@pixelbyte-software/pixcode 1.50.3 → 1.50.5

package/scripts/smoke/hermes-rest-codex-launch.mjs

@@ -84,6 +84,20 @@ const server = createServer(async (req, res) => {
     return;
   }
 
+  if (req.method === 'GET' && url.pathname === '/api/shell/sessions/provider-output') {
+    const launchId = Number(url.searchParams.get('launchId') || 0) || null;
+    res.end(JSON.stringify({
+      active: true,
+      provider: url.searchParams.get('provider') || 'codex',
+      projectPath,
+      launchId,
+      terminalState: 'idle',
+      isBusy: false,
+      output: 'Hermes launched Codex through Pixcode MCP\n\n› ',
+    }));
+    return;
+  }
+
   res.statusCode = 404;
   res.end(JSON.stringify({ error: url.pathname }));
 });

package/scripts/smoke/hermes-settings-commands.mjs

@@ -83,6 +83,66 @@ assert.match(
   /multi-step|piece-by-piece|long-running/i,
   'Pixcode MCP should tell Hermes to send arbitrary multi-step work as visible provider terminal input.',
 );
+assert.match(
+  pixcodeMcpServer,
+  /defaultWaitMs\s*=\s*startupInput \? 180000 : 0/,
+  'Pixcode MCP should wait for visible provider completion by default when startupInput is present.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /launchId/,
+  'Pixcode MCP should tie provider output readback to the terminal launch id.',
+);
+assert.match(
+  serverIndex,
+  /requestedLaunchId[\s\S]+session\.hermesLaunchId === requestedLaunchId/,
+  'Provider output API should filter by Hermes terminal launch id when supplied.',
+);
+assert.match(
+  serverIndex,
+  /lifecycleState/,
+  'Provider output API should expose provider-agnostic PTY lifecycle state instead of relying only on terminal text regex.',
+);
+assert.match(
+  serverIndex,
+  /terminalFailed/,
+  'Provider output API should expose non-zero visible terminal exits as failures for Hermes readback.',
+);
+assert.match(
+  serverIndex,
+  /existingSession[\s\S]+existingSession\.pty/,
+  'Completed visible terminal records should not be reattached as live PTYs.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /terminalFailed/,
+  'Pixcode MCP should tell Hermes when the visible provider terminal failed.',
+);
+assert.match(
+  serverIndex,
+  /const hermesLaunchId = Number\.isFinite\(Number\(data\.hermesLaunchId\)\)/,
+  'Shell backend should persist Hermes terminal launch ids on PTY sessions.',
+);
+assert.match(
+  workbench,
+  /terminalHermesLaunchId/,
+  'Workbench CLI panel should pass Hermes launch ids into provider shells.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /terminalState is busy|terminalState.+busy|terminal to become idle/i,
+  'Pixcode MCP should not summarize the first busy terminal frame as final output.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /READBACK_IDLE_STABLE_MS/,
+  'Pixcode MCP should require a stable idle readback before reporting provider output as final.',
+);
+assert.match(
+  pixcodeMcpServer,
+  /readbackStable/,
+  'Pixcode MCP should mark whether a visible provider readback was stable before Hermes summarizes it.',
+);
 assert.match(
   pixcodeMcpServer,
   /startup input typed into the provider CLI/,

package/scripts/smoke/tunnel-persistence.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const externalAccess = readFileSync('server/services/external-access.js', 'utf8');
+const networkRoutes = readFileSync('server/routes/network.js', 'utf8');
+const serverIndex = readFileSync('server/index.js', 'utf8');
+
+assert.match(
+  externalAccess,
+  /TUNNEL_PERSISTENCE_PATH/,
+  'Tunnel service should persist the user-requested tunnel state outside process memory.',
+);
+assert.match(
+  externalAccess,
+  /persistTunnelPreference/,
+  'Tunnel service should write tunnel start/stop intent to disk.',
+);
+assert.match(
+  externalAccess,
+  /desired:\s*true/,
+  'Starting a tunnel should mark tunnel intent as desired until the user stops it.',
+);
+assert.match(
+  externalAccess,
+  /desired:\s*false/,
+  'Stopping a tunnel should clear persisted tunnel intent.',
+);
+assert.match(
+  externalAccess,
+  /restoreRequestedTunnel/,
+  'Tunnel service should expose a startup restore hook.',
+);
+assert.match(
+  externalAccess,
+  /restoring/,
+  'Tunnel restore should distinguish automatic restart attempts from direct user starts.',
+);
+assert.match(
+  networkRoutes,
+  /persistPreference:\s*true/,
+  'Manual tunnel starts should persist the user preference through the network route.',
+);
+assert.match(
+  serverIndex,
+  /restoreRequestedTunnel/,
+  'Server startup should restore a requested tunnel after updates/restarts.',
+);
+assert.match(
+  serverIndex,
+  /restoreRequestedTunnel\(\{ port: Number\(SERVER_PORT\) \}\)/,
+  'Server startup should restore the tunnel against the current backend port.',
+);
+
+console.log('tunnel persistence smoke passed');

package/server/index.js

@@ -98,6 +98,7 @@ import {
 } from './modules/orchestration/index.js';
 import networkRoutes from './routes/network.js';
 import telegramRoutes from './routes/telegram.js';
+import { restoreRequestedTunnel } from './services/external-access.js';
 import { restoreBotFromConfig } from './services/telegram/bot.js';
 import { ensurePortOpen } from './utils/port-access.js';
 import {
@@ -285,6 +286,7 @@ const server = http.createServer(app);
 
 const ptySessionsMap = new Map();
 const PTY_SESSION_TIMEOUT = 30 * 60 * 1000;
+const COMPLETED_PTY_SESSION_TTL = 5 * 60 * 1000;
 const SHELL_URL_PARSE_BUFFER_LIMIT = 32768;
 const SHELL_CLI_PROVIDERS = new Set(['claude', 'codex', 'cursor', 'gemini', 'qwen', 'opencode']);
 import { stripAnsiSequences, normalizeDetectedUrl, extractUrlsFromText, shouldAutoOpenUrlFromOutput } from './utils/url-detection.js';
@@ -324,6 +326,114 @@ function killProviderPtySessions(projectPath, provider) {
     return killed;
 }
 
+function getLastRegexMatchIndex(text, pattern) {
+    let lastIndex = -1;
+    for (const match of text.matchAll(pattern)) {
+        lastIndex = match.index ?? lastIndex;
+    }
+    return lastIndex;
+}
+
+function detectProviderTerminalState(provider, output) {
+    const cleanOutput = String(output || '');
+    if (!cleanOutput.trim()) {
+        return {
+            terminalState: 'unknown',
+            isBusy: false,
+            terminalStateReason: 'empty_output',
+        };
+    }
+
+    if (/Process exited with code/iu.test(cleanOutput)) {
+        return {
+            terminalState: 'exited',
+            isBusy: false,
+            terminalStateReason: 'process_exit',
+        };
+    }
+
+    const lastBusy = Math.max(
+        getLastRegexMatchIndex(cleanOutput, /(?:^|\n)\s*[•*]\s*(?:Working|Running|Thinking)\b/giu),
+        getLastRegexMatchIndex(cleanOutput, /\bWorking\s*\([^)]*esc to interrupt[^)]*\)/giu),
+        getLastRegexMatchIndex(cleanOutput, /\bmsg=interrupt\b/giu),
+    );
+
+    if (provider === 'codex') {
+        const lastPrompt = Math.max(
+            getLastRegexMatchIndex(cleanOutput, /(?:^|\n)\s*›(?:\s|$)/gu),
+            getLastRegexMatchIndex(cleanOutput, /(?:^|\n)\s*❯(?:\s|$)/gu),
+        );
+
+        if (lastBusy >= 0) {
+            const isBusy = lastPrompt <= lastBusy;
+            return {
+                terminalState: isBusy ? 'busy' : 'idle',
+                isBusy,
+                terminalStateReason: isBusy ? 'codex_busy_marker_after_prompt' : 'codex_prompt_after_busy_marker',
+            };
+        }
+
+        if (lastPrompt >= 0 && /(?:Initialized|Baseline check passed|I did not modify files|Use \/skills)/iu.test(cleanOutput)) {
+            return {
+                terminalState: 'idle',
+                isBusy: false,
+                terminalStateReason: 'codex_idle_prompt',
+            };
+        }
+    }
+
+    if (lastBusy >= 0) {
+        return {
+            terminalState: 'busy',
+            isBusy: true,
+            terminalStateReason: 'generic_busy_marker',
+        };
+    }
+
+    return {
+        terminalState: 'unknown',
+        isBusy: false,
+        terminalStateReason: 'no_known_marker',
+    };
+}
+
+function resolveProviderTerminalState(session, provider, output) {
+    if (session?.lifecycleState === 'completed' || session?.lifecycleState === 'failed' || session?.lifecycleState === 'exited') {
+        const exitCode = typeof session.exitCode === 'number' ? session.exitCode : null;
+        const terminalFailed = exitCode !== null ? exitCode !== 0 : Boolean(session.exitSignal);
+        return {
+            terminalState: terminalFailed ? 'failed' : 'completed',
+            lifecycleState: session.lifecycleState,
+            isBusy: false,
+            terminalFailed,
+            exitCode,
+            exitSignal: session.exitSignal || null,
+            completedAt: session.completedAt || null,
+            terminalStateReason: terminalFailed ? 'pty_failed' : 'pty_completed',
+        };
+    }
+
+    const detected = detectProviderTerminalState(provider, output);
+    return {
+        ...detected,
+        lifecycleState: session?.lifecycleState || 'running',
+        terminalFailed: false,
+        exitCode: null,
+        exitSignal: null,
+        completedAt: null,
+    };
+}
+
+function appendPtySessionBuffer(session, data) {
+    if (!session) return;
+    if (session.buffer.length < 5000) {
+        session.buffer.push(data);
+    } else {
+        session.buffer.shift();
+        session.buffer.push(data);
+    }
+}
+
 function normalizeShellPermissionMode(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
@@ -532,6 +642,8 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, (req, res) =>
     const projectPath = typeof req.query.projectPath === 'string' && req.query.projectPath.trim()
         ? req.query.projectPath.trim()
         : null;
+    const launchId = Number.parseInt(String(req.query.launchId || ''), 10);
+    const requestedLaunchId = Number.isFinite(launchId) && launchId > 0 ? launchId : null;
     const maxChars = Math.min(
         20000,
         Math.max(1000, Number.parseInt(String(req.query.maxChars || '12000'), 10) || 12000)
@@ -547,7 +659,8 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, (req, res) =>
         if (
             session?.provider === provider &&
             !session?.isPlainShell &&
-            (!requestedProjectPath || path.resolve(session.projectPath || os.homedir()) === requestedProjectPath)
+            (!requestedProjectPath || path.resolve(session.projectPath || os.homedir()) === requestedProjectPath) &&
+            (!requestedLaunchId || session.hermesLaunchId === requestedLaunchId)
         ) {
             if (!matchedSession || (session.updatedAt || 0) > (matchedSession.updatedAt || 0)) {
                 matchedSession = session;
@@ -560,19 +673,24 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, (req, res) =>
             active: false,
             provider,
             projectPath: requestedProjectPath,
+            launchId: requestedLaunchId,
             output: '',
             message: 'No active provider terminal session found for this project.',
         });
     }
 
     const rawOutput = matchedSession.buffer.join('').slice(-maxChars);
+    const output = stripAnsiSequences(rawOutput);
+    const terminalState = resolveProviderTerminalState(matchedSession, provider, output);
     res.json({
         active: true,
         provider,
         projectPath: path.resolve(matchedSession.projectPath || os.homedir()),
         sessionId: matchedSession.sessionId || null,
+        launchId: matchedSession.hermesLaunchId || null,
         updatedAt: matchedSession.updatedAt || null,
-        output: stripAnsiSequences(rawOutput),
+        ...terminalState,
+        output,
     });
 });
 
@@ -2268,6 +2386,9 @@ function handleShellConnection(ws, request) {
                 const startupInput = typeof data.startupInput === 'string' && data.startupInput.trim()
                     ? data.startupInput.trim()
                     : null;
+                const hermesLaunchId = Number.isFinite(Number(data.hermesLaunchId)) && Number(data.hermesLaunchId) > 0
+                    ? Number(data.hermesLaunchId)
+                    : null;
                 const isPlainShell = data.isPlainShell || (!!initialCommand && !hasSession) || provider === 'plain-shell';
                 const isHermesCliLaunch = isPlainShell && isHermesCliCommand(initialCommand);
                 const forceNewSession = Boolean(data.forceNewSession);
@@ -2328,29 +2449,33 @@ function handleShellConnection(ws, request) {
 
                 const existingSession = (isLoginCommand || forceNewSession) ? null : ptySessionsMap.get(ptySessionKey);
                 if (existingSession) {
-                    console.log('♻️  Reconnecting to existing PTY session:', ptySessionKey);
-                    shellProcess = existingSession.pty;
-
-                    clearTimeout(existingSession.timeoutId);
+                    if (!existingSession.pty || existingSession.lifecycleState === 'completed' || existingSession.lifecycleState === 'failed') {
+                        ptySessionsMap.delete(ptySessionKey);
+                    } else {
+                        console.log('♻️  Reconnecting to existing PTY session:', ptySessionKey);
+                        shellProcess = existingSession.pty;
+
+                        clearTimeout(existingSession.timeoutId);
+
+                        ws.send(JSON.stringify({
+                            type: 'output',
+                            data: `\x1b[36m[Reconnected to existing session]\x1b[0m\r\n`
+                        }));
+
+                        if (existingSession.buffer && existingSession.buffer.length > 0) {
+                            console.log(`📜 Sending ${existingSession.buffer.length} buffered messages`);
+                            existingSession.buffer.forEach(bufferedData => {
+                                ws.send(JSON.stringify({
+                                    type: 'output',
+                                    data: bufferedData
+                                }));
+                            });
+                        }
 
-                    ws.send(JSON.stringify({
-                        type: 'output',
-                        data: `\x1b[36m[Reconnected to existing session]\x1b[0m\r\n`
-                    }));
+                        existingSession.ws = ws;
 
-                    if (existingSession.buffer && existingSession.buffer.length > 0) {
-                        console.log(`📜 Sending ${existingSession.buffer.length} buffered messages`);
-                        existingSession.buffer.forEach(bufferedData => {
-                            ws.send(JSON.stringify({
-                                type: 'output',
-                                data: bufferedData
-                            }));
-                        });
+                        return;
                     }
-
-                    existingSession.ws = ws;
-
-                    return;
                 }
 
                 console.log('[INFO] Starting shell in:', projectPath);
@@ -2548,8 +2673,13 @@ function handleShellConnection(ws, request) {
                         timeoutId: null,
                         projectPath,
                         sessionId,
+                        hermesLaunchId,
                         provider,
                         isPlainShell,
+                        lifecycleState: 'running',
+                        exitCode: null,
+                        exitSignal: null,
+                        completedAt: null,
                         keepAliveUntilExit: false,
                         updatedAt: Date.now(),
                     });
@@ -2560,12 +2690,7 @@ function handleShellConnection(ws, request) {
                         if (!session) return;
                         session.updatedAt = Date.now();
 
-                        if (session.buffer.length < 5000) {
-                            session.buffer.push(data);
-                        } else {
-                            session.buffer.shift();
-                            session.buffer.push(data);
-                        }
+                        appendPtySessionBuffer(session, data);
 
                         if (session.ws && session.ws.readyState === WebSocket.OPEN) {
                             let outputData = data;
@@ -2624,16 +2749,36 @@ function handleShellConnection(ws, request) {
                     shellProcess.onExit((exitCode) => {
                         console.log('🔚 Shell process exited with code:', exitCode.exitCode, 'signal:', exitCode.signal);
                         const session = ptySessionsMap.get(ptySessionKey);
+                        const exitMessage = `\r\n\x1b[33mProcess exited with code ${exitCode.exitCode}${exitCode.signal ? ` (${exitCode.signal})` : ''}\x1b[0m\r\n`;
+                        if (session) {
+                            session.lifecycleState = exitCode.exitCode === 0 && !exitCode.signal ? 'completed' : 'failed';
+                            session.exitCode = typeof exitCode.exitCode === 'number' ? exitCode.exitCode : null;
+                            session.exitSignal = exitCode.signal || null;
+                            session.completedAt = new Date().toISOString();
+                            session.updatedAt = Date.now();
+                            session.pty = null;
+                            appendPtySessionBuffer(session, exitMessage);
+                        }
                         if (session && session.ws && session.ws.readyState === WebSocket.OPEN) {
                             session.ws.send(JSON.stringify({
                                 type: 'output',
-                                data: `\r\n\x1b[33mProcess exited with code ${exitCode.exitCode}${exitCode.signal ? ` (${exitCode.signal})` : ''}\x1b[0m\r\n`
+                                data: exitMessage
                             }));
                         }
                         if (session && session.timeoutId) {
                             clearTimeout(session.timeoutId);
                         }
-                        ptySessionsMap.delete(ptySessionKey);
+                        if (session) {
+                            session.ws = null;
+                            session.timeoutId = setTimeout(() => {
+                                const current = ptySessionsMap.get(ptySessionKey);
+                                if (current && current.lifecycleState !== 'running') {
+                                    ptySessionsMap.delete(ptySessionKey);
+                                }
+                            }, COMPLETED_PTY_SESSION_TTL);
+                        } else {
+                            ptySessionsMap.delete(ptySessionKey);
+                        }
                         shellProcess = null;
                     });
 
@@ -3430,6 +3575,10 @@ async function startServer() {
                 console.log(`${c.dim('[INFO]')} Port-access helper failed: ${err?.message || err}`);
             }
 
+            restoreRequestedTunnel({ port: Number(SERVER_PORT) }).catch((err) => {
+                console.warn('[external-access] tunnel restore failed:', err?.message || err);
+            });
+
             console.log(`${c.tip('[TIP]')}  Run "pixcode status" for full configuration details`);
             console.log('');
 

package/server/routes/network.js

@@ -96,7 +96,7 @@ router.delete('/upnp', (_req, res) => {
 router.post('/tunnel', async (req, res) => {
   const port = resolveServerPort();
   try {
-    const state = await startTunnel({ port });
+    const state = await startTunnel({ port, persistPreference: true });
     res.json({ success: true, tunnel: state });
   } catch (error) {
     console.error('Tunnel start failed:', error);
@@ -114,7 +114,7 @@ router.post('/tunnel', async (req, res) => {
 
 router.delete('/tunnel', async (req, res) => {
   try {
-    const state = await stopTunnel();
+    const state = await stopTunnel({ persistPreference: true });
     res.json({ success: true, tunnel: state });
   } catch (error) {
     console.error('Tunnel stop failed:', error);