File size: 4,720 Bytes
b725fa5
 
 
 
 
 
 
3b9ae48
b725fa5
 
f856ca4
d53346f
b725fa5
 
d53346f
b725fa5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6e46312
1dd55eb
b725fa5
0c68f01
b725fa5
3b9ae48
b725fa5
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
const os = require('os');
const bytes = require('bytes');
const logger = require('morgan');
const express = require('express');
const puppeteer = require('puppeteer');
const CharacterAI = require('node_characterai');
const Parser = require('node_characterai/parser');

const characterAI = new CharacterAI();
characterAI.puppeteerPath = puppeteer.executablePath();

async function char() {
    // Authenticate with Character AI using the provided token
    await characterAI.authenticateWithToken("cf4ac86a23c0c415caace8a912dd7bd7bdeec73a");

    const app = express();
    app.set('json spaces', 4);
    app.use(logger('dev'));

    // Endpoint for root
    app.all('/', (req, res) => {
        const obj = {};
        const used = process.memoryUsage();
        for (let key in used) obj[key] = formatSize(used[key]);

        const totalmem = os.totalmem();
        const freemem = os.freemem();
        obj.memoryUsage = `${formatSize(totalmem - freemem)} / ${formatSize(totalmem)}`;

        res.json({
            success: true,
            message: 'Free API!!',
            status: obj
        });
    });

    // Endpoint for chatting with a character
    app.get('/api', async (req, res) => {
        try {
            let { characterId, text, sessionId } = req.query;
            if (!characterId) return res.json({ success: false, message: 'Input parameter characterId' });
            if (!text) return res.json({ success: false, message: 'Input parameter text' });

            // Create a new session if one does not exist
            if (!sessionId) {
                const request = await characterAI.requester.request('https://beta.character.ai/chat/history/create/', {
                    headers: characterAI.getHeaders(),
                    method: 'POST',
                    body: Parser.stringify({ character_external_id: characterId })
                });
                if (!request.ok()) return res.json({ success: false, message: 'Couldn\'t create a new chat' });

                const json = await Parser.parseJSON(request);
                sessionId = json.external_id;
            }

            // Create or continue a chat
            const chat = await characterAI.createOrContinueChat(characterId, sessionId);
            const response = await chat.sendAndAwaitResponse(text, true);
            const urlAvatar = `https://characterai.io/i/80/static/avatars/${response.srcAvatarFileName}`;

            delete response.chat;
            res.json({
                success: true,
                message: '',
                result: { ...response, urlAvatar, sessionId }
            });
        } catch (e) {
            console.error(e); // Use console.error for logging errors
            res.json({ error: true, message: 'Internal Server Error' });
        }
    });

    // Endpoint to fetch character info
    app.get('/api/chara/info', async (req, res) => {
        try {
            const { characterId } = req.query;
            if (!characterId) return res.json({ success: false, message: 'Input parameter characterId' });

            const result = await characterAI.fetchCharacterInfo(characterId);
            if (!result) return res.json({ success: false, message: 'Invalid characterId' });

            res.json({ success: true, message: '', result });
        } catch (e) {
            console.error(e);
            res.json({ error: true, message: 'Internal Server Error' });
        }
    });

    // Endpoint to search for characters
    app.get('/api/chara/search', async (req, res) => {
        try {
            const { name } = req.query;
            if (!name) return res.json({ success: false, message: 'Input parameter name' });

            const { characters } = await characterAI.searchCharacters(name);
            if (!characters.length) return res.json({ success: false, message: 'Character not found' });

            res.json({ success: true, message: '', result: characters });
        } catch (e) {
            console.error(e);
            res.json({ error: true, message: 'Internal Server Error' });
        }
    });

    // Your existing routes...

    // Start the server
    const PORT = process.env.PORT || 7860;
    app.listen(PORT, () => {
        console.log('App running on port', PORT);

        // Restart function every 6 hours (21600000 milliseconds)
        setInterval(() => {
            console.log('Restarting application...');
            process.exit(0); // Exit the process to trigger restart (Hugging Face may automatically restart the app)
        }, 21600000); // 6 hours in milliseconds
    });
}

char(); 

// Utility function to format sizes
function formatSize(num) {
    return bytes(+num, { unitSeparator: ' ' });
}