@pixelbyte-software/pixcode 1.50.4 → 1.50.5

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';
@@ -395,6 +397,43 @@ function detectProviderTerminalState(provider, output) {
     };
 }
 
+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() : '';
 }
@@ -642,7 +681,7 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, (req, res) =>
 
     const rawOutput = matchedSession.buffer.join('').slice(-maxChars);
     const output = stripAnsiSequences(rawOutput);
-    const terminalState = detectProviderTerminalState(provider, output);
+    const terminalState = resolveProviderTerminalState(matchedSession, provider, output);
     res.json({
         active: true,
         provider,
@@ -2410,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;
+                    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
+                                }));
+                            });
+                        }
 
-                    clearTimeout(existingSession.timeoutId);
+                        existingSession.ws = ws;
 
-                    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
-                            }));
-                        });
+                        return;
                     }
-
-                    existingSession.ws = ws;
-
-                    return;
                 }
 
                 console.log('[INFO] Starting shell in:', projectPath);
@@ -2633,6 +2676,10 @@ function handleShellConnection(ws, request) {
                         hermesLaunchId,
                         provider,
                         isPlainShell,
+                        lifecycleState: 'running',
+                        exitCode: null,
+                        exitSignal: null,
+                        completedAt: null,
                         keepAliveUntilExit: false,
                         updatedAt: Date.now(),
                     });
@@ -2643,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;
@@ -2707,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;
                     });
 
@@ -3513,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);

package/server/services/external-access.js

@@ -1,4 +1,7 @@
 import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 
 /**
  * External-access service.
@@ -31,16 +34,62 @@ export const getUpnpState = () => UPNP_UNAVAILABLE;
 // stops the previous one to avoid dangling child processes.
 // ============================================================================
 
+export const TUNNEL_PERSISTENCE_PATH = process.env.PIXCODE_TUNNEL_STATE_PATH
+  || path.join(os.homedir(), '.pixcode', 'external-access.json');
+
 let tunnelProc = null;
+let suppressNextTunnelRestore = false;
+let restoreTimer = null;
+let restoreInFlight = null;
 let tunnelState = {
   running: false,
   binary: null, // 'cloudflared' | 'ngrok'
   url: null,
   error: null,
   installHint: null,
+  desired: false,
+  restoring: false,
   log: [],
 };
 
+const DEFAULT_TUNNEL_PREFERENCE = Object.freeze({
+  desired: false,
+  port: null,
+  provider: null,
+  lastUrl: null,
+  lastStartedAt: null,
+  lastStoppedAt: null,
+  updatedAt: null,
+});
+
+const readTunnelPreference = async () => {
+  try {
+    const raw = await fs.readFile(TUNNEL_PERSISTENCE_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    return {
+      ...DEFAULT_TUNNEL_PREFERENCE,
+      ...(parsed && typeof parsed === 'object' ? parsed : {}),
+    };
+  } catch (error) {
+    if (error?.code !== 'ENOENT') {
+      console.warn('[external-access] Failed to read tunnel preference:', error?.message || error);
+    }
+    return { ...DEFAULT_TUNNEL_PREFERENCE };
+  }
+};
+
+export const persistTunnelPreference = async (patch) => {
+  const current = await readTunnelPreference();
+  const next = {
+    ...current,
+    ...patch,
+    updatedAt: new Date().toISOString(),
+  };
+  await fs.mkdir(path.dirname(TUNNEL_PERSISTENCE_PATH), { recursive: true });
+  await fs.writeFile(TUNNEL_PERSISTENCE_PATH, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+  return next;
+};
+
 const appendLog = (line) => {
   // Tunnels can be noisy. Cap the tail we retain so a long-running tunnel
   // doesn't grow the log into an OOM risk.
@@ -94,17 +143,34 @@ const extractUrl = (binary, text) => {
   return null;
 };
 
-export const startTunnel = async ({ port }) => {
+export const startTunnel = async ({ port, persistPreference = false, restoring = false } = {}) => {
   if (tunnelProc) {
-    // Already running — tell the caller to stop it first rather than silently
-    // replacing, which would orphan the old child and lie about state.
-    throw new Error('Tunnel already running; stop it first');
+    if (persistPreference) {
+      await persistTunnelPreference({
+        desired: true,
+        port,
+        provider: tunnelState.binary,
+        lastUrl: tunnelState.url,
+      });
+      tunnelState = { ...tunnelState, desired: true, restoring: false };
+    }
+    return tunnelState;
   }
+  suppressNextTunnelRestore = false;
 
   const binary = await detectBinary();
   if (!binary) {
     const installHint = createTunnelInstallHint();
-    tunnelState = { running: false, binary: null, url: null, error: 'No tunnel binary found', installHint, log: [] };
+    tunnelState = {
+      running: false,
+      binary: null,
+      url: null,
+      error: 'No tunnel binary found',
+      installHint,
+      desired: Boolean(persistPreference || restoring),
+      restoring,
+      log: [],
+    };
     const err = new Error('No tunnel binary found (tried cloudflared, ngrok)');
     err.code = 'ENOENT_TUNNEL';
     err.installHint = installHint;
@@ -114,7 +180,16 @@ export const startTunnel = async ({ port }) => {
   const args = buildTunnelArgs(binary, port);
   const child = spawn(binary, args, { stdio: ['ignore', 'pipe', 'pipe'] });
   tunnelProc = child;
-  tunnelState = { running: true, binary, url: null, error: null, installHint: null, log: [] };
+  tunnelState = {
+    running: true,
+    binary,
+    url: null,
+    error: null,
+    installHint: null,
+    desired: Boolean(persistPreference || restoring),
+    restoring,
+    log: [],
+  };
 
   const handleChunk = (chunk) => {
     const text = chunk.toString();
@@ -135,8 +210,26 @@ export const startTunnel = async ({ port }) => {
       url: null,
       error: code === 0 ? null : `Tunnel exited with code ${code}`,
       installHint: null,
+      desired: tunnelState.desired,
+      restoring: false,
       log: tunnelState.log,
     };
+
+    if (suppressNextTunnelRestore) {
+      suppressNextTunnelRestore = false;
+      return;
+    }
+
+    void readTunnelPreference().then((preference) => {
+      if (!preference.desired) return;
+      if (restoreTimer) clearTimeout(restoreTimer);
+      restoreTimer = setTimeout(() => {
+        restoreTimer = null;
+        restoreRequestedTunnel({ port: Number(preference.port || port) || port }).catch((error) => {
+          console.warn('[external-access] Tunnel restore failed after exit:', error?.message || error);
+        });
+      }, 3000);
+    });
   });
 
   // Wait up to 15s for the public URL to appear in the log. We don't block
@@ -144,7 +237,19 @@ export const startTunnel = async ({ port }) => {
   // a clear failure instead of a spinner that never resolves.
   const start = Date.now();
   while (Date.now() - start < 15000) {
-    if (tunnelState.url) return tunnelState;
+    if (tunnelState.url) {
+      if (persistPreference || restoring) {
+        await persistTunnelPreference({
+          desired: true,
+          port,
+          provider: binary,
+          lastUrl: tunnelState.url,
+          lastStartedAt: new Date().toISOString(),
+        });
+        tunnelState = { ...tunnelState, desired: true, restoring: false };
+      }
+      return tunnelState;
+    }
     if (!tunnelProc) break; // process died early
      
     await new Promise((r) => setTimeout(r, 250));
@@ -152,18 +257,40 @@ export const startTunnel = async ({ port }) => {
 
   if (!tunnelState.url) {
     // If we never captured a URL, kill the child so we don't leak it.
+    suppressNextTunnelRestore = true;
     try { child.kill(); } catch { /* ignore */ }
     tunnelProc = null;
-    tunnelState = { ...tunnelState, running: false, error: 'Tunnel did not report a public URL', installHint: null };
+    tunnelState = { ...tunnelState, running: false, error: 'Tunnel did not report a public URL', installHint: null, restoring: false };
     throw new Error(tunnelState.error);
   }
 
   return tunnelState;
 };
 
-export const stopTunnel = async () => {
+export const stopTunnel = async ({ persistPreference = true } = {}) => {
+  suppressNextTunnelRestore = Boolean(tunnelProc);
+  if (restoreTimer) {
+    clearTimeout(restoreTimer);
+    restoreTimer = null;
+  }
+  if (persistPreference) {
+    await persistTunnelPreference({
+      desired: false,
+      lastStoppedAt: new Date().toISOString(),
+    });
+  }
   if (!tunnelProc) {
-    tunnelState = { running: false, binary: null, url: null, error: null, installHint: null, log: [] };
+    suppressNextTunnelRestore = false;
+    tunnelState = {
+      running: false,
+      binary: null,
+      url: null,
+      error: null,
+      installHint: null,
+      desired: false,
+      restoring: false,
+      log: [],
+    };
     return tunnelState;
   }
   try {
@@ -172,10 +299,71 @@ export const stopTunnel = async () => {
     // already dead
   }
   tunnelProc = null;
-  tunnelState = { running: false, binary: null, url: null, error: null, installHint: null, log: [] };
+  tunnelState = {
+    running: false,
+    binary: null,
+    url: null,
+    error: null,
+    installHint: null,
+    desired: false,
+    restoring: false,
+    log: [],
+  };
   return tunnelState;
 };
 
+export const restoreRequestedTunnel = async ({ port } = {}) => {
+  if (restoreInFlight) return restoreInFlight;
+
+  restoreInFlight = (async () => {
+    const preference = await readTunnelPreference();
+    if (!preference.desired) {
+      tunnelState = { ...tunnelState, desired: false, restoring: false };
+      return tunnelState;
+    }
+    if (tunnelProc) {
+      tunnelState = { ...tunnelState, desired: true, restoring: false };
+      return tunnelState;
+    }
+
+    const restorePort = Number(port || preference.port);
+    if (!Number.isFinite(restorePort) || restorePort <= 0) {
+      tunnelState = {
+        ...tunnelState,
+        running: false,
+        desired: true,
+        restoring: false,
+        error: 'Tunnel restore skipped: no valid server port',
+      };
+      return tunnelState;
+    }
+
+    try {
+      return await startTunnel({
+        port: restorePort,
+        persistPreference: true,
+        restoring: true,
+      });
+    } catch (error) {
+      tunnelState = {
+        ...tunnelState,
+        running: false,
+        desired: true,
+        restoring: false,
+        error: `Tunnel restore failed: ${error?.message || error}`,
+        installHint: error?.installHint || tunnelState.installHint || null,
+      };
+      return tunnelState;
+    }
+  })();
+
+  try {
+    return await restoreInFlight;
+  } finally {
+    restoreInFlight = null;
+  }
+};
+
 export const getTunnelState = () => tunnelState;
 
 // Explicit cleanup so the server process can shut down without leaking the