@quangnv13/nonstop 1.0.0

package/dist/runtime.js

@@ -0,0 +1,622 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonstopRuntime = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const bot_js_1 = require("./bot.js");
+const config_js_1 = require("./config.js");
+const logger_js_1 = require("./logger.js");
+const runtime_state_js_1 = require("./runtime-state.js");
+const session_delivery_js_1 = require("./session-delivery.js");
+const session_output_js_1 = require("./session-output.js");
+const store_js_1 = require("./store.js");
+const terminal_js_1 = require("./terminal.js");
+class NonstopRuntime {
+    config;
+    mode;
+    startedAt = new Date().toISOString();
+    lastError = null;
+    workspaces = (0, store_js_1.loadWorkspaces)();
+    activeSession = null;
+    activeDriverRef = { current: null };
+    outputBuffer = { current: '' };
+    terminalState = createTerminalState();
+    outputTicker = null;
+    actionOutputTimeout = null;
+    heartbeatTicker = null;
+    onSessionOutputPush = null;
+    bot = null;
+    constructor(config, mode) {
+        this.config = config;
+        this.mode = mode;
+    }
+    getStatus() {
+        return {
+            pid: process.pid,
+            startedAt: this.startedAt,
+            lastHeartbeatAt: new Date().toISOString(),
+            mode: this.mode,
+            clientName: this.config.clientName || os.hostname() || 'LocalClient',
+            botRunning: this.bot !== null,
+            workspaceCount: this.workspaces.length,
+            activeSession: this.activeSession,
+            lastError: this.lastError
+        };
+    }
+    getWorkspaces() {
+        return this.workspaces;
+    }
+    saveWorkspaces(nextWorkspaces) {
+        this.workspaces = [...nextWorkspaces];
+        (0, store_js_1.saveWorkspaces)(this.workspaces);
+        this.writeHeartbeat();
+    }
+    getActiveSession() {
+        return this.activeSession;
+    }
+    getConfig() {
+        return this.config;
+    }
+    async saveConfig(nextConfig) {
+        const tokenChanged = this.config.telegramBotToken !== nextConfig.telegramBotToken;
+        this.config = nextConfig;
+        (0, config_js_1.saveConfigToDisk)(nextConfig);
+        (0, config_js_1.applyConfigToProcessEnv)(nextConfig);
+        this.writeHeartbeat();
+        if (tokenChanged) {
+            setTimeout(() => {
+                void this.restartBot();
+            }, 1000);
+        }
+    }
+    async restartBot() {
+        logger_js_1.logger.info('Restarting Telegram bot due to token change...');
+        await this.stopBot();
+        await this.startBot();
+    }
+    async startBot() {
+        if (this.bot) {
+            return;
+        }
+        logger_js_1.logger.info('nonstop runtime bootstrap complete', {
+            clientName: this.config.clientName,
+            telegramUsername: this.config.telegramUsername,
+            workspaceCount: this.workspaces.length,
+            supportedPresets: terminal_js_1.SUPPORTED_PRESETS,
+            mode: this.mode
+        });
+        this.bot = (0, bot_js_1.createBotRuntime)({
+            getConfig: () => this.getConfig(),
+            saveConfig: async (config) => {
+                await this.saveConfig(config);
+            },
+            getWorkspaces: () => this.getWorkspaces(),
+            saveWorkspaces: (workspaces) => this.saveWorkspaces(workspaces),
+            getActiveSession: () => this.getActiveSession(),
+            startSession: async (chatId, workspaceId, preset) => {
+                await this.startSession(chatId, this.resolveWorkspaceById(workspaceId), preset);
+            },
+            stopSession: async () => this.stopSession(),
+            sendInput: (data) => this.sendSessionInput(data),
+            sendKey: (key) => this.sendSessionKey(key),
+            setInputMode: (inputMode) => this.setSessionInputMode(inputMode),
+            setAutoEnter: (autoEnter) => this.setSessionAutoEnter(autoEnter)
+        });
+        this.setSessionOutputPushCallback(async (chatId, text, options) => {
+            await this.bot?.pushSessionOutput(chatId, text, options);
+        });
+        // Ghi heartbeat TRƯỚC khi bot connect để UI polling nhận ngay trạng thái RUNNING
+        this.startHeartbeat();
+        await this.bot.start({
+            onStart: async (botInfo) => {
+                logger_js_1.logger.info('Telegram bot đã khởi động', {
+                    username: botInfo.username,
+                    mode: this.mode
+                });
+                // Gửi thông báo hello tới Telegram
+                const lastChatId = (0, bot_js_1.loadLastChatId)();
+                if (lastChatId && this.bot) {
+                    try {
+                        await this.bot.pushSessionOutput(lastChatId, `✅ nonstop client đã khởi động thành công và đang chạy!\n🖥 Client: ${this.config.clientName}`);
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        });
+    }
+    async stopBot() {
+        await this.stopSession();
+        if (this.bot) {
+            await this.bot.stop();
+            this.bot = null;
+        }
+        if (this.heartbeatTicker) {
+            clearInterval(this.heartbeatTicker);
+            this.heartbeatTicker = null;
+        }
+        (0, runtime_state_js_1.clearRuntimeState)();
+    }
+    setSessionInputMode(inputMode) {
+        if (this.activeSession) {
+            this.activeSession.inputMode = inputMode;
+            this.writeHeartbeat();
+        }
+    }
+    setSessionAutoEnter(autoEnter) {
+        if (this.activeSession) {
+            this.activeSession.autoEnter = autoEnter;
+            this.writeHeartbeat();
+        }
+    }
+    async startSession(chatId, workspace, preset) {
+        if (this.activeSession?.status === 'running') {
+            throw new Error(`Session "${this.activeSession.sessionId}" is already running.`);
+        }
+        const cwd = path.resolve(workspace.path);
+        if (!fs.existsSync(cwd)) {
+            throw new Error(`Workspace path "${cwd}" does not exist.`);
+        }
+        const { command, args } = (0, terminal_js_1.resolvePreset)(preset);
+        const sessionId = createSessionId(preset);
+        this.resetOutputRuntime();
+        const nextSession = {
+            sessionId,
+            preset,
+            cwd,
+            status: 'running',
+            listenerChatId: chatId,
+            lastSentFinalText: '',
+            inputMode: true,
+            autoEnter: true
+        };
+        logger_js_1.logger.info('Starting local session', {
+            sessionId,
+            preset,
+            chatId,
+            cwd,
+            command,
+            args
+        });
+        try {
+            const driver = new terminal_js_1.NodePtyTerminalDriver(command, args, cwd);
+            this.activeSession = nextSession;
+            this.activeDriverRef.current = driver;
+            this.writeHeartbeat();
+            driver.onData((chunk) => {
+                this.bufferOutput(chunk);
+            });
+            driver.onExit((code, signal) => {
+                void this.handleDriverExit(sessionId, code, signal);
+            });
+        }
+        catch (error) {
+            this.activeSession = null;
+            this.activeDriverRef.current = null;
+            this.resetOutputRuntime();
+            this.lastError = error instanceof Error ? error.message : String(error);
+            this.writeHeartbeat();
+            throw error;
+        }
+    }
+    async stopSession() {
+        const session = this.activeSession;
+        if (!session || session.status !== 'running') {
+            return;
+        }
+        session.status = 'stopped';
+        const driver = this.activeDriverRef.current;
+        this.activeDriverRef.current = null;
+        if (driver) {
+            driver.kill();
+        }
+        await this.flushOutput(true);
+        this.resetOutputRuntime();
+        this.activeSession = null;
+        this.writeHeartbeat();
+        logger_js_1.logger.info('Stopped local session', {
+            sessionId: session.sessionId
+        });
+    }
+    sendSessionInput(data) {
+        const driver = this.activeDriverRef.current;
+        if (!driver || this.activeSession?.status !== 'running') {
+            logger_js_1.logger.warn('Dropping session input because no active session is running', {
+                length: data.length
+            });
+            return;
+        }
+        driver.write(data);
+    }
+    sendSessionKey(key) {
+        const driver = this.activeDriverRef.current;
+        const session = this.activeSession;
+        if (!driver || !session || session.status !== 'running') {
+            logger_js_1.logger.warn('Dropping session key because no active session is running', { key });
+            return;
+        }
+        const input = resolveKeyInput(key, session.preset);
+        if (!input) {
+            logger_js_1.logger.warn('Ignoring unsupported session key', {
+                key,
+                preset: session.preset
+            });
+            return;
+        }
+        driver.write(input);
+        if (['send_escape', 'send_enter', 'send_up', 'send_down'].includes(key)) {
+            if (this.outputTicker) {
+                clearInterval(this.outputTicker);
+                this.outputTicker = null;
+            }
+            if (this.actionOutputTimeout) {
+                clearTimeout(this.actionOutputTimeout);
+                this.actionOutputTimeout = null;
+            }
+            this.actionOutputTimeout = setTimeout(async () => {
+                this.actionOutputTimeout = null;
+                await this.flushOutput(true);
+                this.ensureOutputTicker();
+            }, 5000);
+        }
+    }
+    resolveWorkspaceById(workspaceId) {
+        const workspace = this.workspaces.find((candidate) => candidate.id === workspaceId);
+        if (!workspace) {
+            throw new Error(`Workspace "${workspaceId}" not found.`);
+        }
+        return workspace;
+    }
+    setSessionOutputPushCallback(callback) {
+        this.onSessionOutputPush = callback;
+    }
+    startHeartbeat() {
+        this.writeHeartbeat();
+        if (this.heartbeatTicker) {
+            clearInterval(this.heartbeatTicker);
+        }
+        this.heartbeatTicker = setInterval(() => {
+            this.writeHeartbeat();
+        }, 2000);
+    }
+    writeHeartbeat() {
+        (0, runtime_state_js_1.saveRuntimeState)(this.getStatus());
+    }
+    async handleDriverExit(sessionId, code, signal) {
+        const session = this.activeSession;
+        if (!session || session.sessionId !== sessionId || session.status !== 'running') {
+            return;
+        }
+        session.status = 'stopped';
+        this.activeDriverRef.current = null;
+        await this.flushOutput(true);
+        this.resetOutputRuntime();
+        this.activeSession = null;
+        this.writeHeartbeat();
+        logger_js_1.logger.warn('Local PTY session exited', {
+            sessionId,
+            code,
+            signal
+        });
+        if (this.onSessionOutputPush) {
+            await this.onSessionOutputPush(session.listenerChatId, `Session \`${sessionId}\` exited with code \`${code}\`.`);
+        }
+    }
+    bufferOutput(chunk) {
+        if (!this.activeSession) {
+            return;
+        }
+        this.outputBuffer.current += chunk;
+        applyTerminalOutput(this.terminalState, chunk, this.config.maxRenderLines);
+        this.ensureOutputTicker();
+    }
+    async flushOutput(forceSnapshot = false) {
+        const session = this.activeSession;
+        if (!session) {
+            this.outputBuffer.current = '';
+            return;
+        }
+        const text = this.outputBuffer.current;
+        this.outputBuffer.current = '';
+        const promptDetectionText = stripAnsi(text);
+        const snapshot = renderTerminalSnapshot(this.terminalState, this.config.maxOutputLines);
+        const finalText = snapshot || limitLines(promptDetectionText, this.config.maxOutputLines);
+        if (!text && !forceSnapshot) {
+            return;
+        }
+        if (!finalText.trim()) {
+            return;
+        }
+        // Lọc loading spinner và window title residue
+        if (isSpinnerOrNoiseOutput(finalText)) {
+            return;
+        }
+        if ((0, session_delivery_js_1.shouldSkipSessionOutput)(session.lastSentFinalText, finalText)) {
+            return;
+        }
+        const messages = (0, session_output_js_1.buildSessionOutputMessages)({
+            sessionId: session.sessionId,
+            snapshot: finalText,
+            inputMode: session.inputMode,
+            autoEnter: session.autoEnter
+        });
+        if (!this.onSessionOutputPush) {
+            session.lastSentFinalText = finalText;
+            return;
+        }
+        for (const message of messages) {
+            await this.onSessionOutputPush(session.listenerChatId, message.text, message.options);
+        }
+        session.lastSentFinalText = finalText;
+    }
+    ensureOutputTicker() {
+        if (this.outputTicker || this.actionOutputTimeout) {
+            return;
+        }
+        this.outputTicker = setInterval(() => {
+            void this.flushOutput(true);
+        }, this.config.outputInterval);
+    }
+    resetOutputRuntime() {
+        if (this.outputTicker) {
+            clearInterval(this.outputTicker);
+            this.outputTicker = null;
+        }
+        if (this.actionOutputTimeout) {
+            clearTimeout(this.actionOutputTimeout);
+            this.actionOutputTimeout = null;
+        }
+        this.outputBuffer.current = '';
+        this.terminalState = createTerminalState();
+        if (this.activeSession) {
+            this.activeSession.lastSentFinalText = '';
+        }
+    }
+}
+exports.NonstopRuntime = NonstopRuntime;
+function createSessionId(preset) {
+    return `${preset}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function resolveKeyInput(key, preset) {
+    switch (key) {
+        case 'send_up':
+        case 'up':
+            return '\u001b[A';
+        case 'send_down':
+        case 'down':
+            return '\u001b[B';
+        case 'send_enter':
+        case 'enter':
+            return '\r';
+        case 'send_escape':
+        case 'escape':
+        case 'interrupt':
+            if (preset === 'codex' || preset === 'antigravity') {
+                return '\u001b';
+            }
+            return null;
+        default:
+            return null;
+    }
+}
+function limitLines(text, maxLines) {
+    const lines = text.split(/\r?\n/);
+    if (lines.length <= maxLines) {
+        return text;
+    }
+    return lines.slice(-maxLines).join('\n');
+}
+function stripAnsi(text) {
+    const ansiRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+    return text.replace(ansiRegex, '');
+}
+function createTerminalState() {
+    return { lines: [''], row: 0, col: 0, savedRow: 0, savedCol: 0 };
+}
+function ensureLine(state, row) {
+    while (state.lines.length <= row) {
+        state.lines.push('');
+    }
+}
+function writeAt(state, char) {
+    ensureLine(state, state.row);
+    const current = state.lines[state.row];
+    const padded = current.padEnd(state.col, ' ');
+    state.lines[state.row] = padded.slice(0, state.col) + char + padded.slice(state.col + 1);
+    state.col += 1;
+}
+function clearLineFromCursor(state) {
+    ensureLine(state, state.row);
+    state.lines[state.row] = state.lines[state.row].slice(0, state.col);
+}
+function trimTerminalHistory(state, maxRenderLines) {
+    if (state.lines.length <= maxRenderLines) {
+        return;
+    }
+    const removeCount = state.lines.length - maxRenderLines;
+    state.lines = state.lines.slice(removeCount);
+    state.row = Math.max(0, state.row - removeCount);
+    state.savedRow = Math.max(0, state.savedRow - removeCount);
+}
+function handleCsiSequence(state, paramsRaw, command) {
+    const privateMode = paramsRaw.startsWith('?');
+    const normalized = privateMode ? paramsRaw.slice(1) : paramsRaw;
+    const params = normalized.length > 0
+        ? normalized.split(';').map((value) => {
+            const parsed = parseInt(value, 10);
+            return Number.isFinite(parsed) ? parsed : 0;
+        })
+        : [];
+    switch (command) {
+        case 'A':
+            state.row = Math.max(0, state.row - (params[0] || 1));
+            return;
+        case 'B':
+            state.row += params[0] || 1;
+            ensureLine(state, state.row);
+            return;
+        case 'C':
+            state.col += params[0] || 1;
+            return;
+        case 'D':
+            state.col = Math.max(0, state.col - (params[0] || 1));
+            return;
+        case 'G':
+            state.col = Math.max(0, (params[0] || 1) - 1);
+            return;
+        case 'H':
+        case 'f':
+            state.row = Math.max(0, (params[0] || 1) - 1);
+            state.col = Math.max(0, (params[1] || 1) - 1);
+            ensureLine(state, state.row);
+            return;
+        case 'J':
+            if ((params[0] || 0) === 2) {
+                state.lines = [''];
+                state.row = 0;
+                state.col = 0;
+                state.savedRow = 0;
+                state.savedCol = 0;
+            }
+            return;
+        case 'K':
+            clearLineFromCursor(state);
+            return;
+        case 's':
+            state.savedRow = state.row;
+            state.savedCol = state.col;
+            return;
+        case 'u':
+            state.row = state.savedRow;
+            state.col = state.savedCol;
+            ensureLine(state, state.row);
+            return;
+        default:
+            return;
+    }
+}
+function applyTerminalOutput(state, chunk, maxRenderLines) {
+    let index = 0;
+    while (index < chunk.length) {
+        const char = chunk[index];
+        if (char === '\u001b') {
+            const next = chunk[index + 1];
+            if (next === '[') {
+                const match = chunk.slice(index).match(/^\u001b\[([0-9;?]*)([@-~])/);
+                if (match) {
+                    handleCsiSequence(state, match[1], match[2]);
+                    index += match[0].length;
+                    continue;
+                }
+            }
+            if (next === ']') {
+                const belIndex = chunk.indexOf('\u0007', index + 2);
+                if (belIndex !== -1) {
+                    index = belIndex + 1;
+                    continue;
+                }
+            }
+            index += 1;
+            continue;
+        }
+        if (char === '\r') {
+            state.col = 0;
+            index += 1;
+            continue;
+        }
+        if (char === '\n') {
+            state.row += 1;
+            state.col = 0;
+            ensureLine(state, state.row);
+            trimTerminalHistory(state, maxRenderLines);
+            index += 1;
+            continue;
+        }
+        if (char === '\b') {
+            state.col = Math.max(0, state.col - 1);
+            index += 1;
+            continue;
+        }
+        if (char === '\t') {
+            const spaces = 4 - (state.col % 4);
+            for (let i = 0; i < spaces; i += 1) {
+                writeAt(state, ' ');
+            }
+            index += 1;
+            continue;
+        }
+        if (char >= ' ') {
+            writeAt(state, char);
+        }
+        index += 1;
+    }
+    trimTerminalHistory(state, maxRenderLines);
+}
+function renderTerminalSnapshot(state, maxOutputLines) {
+    const rawText = state.lines
+        .map((line) => line.replace(/\s+$/g, ''))
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    if (!rawText) {
+        return '';
+    }
+    const rawLines = rawText.split('\n');
+    const nonEmptyLines = rawLines.filter((line) => line.trim().length > 0);
+    const commonIndent = nonEmptyLines.length > 0
+        ? Math.min(...nonEmptyLines.map((line) => line.match(/^ */)?.[0].length ?? 0))
+        : 0;
+    return limitLines(rawLines.map((line) => line.slice(commonIndent)).join('\n').trim(), maxOutputLines);
+}
+/**
+ * Lọc bỏ output chỉ chứa loading spinner, window title, hoặc ký tự thừa trước khi gửi Telegram.
+ */
+function isSpinnerOrNoiseOutput(text) {
+    const lines = text.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+    if (lines.length === 0)
+        return true;
+    // Nếu tất cả các dòng đều là noise thì bỏ
+    const noisePatterns = [
+        /^[\u2800-\u28FF\s]+$/, // Braille spinner
+        /^\]0;/, // Window title sequence
+        /^q{1,4}\d?\w{0,5}$/, // "q", "q8", "qrk" etc.
+        /^[\s\u2800-\u28FF\]0;q\r\n]{1,20}$/ // Short mixed noise
+    ];
+    const allNoise = lines.every(line => noisePatterns.some(pattern => pattern.test(line)));
+    return allNoise;
+}

package/dist/session-controls.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSessionActionMarkup = buildSessionActionMarkup;
+function buildSessionActionMarkup(options) {
+    const inputMode = options.inputMode ?? true;
+    const autoEnter = options.autoEnter ?? true;
+    const rows = [
+        [
+            {
+                text: inputMode ? '⌨️ Input OFF' : '⌨️ Input ON',
+                callback_data: `session_cmd:${options.sessionId}:toggle_input`
+            },
+            {
+                text: autoEnter ? '⏎ AutoEnter OFF' : '⏎ AutoEnter ON',
+                callback_data: `session_cmd:${options.sessionId}:toggle_enter`
+            },
+            {
+                text: '🔄 Refresh',
+                callback_data: `session_cmd:${options.sessionId}:refresh`
+            }
+        ],
+        [
+            {
+                text: '⛔ Esc',
+                callback_data: `session_cmd:${options.sessionId}:send_escape`
+            },
+            {
+                text: '⬆️ Up',
+                callback_data: `session_cmd:${options.sessionId}:send_up`
+            },
+            {
+                text: '⬇️ Down',
+                callback_data: `session_cmd:${options.sessionId}:send_down`
+            }
+        ],
+        [
+            {
+                text: '⏎ Enter',
+                callback_data: `session_cmd:${options.sessionId}:send_enter`
+            },
+            {
+                text: '🛑 Stop',
+                callback_data: `session_cmd:${options.sessionId}:stop`
+            }
+        ]
+    ];
+    if (options.includeBackButton) {
+        rows.push([
+            {
+                text: '⬅️ Back',
+                callback_data: 'sessions_list'
+            }
+        ]);
+    }
+    return { inline_keyboard: rows };
+}

package/dist/session-delivery.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkipSessionOutput = shouldSkipSessionOutput;
+function shouldSkipSessionOutput(previousFinalText, nextFinalText) {
+    return Boolean(previousFinalText) && previousFinalText === nextFinalText;
+}