@quangnv13/nonstop 1.0.14 → 1.0.16

package/dist/index.js

@@ -6,6 +6,7 @@ const logger_js_1 = require("./logger.js");
 const runtime_js_1 = require("./runtime.js");
 const ui_js_1 = require("./ui.js");
 const runtime_manager_js_1 = require("./runtime-manager.js");
+const runtime_state_js_1 = require("./runtime-state.js");
 async function main() {
     (0, config_js_1.ensureEnvExampleFile)();
     const args = new Set(process.argv.slice(2));
@@ -14,10 +15,11 @@ async function main() {
     const config = (0, config_js_1.loadConfigFromDisk)();
     (0, config_js_1.applyConfigToProcessEnv)(config);
     if (isStop) {
+        (0, runtime_state_js_1.saveShouldRunState)(false);
         const status = (0, runtime_manager_js_1.getRuntimeStatus)();
         if (status.running && status.snapshot) {
             try {
-                const msg = (0, runtime_manager_js_1.stopBackgroundRuntime)(status.snapshot);
+                const msg = (0, runtime_manager_js_1.stopBackgroundRuntime)(status.snapshot, config.language);
                 console.log(msg);
             }
             catch (error) {
@@ -26,7 +28,9 @@ async function main() {
             }
         }
         else {
-            console.log('nonstop background runtime is not running.');
+            console.log(config.language === 'vi'
+                ? '⚠ Runtime nền của nonstop không đang chạy.'
+                : 'nonstop background runtime is not running.');
         }
         return;
     }
@@ -39,6 +43,8 @@ async function main() {
             process.exitCode = 1;
             return;
         }
+        (0, runtime_state_js_1.saveShouldRunState)(true);
+        void (0, runtime_manager_js_1.checkUpdateOnStartup)(true, config.language);
         const runtime = new runtime_js_1.NonstopRuntime(config, 'background');
         await runtime.startBot();
         const shutdown = async () => {
@@ -64,6 +70,22 @@ async function main() {
         });
         return;
     }
+    // Auto-restart if it was running but is not currently running (e.g. after system restart)
+    const status = (0, runtime_manager_js_1.getRuntimeStatus)();
+    if (!status.running && (0, runtime_state_js_1.loadShouldRunState)()) {
+        console.log(config.language === 'vi'
+            ? '↻ Phát hiện trạng thái trước đó đang chạy. Đang tự khởi động lại runtime nền...'
+            : '↻ Detected previous running state. Auto-restarting background runtime...');
+        try {
+            const msg = (0, runtime_manager_js_1.startBackgroundRuntime)(config.language);
+            console.log(msg);
+            // Chờ một chút để tiến trình nền khởi động và ghi state/heartbeat
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+        }
+    }
     await (0, ui_js_1.launchControlCenter)();
 }
 void main();

package/dist/runtime-manager.js

@@ -37,9 +37,13 @@ exports.getRuntimeStatus = getRuntimeStatus;
 exports.getEntryScriptPath = getEntryScriptPath;
 exports.startBackgroundRuntime = startBackgroundRuntime;
 exports.stopBackgroundRuntime = stopBackgroundRuntime;
+exports.getCurrentVersion = getCurrentVersion;
+exports.checkForUpdate = checkForUpdate;
+exports.checkUpdateOnStartup = checkUpdateOnStartup;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const runtime_state_js_1 = require("./runtime-state.js");
 function getRuntimeStatus() {
     const snapshot = (0, runtime_state_js_1.loadRuntimeState)();
@@ -68,25 +72,126 @@ function getEntryScriptPath() {
     }
     throw new Error('dist/index.js not found. Please ensure the project is built.');
 }
-function startBackgroundRuntime() {
+function startBackgroundRuntime(language) {
     const entryScriptPath = getEntryScriptPath();
+    (0, runtime_state_js_1.saveShouldRunState)(true);
     const child = (0, child_process_1.spawn)(process.execPath, [entryScriptPath, '--background'], {
         cwd: process.cwd(),
         detached: true,
         stdio: 'ignore'
     });
     child.unref();
-    return `Started nonstop background runtime (pid ${child.pid ?? 'unknown'}).`;
+    const pid = child.pid ?? 'unknown';
+    return language === 'vi'
+        ? `✓ Đã khởi chạy runtime nền của nonstop (pid ${pid}).`
+        : `✓ Started nonstop background runtime (pid ${pid}).`;
 }
-function stopBackgroundRuntime(snapshot) {
+function stopBackgroundRuntime(snapshot, language) {
+    const isVi = language === 'vi';
     if (!snapshot || !(0, runtime_state_js_1.isPidRunning)(snapshot.pid)) {
-        return 'Background runtime is not running.';
+        return isVi ? '⚠ Runtime nền không đang chạy.' : 'Background runtime is not running.';
     }
+    (0, runtime_state_js_1.saveShouldRunState)(false);
     try {
         process.kill(snapshot.pid);
-        return `Stopped nonstop background runtime (${snapshot.pid}).`;
+        return isVi
+            ? `✓ Đã dừng runtime nền của nonstop (${snapshot.pid}).`
+            : `✓ Stopped nonstop background runtime (${snapshot.pid}).`;
     }
     catch (error) {
-        throw new Error(`Failed to stop background runtime (${snapshot.pid}): ${error instanceof Error ? error.message : String(error)}`);
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        throw new Error(isVi
+            ? `❌ Lỗi khi dừng runtime nền (${snapshot.pid}): ${errorMsg}`
+            : `Failed to stop background runtime (${snapshot.pid}): ${errorMsg}`);
+    }
+}
+function getCurrentVersion() {
+    try {
+        const pkgPath = path.join(__dirname, '..', 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        return pkg.version;
+    }
+    catch {
+        return '1.0.13';
+    }
+}
+function checkForUpdate(currentVersion) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            resolve(null);
+        }, 4000);
+        (0, child_process_1.exec)('npm view @quangnv13/nonstop version', (error, stdout) => {
+            clearTimeout(timer);
+            if (error) {
+                resolve(null);
+                return;
+            }
+            const latest = stdout.trim();
+            if (latest && latest !== currentVersion) {
+                resolve(latest);
+            }
+            else {
+                resolve(null);
+            }
+        });
+    });
+}
+async function checkUpdateOnStartup(isBackground, language) {
+    const currentVersion = getCurrentVersion();
+    const latestVersion = await checkForUpdate(currentVersion);
+    if (latestVersion) {
+        if (isBackground) {
+            promptUpgradeBackground(currentVersion, latestVersion, language);
+        }
+    }
+}
+function promptUpgradeBackground(currentVersion, latestVersion, language) {
+    const platform = os.platform();
+    const isVi = language === 'vi';
+    if (platform === 'win32') {
+        const title = isVi ? 'Cập nhật nonstop' : 'nonstop Update';
+        const msg = isVi
+            ? `Có phiên bản mới của nonstop: ${latestVersion} (Hiện tại: ${currentVersion}). Bạn có muốn nâng cấp không? (y/n): `
+            : `A new version of nonstop is available: ${latestVersion} (Current: ${currentVersion}). Do you want to upgrade? (y/n): `;
+        const upgradingMsg = isVi ? 'Đang nâng cấp @quangnv13/nonstop lên phiên bản mới nhất...' : 'Upgrading @quangnv13/nonstop to the latest version...';
+        const successMsg = isVi ? 'Cập nhật nonstop thành công! Nhấn phím bất kỳ để đóng...' : 'nonstop update successful! Press any key to close...';
+        const failMsg = isVi ? 'Cập nhật nonstop thất bại.' : 'nonstop update failed.';
+        const skippedMsg = isVi ? 'Đã bỏ qua cập nhật nonstop.' : 'nonstop update skipped.';
+        const psCommand = `
+      $Host.UI.RawUI.WindowTitle = '${title}';
+      Write-Host '${msg}' -NoNewline -ForegroundColor Yellow;
+      $choice = Read-Host;
+      if ($choice -eq 'y' -or $choice -eq 'yes') {
+        Write-Host '${upgradingMsg}' -ForegroundColor Blue;
+        npm install -g @quangnv13/nonstop@latest;
+        if ($LASTEXITCODE -eq 0) {
+          Write-Host '${successMsg}' -ForegroundColor Green;
+        } else {
+          Write-Host '${failMsg}' -ForegroundColor Red;
+          Start-Sleep -Seconds 3;
+        }
+        $null = [Console]::ReadKey();
+      } else {
+        Write-Host '${skippedMsg}' -ForegroundColor Gray;
+        Start-Sleep -Seconds 1;
+      }
+    `.replace(/\r?\n/g, ' ').trim();
+        const cmd = 'cmd.exe';
+        const args = [
+            '/c',
+            'start',
+            'powershell',
+            '-NoProfile',
+            '-Command',
+            psCommand
+        ];
+        (0, child_process_1.spawn)(cmd, args, {
+            detached: true,
+            stdio: 'ignore',
+            shell: true
+        }).unref();
+    }
+    else {
+        console.log(`Update available: ${latestVersion} (Current: ${currentVersion})`);
     }
 }

package/dist/runtime-state.js

@@ -34,17 +34,38 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.saveRuntimeState = saveRuntimeState;
+exports.saveShouldRunState = saveShouldRunState;
+exports.loadShouldRunState = loadShouldRunState;
 exports.loadRuntimeState = loadRuntimeState;
 exports.clearRuntimeState = clearRuntimeState;
 exports.isPidRunning = isPidRunning;
 exports.getRuntimeStatePath = getRuntimeStatePath;
+exports.getIpcSocketPath = getIpcSocketPath;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const RUNTIME_STATE_PATH = path.join(process.cwd(), 'data', 'runtime-state.json');
+const SHOULD_RUN_PATH = path.join(process.cwd(), 'data', 'runtime-should-run.json');
 function saveRuntimeState(snapshot) {
     fs.mkdirSync(path.dirname(RUNTIME_STATE_PATH), { recursive: true });
     fs.writeFileSync(RUNTIME_STATE_PATH, JSON.stringify(snapshot, null, 2), 'utf8');
 }
+function saveShouldRunState(shouldRun) {
+    fs.mkdirSync(path.dirname(SHOULD_RUN_PATH), { recursive: true });
+    fs.writeFileSync(SHOULD_RUN_PATH, JSON.stringify({ shouldRun }, null, 2), 'utf8');
+}
+function loadShouldRunState() {
+    if (!fs.existsSync(SHOULD_RUN_PATH)) {
+        return false;
+    }
+    try {
+        const data = JSON.parse(fs.readFileSync(SHOULD_RUN_PATH, 'utf8'));
+        return !!data.shouldRun;
+    }
+    catch {
+        return false;
+    }
+}
 function loadRuntimeState() {
     if (!fs.existsSync(RUNTIME_STATE_PATH)) {
         return null;
@@ -76,3 +97,12 @@ function isPidRunning(pid) {
 function getRuntimeStatePath() {
     return RUNTIME_STATE_PATH;
 }
+function getIpcSocketPath() {
+    const username = os.userInfo().username || 'user';
+    if (process.platform === 'win32') {
+        return `\\\\.\\pipe\\nonstop-ipc-${username}`;
+    }
+    else {
+        return path.join(process.cwd(), 'data', `nonstop-ipc-${username}.sock`);
+    }
+}

package/dist/runtime.js

@@ -41,6 +41,7 @@ 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 net = __importStar(require("net"));
 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");
@@ -60,6 +61,8 @@ class NonstopRuntime {
     heartbeatTicker = null;
     onSessionOutputPush = null;
     bot = null;
+    ipcServer = null;
+    activeIpcSockets = new Set();
     constructor(config, mode) {
         this.config = config;
         this.mode = mode;
@@ -112,6 +115,15 @@ class NonstopRuntime {
         if (this.bot) {
             return;
         }
+        const ipcPath = path.join(process.cwd(), 'data', 'ipc-command.json');
+        if (fs.existsSync(ipcPath)) {
+            try {
+                fs.unlinkSync(ipcPath);
+            }
+            catch {
+                // ignore
+            }
+        }
         logger_js_1.logger.info('nonstop runtime bootstrap complete', {
             clientName: this.config.clientName,
             telegramUsername: this.config.telegramUsername,
@@ -142,17 +154,21 @@ class NonstopRuntime {
         });
         // Ghi heartbeat TRƯỚC khi bot connect để UI polling nhận ngay trạng thái RUNNING
         this.startHeartbeat();
+        this.startIpcServer();
         await this.bot.start({
             onStart: async (botInfo) => {
-                logger_js_1.logger.info('Telegram bot đã khởi động', {
+                logger_js_1.logger.info('Telegram bot started', {
                     username: botInfo.username,
                     mode: this.mode
                 });
-                // Gửi thông báo hello tới Telegram
+                // Send startup notification to 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}`);
+                        const startupMsg = this.config.language === 'vi'
+                            ? `✅ nonstop client đã khởi động thành công và đang chạy!\n🖥 Client: ${this.config.clientName}`
+                            : `✅ nonstop client started successfully and is running!\n🖥 Client: ${this.config.clientName}`;
+                        await this.bot.pushSessionOutput(lastChatId, startupMsg);
                     }
                     catch {
                         // ignore
@@ -171,6 +187,7 @@ class NonstopRuntime {
             clearInterval(this.heartbeatTicker);
             this.heartbeatTicker = null;
         }
+        this.stopIpcServer();
         (0, runtime_state_js_1.clearRuntimeState)();
     }
     setSessionInputMode(inputMode) {
@@ -239,6 +256,7 @@ class NonstopRuntime {
             this.writeHeartbeat();
             driver.onData((chunk) => {
                 this.bufferOutput(chunk);
+                this.broadcastToIpcClients({ type: 'output', data: chunk });
             });
             driver.onExit((code, signal) => {
                 void this.handleDriverExit(sessionId, code, signal);
@@ -322,8 +340,36 @@ class NonstopRuntime {
         }
         this.heartbeatTicker = setInterval(() => {
             this.writeHeartbeat();
+            void this.checkIpcCommands();
         }, 2000);
     }
+    async checkIpcCommands() {
+        const ipcPath = path.join(process.cwd(), 'data', 'ipc-command.json');
+        if (!fs.existsSync(ipcPath)) {
+            return;
+        }
+        try {
+            const content = fs.readFileSync(ipcPath, 'utf8');
+            const cmd = JSON.parse(content);
+            if (cmd.action === 'stop-session') {
+                logger_js_1.logger.info('Received IPC command to stop session via file');
+                await this.stopSession();
+            }
+        }
+        catch (error) {
+            logger_js_1.logger.error('Error handling IPC command', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        finally {
+            try {
+                fs.unlinkSync(ipcPath);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
     writeHeartbeat() {
         (0, runtime_state_js_1.saveRuntimeState)(this.getStatus());
     }
@@ -334,6 +380,7 @@ class NonstopRuntime {
         }
         session.status = 'stopped';
         this.activeDriverRef.current = null;
+        this.broadcastToIpcClients({ type: 'exit', code });
         await this.flushOutput(true);
         this.resetOutputRuntime();
         this.activeSession = null;
@@ -366,6 +413,11 @@ class NonstopRuntime {
         const promptDetectionText = stripAnsi(text);
         const snapshot = renderTerminalSnapshot(this.terminalState, this.config.maxOutputLines);
         const finalText = snapshot || limitLines(promptDetectionText, this.config.maxOutputLines);
+        if (this.activeIpcSockets.size > 0) {
+            // User is active locally. Clear buffer, sync lastSentFinalText, but skip Telegram messaging.
+            session.lastSentFinalText = finalText;
+            return;
+        }
         if (!text && !forceSnapshot) {
             return;
         }
@@ -391,7 +443,14 @@ class NonstopRuntime {
             return;
         }
         for (const message of messages) {
-            await this.onSessionOutputPush(session.listenerChatId, message.text, message.options);
+            try {
+                await this.onSessionOutputPush(session.listenerChatId, message.text, message.options);
+            }
+            catch (err) {
+                logger_js_1.logger.error('Failed to push session output to Telegram', {
+                    error: err instanceof Error ? err.message : String(err)
+                });
+            }
         }
         session.lastSentFinalText = finalText;
     }
@@ -418,6 +477,129 @@ class NonstopRuntime {
             this.activeSession.lastSentFinalText = '';
         }
     }
+    startIpcServer() {
+        if (this.ipcServer)
+            return;
+        const socketPath = (0, runtime_state_js_1.getIpcSocketPath)();
+        if (process.platform !== 'win32') {
+            try {
+                const socketDir = path.dirname(socketPath);
+                if (!fs.existsSync(socketDir)) {
+                    fs.mkdirSync(socketDir, { recursive: true });
+                }
+                if (fs.existsSync(socketPath)) {
+                    fs.unlinkSync(socketPath);
+                }
+            }
+            catch (err) {
+                logger_js_1.logger.error('Failed to unlink existing IPC socket file', { err });
+            }
+        }
+        this.ipcServer = net.createServer((socket) => {
+            logger_js_1.logger.info('IPC client connected to background session');
+            this.activeIpcSockets.add(socket);
+            // Immediately send the current screen snapshot to the newly connected client
+            const snapshot = renderTerminalSnapshot(this.terminalState, this.config.maxRenderLines);
+            const initOutput = '\u001b[2J\u001b[H' + snapshot;
+            socket.write(JSON.stringify({ type: 'output', data: initOutput }) + '\n');
+            let buffer = '';
+            socket.on('data', (data) => {
+                buffer += data.toString();
+                let boundary = buffer.indexOf('\n');
+                while (boundary !== -1) {
+                    const line = buffer.slice(0, boundary).trim();
+                    buffer = buffer.slice(boundary + 1);
+                    if (line) {
+                        try {
+                            const msg = JSON.parse(line);
+                            this.handleIpcClientMessage(msg);
+                        }
+                        catch (err) {
+                            logger_js_1.logger.error('Error parsing IPC client message', { err, line });
+                        }
+                    }
+                    boundary = buffer.indexOf('\n');
+                }
+            });
+            socket.on('error', (err) => {
+                logger_js_1.logger.error('IPC client socket error', { err });
+            });
+            socket.on('close', () => {
+                logger_js_1.logger.info('IPC client disconnected');
+                this.activeIpcSockets.delete(socket);
+                if (this.activeIpcSockets.size === 0) {
+                    // Immediately flush the final state of the session to Telegram
+                    void this.flushOutput(true, true);
+                }
+            });
+        });
+        this.ipcServer.listen(socketPath, () => {
+            logger_js_1.logger.info(`IPC Server listening on ${socketPath}`);
+        });
+        this.ipcServer.on('error', (err) => {
+            logger_js_1.logger.error('IPC Server error', { err });
+        });
+    }
+    handleIpcClientMessage(msg) {
+        if (!msg || typeof msg !== 'object')
+            return;
+        switch (msg.type) {
+            case 'input':
+                if (typeof msg.data === 'string') {
+                    this.sendSessionInput(msg.data);
+                }
+                break;
+            case 'resize':
+                if (typeof msg.cols === 'number' && typeof msg.rows === 'number') {
+                    const driver = this.activeDriverRef.current;
+                    if (driver && this.activeSession?.status === 'running') {
+                        driver.resize(msg.cols, msg.rows);
+                    }
+                }
+                break;
+            default:
+                logger_js_1.logger.warn('Unknown IPC message type', { msg });
+        }
+    }
+    stopIpcServer() {
+        if (this.ipcServer) {
+            for (const socket of this.activeIpcSockets) {
+                try {
+                    socket.destroy();
+                }
+                catch {
+                    // ignore
+                }
+            }
+            this.activeIpcSockets.clear();
+            this.ipcServer.close();
+            this.ipcServer = null;
+            const socketPath = (0, runtime_state_js_1.getIpcSocketPath)();
+            if (process.platform !== 'win32') {
+                try {
+                    if (fs.existsSync(socketPath)) {
+                        fs.unlinkSync(socketPath);
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    broadcastToIpcClients(msg) {
+        if (this.activeIpcSockets.size === 0)
+            return;
+        const packet = JSON.stringify(msg) + '\n';
+        for (const socket of this.activeIpcSockets) {
+            try {
+                socket.write(packet);
+            }
+            catch (err) {
+                logger_js_1.logger.error('Failed to write to IPC client socket', { err });
+            }
+        }
+    }
 }
 exports.NonstopRuntime = NonstopRuntime;
 function createSessionId(preset) {
@@ -437,7 +619,7 @@ function resolveKeyInput(key, preset) {
         case 'send_escape':
         case 'escape':
         case 'interrupt':
-            if (preset === 'codex' || preset === 'antigravity') {
+            if (preset === 'codex' || preset === 'antigravity' || preset === 'claude') {
                 return '\u001b';
             }
             return null;

package/dist/session-controls.js

@@ -9,14 +9,14 @@ function buildSessionActionMarkup(options) {
         [
             {
                 text: inputMode
-                    ? (isVi ? '⌨️ Tắt Input' : '⌨️ Input OFF')
-                    : (isVi ? '⌨️ Bật Input' : '⌨️ Input ON'),
+                    ? (isVi ? '⌨️ Tắt Nhập' : '⌨️ Input OFF')
+                    : (isVi ? '⌨️ Bật Nhập' : '⌨️ Input ON'),
                 callback_data: `session_cmd:${options.sessionId}:toggle_input`
             },
             {
                 text: autoEnter
                     ? (isVi ? '⏎ Tắt AutoEnter' : '⏎ AutoEnter OFF')
-                    : (isVi ? '⏎ Bật AutoEnter' : '⏎ Bật AutoEnter ON'),
+                    : (isVi ? '⏎ Bật AutoEnter' : '⏎ AutoEnter ON'),
                 callback_data: `session_cmd:${options.sessionId}:toggle_enter`
             },
             {

package/dist/terminal.js

@@ -92,7 +92,7 @@ class NodePtyTerminalDriver {
     }
 }
 exports.NodePtyTerminalDriver = NodePtyTerminalDriver;
-exports.SUPPORTED_PRESETS = ['powershell', 'bash', 'codex', 'antigravity'];
+exports.SUPPORTED_PRESETS = ['powershell', 'bash', 'codex', 'antigravity', 'claude'];
 function resolvePreset(presetName) {
     const isWindows = process.platform === 'win32';
     switch (presetName) {
@@ -132,6 +132,19 @@ function resolvePreset(presetName) {
             }
             return { command, args };
         }
+        case 'claude': {
+            const command = process.env.CLAUDE_CMD || 'claude';
+            let args = [];
+            if (process.env.CLAUDE_ARGS) {
+                try {
+                    args = JSON.parse(process.env.CLAUDE_ARGS);
+                }
+                catch {
+                    args = process.env.CLAUDE_ARGS.split(/\s+/).filter(Boolean);
+                }
+            }
+            return { command, args };
+        }
         default:
             throw new Error(`Unsupported preset "${presetName}".`);
     }