@pixelbyte-software/pixcode 1.50.3 → 1.50.4

package/scripts/hermes/pixcode-mcp-server.mjs

@@ -35,7 +35,7 @@ const tools = [
   },
   {
     name: 'pixcode_open_cli_terminal',
-    description: 'Use this instead of Hermes shell/proc/skill execution whenever the user asks to open Codex, Claude, Cursor, Gemini, Qwen, or OpenCode inside Pixcode. It asks the open Pixcode workbench to open a visible provider CLI terminal in the project and submit startup input there. Do not run a parallel Hermes codex/claude/proc command for the same request. For multi-step, piece-by-piece, or long-running work, put the full user instruction in startupInput so the provider CLI does the work visibly inside Pixcode. If the user asks for the provider output, set waitForOutputMs or call pixcode_read_cli_terminal after launch.',
+    description: 'Use this instead of Hermes shell/proc/skill execution whenever the user asks to open Codex, Claude, Cursor, Gemini, Qwen, or OpenCode inside Pixcode. It asks the open Pixcode workbench to open a visible provider CLI terminal in the project and submit startup input there. Do not run a parallel Hermes codex/claude/proc command for the same request. For multi-step, piece-by-piece, or long-running work, put the full user instruction in startupInput so the provider CLI does the work visibly inside Pixcode. When startupInput is present, Pixcode waits for the terminal to become idle before returning readback by default; never treat the first working frame as final output.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -66,7 +66,15 @@ const tools = [
         },
         waitForOutputMs: {
           type: 'number',
-          description: 'Optional milliseconds to wait and then read recent terminal output. Useful when the user asks you to report the provider output.',
+          description: 'Optional milliseconds to wait for recent terminal output. Pixcode keeps polling while terminalState is busy, so use a large value when the user asks for the final provider answer.',
+        },
+        waitForCompletionMs: {
+          type: 'number',
+          description: 'Optional explicit milliseconds to wait for the visible provider CLI to return to an idle prompt before reporting output. Overrides waitForOutputMs.',
+        },
+        launchId: {
+          type: 'number',
+          description: 'Optional Pixcode terminal launch id. Use the id returned by pixcode_open_cli_terminal when reading one specific visible terminal.',
         },
       },
       required: ['provider'],
@@ -186,15 +194,87 @@ async function readProviderStatus(provider) {
   return body?.data ?? body;
 }
 
-async function readProviderTerminalOutput(provider, projectPath, maxChars) {
+async function readProviderTerminalOutput(provider, projectPath, maxChars, launchId = null) {
   const params = new URLSearchParams({
     provider,
     maxChars: String(maxChars || 12000),
   });
   if (projectPath) params.set('projectPath', projectPath);
+  if (launchId) params.set('launchId', String(launchId));
   return pixcodeFetch(`/api/shell/sessions/provider-output?${params.toString()}`);
 }
 
+function getLastMatchIndex(text, pattern) {
+  let lastIndex = -1;
+  for (const match of text.matchAll(pattern)) {
+    lastIndex = match.index ?? lastIndex;
+  }
+  return lastIndex;
+}
+
+function inferTerminalState(provider, terminalOutput) {
+  if (!terminalOutput) return 'unknown';
+  if (typeof terminalOutput.terminalState === 'string') return terminalOutput.terminalState;
+  if (typeof terminalOutput.isBusy === 'boolean') return terminalOutput.isBusy ? 'busy' : 'idle';
+  if (terminalOutput.active === false) return terminalOutput.output ? 'idle' : 'unknown';
+
+  const output = String(terminalOutput.output || '');
+  if (!output.trim()) return 'unknown';
+  if (/Process exited with code/iu.test(output)) return 'idle';
+
+  const lastBusy = Math.max(
+    getLastMatchIndex(output, /(?:^|\n)\s*[•*]\s*(?:Working|Running|Thinking)\b/giu),
+    getLastMatchIndex(output, /\bWorking\s*\([^)]*esc to interrupt[^)]*\)/giu),
+    getLastMatchIndex(output, /\bmsg=interrupt\b/giu),
+  );
+
+  if (provider === 'codex') {
+    const lastPrompt = Math.max(
+      getLastMatchIndex(output, /(?:^|\n)\s*›(?:\s|$)/gu),
+      getLastMatchIndex(output, /(?:^|\n)\s*❯(?:\s|$)/gu),
+    );
+    if (lastBusy >= 0) return lastPrompt > lastBusy ? 'idle' : 'busy';
+    return lastPrompt >= 0 && /(?:Initialized|Baseline check passed|I did not modify files|Use \/skills)/iu.test(output)
+      ? 'idle'
+      : 'unknown';
+  }
+
+  if (lastBusy >= 0) return 'busy';
+  return 'unknown';
+}
+
+function isTerminalReadbackFinal(provider, terminalOutput) {
+  const terminalState = inferTerminalState(provider, terminalOutput);
+  return terminalState === 'idle' || terminalState === 'completed' || terminalState === 'exited';
+}
+
+async function waitForProviderTerminalOutput(provider, projectPath, waitMs, launchId = null) {
+  const startedAt = Date.now();
+  let latestOutput = null;
+  do {
+    const elapsed = Date.now() - startedAt;
+    const remaining = Math.max(0, waitMs - elapsed);
+    await sleep(Math.min(1000, Math.max(250, remaining)));
+    latestOutput = await readProviderTerminalOutput(provider, projectPath, 12000, launchId).catch((error) => ({
+      active: false,
+      terminalState: 'unknown',
+      error: error instanceof Error ? error.message : String(error),
+    }));
+
+    if (latestOutput?.output && isTerminalReadbackFinal(provider, latestOutput)) {
+      break;
+    }
+  } while (Date.now() - startedAt < waitMs);
+
+  if (latestOutput && !latestOutput.terminalState) {
+    latestOutput.terminalState = inferTerminalState(provider, latestOutput);
+  }
+  if (latestOutput && typeof latestOutput.isBusy !== 'boolean') {
+    latestOutput.isBusy = latestOutput.terminalState === 'busy';
+  }
+  return latestOutput;
+}
+
 function isLegacyPromptLikelyStartupInput(prompt) {
   if (!prompt || prompt.length > 160 || prompt.includes('\n')) return false;
   if (/^[/:!@]/u.test(prompt)) return true;
@@ -287,26 +367,27 @@ async function callTool(name, args = {}) {
         permissionMode,
       }),
     });
+    const launchId = Number(body?.event?.id || body?.id || 0) || null;
     let terminalOutput = null;
-    const waitForOutputMs = Math.min(15000, Math.max(0, Number(args.waitForOutputMs || 0)));
+    const defaultWaitMs = startupInput ? 180000 : 0;
+    const requestedWaitMs = Number(args.waitForCompletionMs ?? args.waitForOutputMs ?? defaultWaitMs);
+    const waitForOutputMs = Math.min(600000, Math.max(0, requestedWaitMs));
     if (waitForOutputMs > 0) {
-      const startedAt = Date.now();
-      do {
-        await sleep(Math.min(1000, Math.max(250, waitForOutputMs)));
-        terminalOutput = await readProviderTerminalOutput(provider, projectPath, 12000).catch((error) => ({
-          active: false,
-          error: error instanceof Error ? error.message : String(error),
-        }));
-        if (terminalOutput?.active && terminalOutput?.output) break;
-      } while (Date.now() - startedAt < waitForOutputMs);
+      terminalOutput = await waitForProviderTerminalOutput(provider, projectPath, waitForOutputMs, launchId);
     }
+    const terminalOutputFinal = terminalOutput ? isTerminalReadbackFinal(provider, terminalOutput) : false;
     return textResult(JSON.stringify({
       launched: true,
+      launchId,
       pixcodeMcpConfigured: mcpConfigured,
       pixcodeMcpError: mcpError,
       event: body?.event ?? body,
       permissionBypass: bypassPermissions,
       status,
+      terminalOutputFinal,
+      message: terminalOutput && !terminalOutputFinal
+        ? 'Provider terminal is still running or not at an idle prompt yet. Do not summarize this as final output; call pixcode_read_cli_terminal with launchId later.'
+        : undefined,
       terminalOutput,
     }, null, 2));
   }
@@ -317,7 +398,15 @@ async function callTool(name, args = {}) {
       ? args.projectPath.trim()
       : null;
     const maxChars = Math.min(20000, Math.max(1000, Number(args.maxChars || 12000)));
-    const body = await readProviderTerminalOutput(provider, projectPath, maxChars);
+    const launchId = Number(args.launchId || 0) || null;
+    const body = await readProviderTerminalOutput(provider, projectPath, maxChars, launchId);
+    if (body && !body.terminalState) {
+      body.terminalState = inferTerminalState(provider, body);
+    }
+    if (body && typeof body.isBusy !== 'boolean') {
+      body.isBusy = body.terminalState === 'busy';
+    }
+    body.terminalOutputFinal = isTerminalReadbackFinal(provider, body);
     return textResult(JSON.stringify(body, null, 2));
   }
 

package/scripts/smoke/hermes-mcp-pixcode-roundtrip.mjs

@@ -9,6 +9,7 @@ const apiKey = 'px_smoke_key';
 const seen = [];
 const providerMcpUpserts = [];
 const terminalLaunches = [];
+const providerOutputReads = [];
 
 function readJson(req) {
   return new Promise((resolve, reject) => {
@@ -90,7 +91,7 @@ const server = createServer(async (req, res) => {
     res.statusCode = 201;
     res.end(JSON.stringify({
       event: {
-        id: 1,
+        id: terminalLaunches.length,
         provider: body.provider,
         projectPath: body.projectPath,
         prompt: body.prompt,
@@ -100,6 +101,39 @@ const server = createServer(async (req, res) => {
     return;
   }
 
+  if (req.method === 'GET' && url.pathname === '/api/shell/sessions/provider-output') {
+    providerOutputReads.push({
+      provider: url.searchParams.get('provider'),
+      projectPath: url.searchParams.get('projectPath'),
+      launchId: url.searchParams.get('launchId'),
+    });
+    const outputs = [
+      {
+        active: true,
+        provider: 'codex',
+        projectPath: '/root/pixcode',
+        terminalState: 'busy',
+        output: 'OpenAI Codex\n› /init\n\n• Working (10s • esc to interrupt)\n',
+      },
+      {
+        active: true,
+        provider: 'codex',
+        projectPath: '/root/pixcode',
+        terminalState: 'busy',
+        output: 'OpenAI Codex\n› /init\n\n• Ran npm test\n• Working (30s • esc to interrupt)\n',
+      },
+      {
+        active: true,
+        provider: 'codex',
+        projectPath: '/root/pixcode',
+        terminalState: 'idle',
+        output: 'Baseline check passed: npm test reports 195 passing, 0 failing.\n\n› Use /skills to list available skills\n',
+      },
+    ];
+    res.end(JSON.stringify(outputs[Math.min(providerOutputReads.length - 1, outputs.length - 1)]));
+    return;
+  }
+
   res.statusCode = 404;
   res.end(JSON.stringify({ error: url.pathname }));
 });
@@ -190,13 +224,38 @@ try {
   assert.equal(providerMcpUpserts.length, 1, 'Codex launch should upsert a project-scoped Pixcode MCP server');
   assert.equal(providerMcpUpserts[0].name, 'pixcode', 'Provider MCP server should be named pixcode');
 
+  providerOutputReads.length = 0;
+  const launchWithReadback = await callMcp(child, 'tools/call', {
+    name: 'pixcode_open_cli_terminal',
+    arguments: {
+      provider: 'codex',
+      projectPath: '/root/pixcode',
+      prompt: 'read final output',
+      startupInput: '/init',
+      waitForOutputMs: 3000,
+    },
+  });
+  assert(
+    providerOutputReads.length >= 3,
+    `readback should keep polling until the provider terminal is idle, reads=${providerOutputReads.length}`,
+  );
+  assert.match(
+    launchWithReadback.content[0].text,
+    /195 passing, 0 failing/,
+    'readback should return the final Codex output instead of the first working frame',
+  );
+  assert(
+    providerOutputReads.every((read) => read.launchId === '2'),
+    `readback should be tied to the Hermes terminal launch id, reads=${JSON.stringify(providerOutputReads)}`,
+  );
+
   const blockedLaunch = await callMcp(child, 'tools/call', {
     name: 'pixcode_open_cli_terminal',
     arguments: { provider: 'qwen', projectPath: '/root/pixcode', prompt: 'smoke' },
   });
   assert.match(blockedLaunch.content[0].text, /"launched": false/, 'uninstalled providers should not create terminal launches');
   assert.match(blockedLaunch.content[0].text, /"reason": "not_installed"/, 'uninstalled provider response should explain the block');
-  assert.equal(terminalLaunches.length, 1, 'Only the installed Codex provider should be launched');
+  assert.equal(terminalLaunches.length, 2, 'Only installed Codex provider launches should be created');
 
   assert(seen.every((entry) => entry.auth === `Bearer ${apiKey}`), 'all MCP calls should use the Pixcode bearer key');
   console.log('hermes MCP Pixcode roundtrip smoke passed');

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,36 @@ 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,
+  /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,
   /startup input typed into the provider CLI/,

package/server/index.js

@@ -324,6 +324,77 @@ 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 normalizeShellPermissionMode(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
@@ -532,6 +603,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 +620,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 +634,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 = detectProviderTerminalState(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 +2347,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);
@@ -2548,6 +2630,7 @@ function handleShellConnection(ws, request) {
                         timeoutId: null,
                         projectPath,
                         sessionId,
+                        hermesLaunchId,
                         provider,
                         isPlainShell,
                         keepAliveUntilExit: false,