handmux 0.22.0 → 0.23.0

package/src/codexDiff.js

@@ -0,0 +1,108 @@
+const HUNK_HEADER = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+
+function changedLines(lines) {
+  return lines.filter((line) => /^[+-]/.test(line)
+    && !line.startsWith('+++') && !line.startsWith('---'));
+}
+
+export function parseUnifiedDiff(value, { created = false } = {}) {
+  const lines = String(value || '').split('\n');
+  let added = 0;
+  let removed = 0;
+  const hunks = [];
+  let current = null;
+  const flush = () => {
+    if (current?.lines.length) hunks.push(current);
+    current = null;
+  };
+
+  for (const line of lines) {
+    const header = HUNK_HEADER.exec(line);
+    if (header) {
+      flush();
+      current = { oldStart: Number(header[1]), newStart: Number(header[2]), lines: [] };
+      continue;
+    }
+    if (line.startsWith('+') && !line.startsWith('+++')) added++;
+    else if (line.startsWith('-') && !line.startsWith('---')) removed++;
+    if (current && /^[ +\-]/.test(line) && !line.startsWith('+++') && !line.startsWith('---')) {
+      current.lines.push(line);
+    }
+  }
+  flush();
+  return {
+    added,
+    removed,
+    hunks: hunks.length ? hunks : null,
+    ...(created ? { created: true } : {}),
+  };
+}
+
+function applyPatchSection(value, path) {
+  const lines = String(value || '').split('\n');
+  let active = false;
+  const section = [];
+  for (const line of lines) {
+    const header = /^\*\*\* (?:Add|Update|Delete) File: (.+)$/.exec(line);
+    if (header) {
+      if (active) break;
+      active = header[1].trim() === path;
+      continue;
+    }
+    if (active && line === '*** End Patch') break;
+    if (active) section.push(line);
+  }
+  return section;
+}
+
+function diffKey(lines) {
+  return changedLines(lines).join('\0');
+}
+
+function sameFilePath(left, right) {
+  const a = String(left || '').replaceAll('\\', '/').replace(/^\.\//, '');
+  const b = String(right || '').replaceAll('\\', '/').replace(/^\.\//, '');
+  return a === b || a.endsWith(`/${b}`) || b.endsWith(`/${a}`);
+}
+
+function candidateDiffs(thread) {
+  const candidates = [];
+  for (const turn of thread?.turns || []) {
+    for (const item of turn?.items || []) {
+      if (item?.type !== 'fileChange') continue;
+      for (const change of item.changes || []) {
+        const diff = parseUnifiedDiff(change?.diff, { created: change?.kind?.type === 'add' });
+        if (!diff.hunks) continue;
+        candidates.push({
+          turnId: turn.id || null,
+          path: change?.path || '',
+          key: diffKey(String(change?.diff || '').split('\n')),
+          diff,
+        });
+      }
+    }
+  }
+  return candidates;
+}
+
+export function enrichCodexFileDiffs(messages, thread) {
+  const candidates = candidateDiffs(thread);
+  const used = new Set();
+  return messages.map((message) => {
+    const tool = message?.tool;
+    if (tool?.name !== 'apply_patch' || !tool.diff || tool.diff.hunks?.length) return message;
+    const path = tool.input?.file_path || '';
+    const key = diffKey(applyPatchSection(tool.input?.patch, path));
+    const matches = (candidate, index) => !used.has(index)
+      && sameFilePath(candidate.path, path)
+      && candidate.diff.added === tool.diff.added
+      && candidate.diff.removed === tool.diff.removed
+      && (!message.turnId || !candidate.turnId || candidate.turnId === message.turnId);
+    let index = candidates.findIndex((candidate, candidateIndex) => matches(candidate, candidateIndex)
+      && (!key || !candidate.key || candidate.key === key));
+    if (index < 0 && !key) index = candidates.findIndex(matches);
+    if (index < 0) return message;
+    used.add(index);
+    return { ...message, tool: { ...tool, diff: candidates[index].diff } };
+  });
+}

package/src/codexTranscriptParse.js

@@ -0,0 +1,413 @@
+// Codex's rollout JSONL is the durable, ordered conversation log. App Server notifications drive live
+// controls/status, but its thread snapshots currently omit some completed tools, so transcript rendering
+// must come from this log alone. event_msg mirrors response_item content and is deliberately ignored.
+const SLASH_CMD_RE = /^\/([a-z][\w-]*)(?:\s+([^\n]*))?$/i;
+const OUTPUT_CAP = 100_000;
+const SCRIPT_CAP = 4_000;
+
+const cap = (value, limit) => {
+  const text = String(value ?? '');
+  return text.length > limit ? `${text.slice(0, limit)}…` : text;
+};
+
+// Codex persists its injected context as role=user response items. Match only its reserved envelope roots:
+// user prompts may legitimately begin with ordinary HTML/XML and must remain part of the conversation.
+export function isCodexSyntheticUserText(value) {
+  const text = String(value ?? '');
+  return /^\s*<(?:environment_context|permissions(?:\s+instructions)?|collaboration_mode|apps_instructions|plugins_instructions|skills_instructions|recommended_plugins|user_action|user_shell_command|image|turn_aborted)(?:\s|>|\/)/.test(text)
+    || /^\s*# AGENTS\.md instructions for [^\r\n]+\r?\n\s*<INSTRUCTIONS>(?:\r?\n|$)/.test(text);
+}
+
+function messageText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((item) => (item && ['input_text', 'output_text', 'text'].includes(item.type)) ? (item.text || '') : '')
+    .join('');
+}
+
+function parseInput(value) {
+  if (value && typeof value === 'object') return value;
+  if (typeof value !== 'string' || !value.trim()) return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === 'object' ? parsed : { value: parsed };
+  } catch { return { value }; }
+}
+
+function outputText(value) {
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('[') || trimmed.startsWith('{')) && trimmed.length < OUTPUT_CAP * 2) {
+      try { return outputText(JSON.parse(trimmed)); } catch { /* keep original */ }
+    }
+    return cap(value, OUTPUT_CAP);
+  }
+  if (Array.isArray(value)) {
+    return cap(value.map((item) => {
+      if (item && typeof item === 'object' && typeof item.text === 'string') return item.text;
+      return outputText(item);
+    }).filter(Boolean).join('\n'), OUTPUT_CAP);
+  }
+  if (value && typeof value === 'object') {
+    if (Object.keys(value).length === 0) return '';
+    if (typeof value.output === 'string') return cap(value.output, OUTPUT_CAP);
+    try { return cap(JSON.stringify(value, null, 2), OUTPUT_CAP); } catch { return ''; }
+  }
+  return value == null ? '' : cap(value, OUTPUT_CAP);
+}
+
+function classicOutput(value) {
+  const raw = outputText(value);
+  const exit = raw.match(/Process exited with code\s+(-?\d+)/i);
+  const marker = raw.match(/(?:^|\n)Output:\n?/i);
+  const result = marker ? raw.slice(marker.index + marker[0].length) : raw;
+  const declined = /^aborted by user(?:\s+after\s+[\d.]+s)?\s*$/i.test(result.trim());
+  const isError = !!(exit && Number(exit[1]) !== 0);
+  return {
+    result,
+    isError,
+    outcome: declined ? 'declined' : isError ? 'failed' : 'success',
+  };
+}
+
+function resultOutcome(value, result) {
+  if (/^aborted by user(?:\s+after\s+[\d.]+s)?\s*$/i.test(String(result).trim())) return 'declined';
+  if (value && typeof value === 'object') {
+    if (value.success === false) return 'failed';
+    if (typeof value.exit_code === 'number') return value.exit_code === 0 ? 'success' : 'failed';
+  }
+  return 'success';
+}
+
+// Bounded extraction only: find known tools.* calls without evaluating generated JavaScript.
+function callArgument(script, open) {
+  let depth = 1;
+  let quote = null;
+  let escaped = false;
+  for (let i = open + 1; i < script.length; i++) {
+    const ch = script[i];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (ch === '\\') escaped = true;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === '`') { quote = ch; continue; }
+    if (ch === '(' || ch === '{' || ch === '[') depth++;
+    else if (ch === ')' || ch === '}' || ch === ']') {
+      depth--;
+      if (depth === 0) return { text: script.slice(open + 1, i).trim(), end: i + 1 };
+    }
+  }
+  return null;
+}
+
+function decodeJsString(raw) {
+  if (!raw || !['"', "'", '`'].includes(raw[0]) || raw.at(-1) !== raw[0]) return null;
+  if (raw[0] === '"') {
+    try { return JSON.parse(raw); } catch { return null; }
+  }
+  const body = raw.slice(1, -1);
+  if (raw[0] === '`' && body.includes('${')) return null;
+  return body.replace(/\\([\\'`nrt])/g, (_match, char) => ({ n: '\n', r: '\r', t: '\t' }[char] ?? char));
+}
+
+function stringTokenAt(script, start) {
+  const quote = script[start];
+  if (!['"', "'", '`'].includes(quote)) return null;
+  let escaped = false;
+  for (let i = start + 1; i < script.length; i++) {
+    const ch = script[i];
+    if (escaped) escaped = false;
+    else if (ch === '\\') escaped = true;
+    else if (ch === quote) return script.slice(start, i + 1);
+  }
+  return null;
+}
+
+function resolveStringArgument(script, raw, before) {
+  const direct = decodeJsString(raw);
+  if (direct != null || !/^[A-Za-z_$][\w$]*$/.test(raw)) return direct;
+  const escaped = raw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const declaration = new RegExp(`(?:const|let|var)\\s+${escaped}\\s*=\\s*`, 'g');
+  let match;
+  let token = null;
+  while ((match = declaration.exec(script)) && match.index < before) {
+    token = stringTokenAt(script, declaration.lastIndex);
+  }
+  return token ? decodeJsString(token) : null;
+}
+
+function splitTopLevel(value, separator) {
+  const parts = [];
+  let start = 0;
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (ch === '\\') escaped = true;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === '`') { quote = ch; continue; }
+    if (ch === '(' || ch === '{' || ch === '[') depth++;
+    else if (ch === ')' || ch === '}' || ch === ']') depth--;
+    else if (ch === separator && depth === 0) {
+      parts.push(value.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(value.slice(start));
+  return parts;
+}
+
+function parseJsLiteral(script, raw, before) {
+  const value = raw.trim();
+  const decoded = decodeJsString(value);
+  if (decoded != null) return decoded;
+  try { return JSON.parse(value); } catch { /* JavaScript object syntax is not strict JSON. */ }
+  const resolved = resolveStringArgument(script, value, before);
+  return resolved == null ? value : resolved;
+}
+
+// Orchestrated tool calls are stored as JavaScript source, and their arguments commonly use object-literal
+// keys (`{ cmd: "pwd" }`) rather than strict JSON (`{"cmd":"pwd"}`). Parse only top-level literal fields;
+// never evaluate generated code. Unknown expressions stay as source text so the detail view loses nothing.
+function parseJsObjectInput(script, raw, before) {
+  const value = raw.trim();
+  if (!value.startsWith('{') || !value.endsWith('}')) return null;
+  const input = {};
+  for (const field of splitTopLevel(value.slice(1, -1), ',')) {
+    const colon = splitTopLevel(field, ':');
+    if (colon.length < 2) continue;
+    const rawKey = colon.shift().trim();
+    const key = decodeJsString(rawKey) ?? (/^[A-Za-z_$][\w$]*$/.test(rawKey) ? rawKey : null);
+    if (!key) continue;
+    input[key] = parseJsLiteral(script, colon.join(':').trim(), before);
+  }
+  return Object.keys(input).length ? input : null;
+}
+
+function parseToolInput(script, raw, before) {
+  const parsed = parseInput(raw);
+  if (parsed.value !== raw) return parsed;
+  return parseJsObjectInput(script, raw, before) || { script: raw };
+}
+
+function applyPatchCalls(patch) {
+  const header = /^\*\*\* (Add|Update|Delete) File: (.+)$/gm;
+  const sections = [];
+  let match;
+  while ((match = header.exec(patch))) {
+    sections.push({ kind: match[1], path: match[2].trim(), start: match.index });
+  }
+  if (!sections.length) return [{ name: 'apply_patch', input: { patch } }];
+  return sections.map((section, index) => {
+    const end = sections[index + 1]?.start ?? patch.indexOf('\n*** End Patch', section.start);
+    const body = patch.slice(section.start, end < 0 ? patch.length : end);
+    let added = 0;
+    let removed = 0;
+    for (const line of body.split('\n').slice(1)) {
+      if (line.startsWith('@@')) continue;
+      if (!/^[+\- ]/.test(line)) continue;
+      if (line.startsWith('+')) added++;
+      else if (line.startsWith('-')) removed++;
+    }
+    return {
+      name: 'apply_patch',
+      input: { file_path: section.path, patch },
+      diff: {
+        // apply_patch's persisted input normally uses bare `@@` markers with no file positions. Keep the
+        // stat, but never invent line zero; the transcript route enriches this from App Server's unified diff.
+        added, removed, hunks: null,
+        ...(section.kind === 'Add' ? { created: true } : {}),
+      },
+    };
+  });
+}
+
+function extractCustomCalls(script) {
+  const calls = [];
+  const re = /tools\.([A-Za-z][\w]*)\s*\(/g;
+  let match;
+  while ((match = re.exec(script))) {
+    const arg = callArgument(script, re.lastIndex - 1);
+    if (!arg) return null;
+    if (match[1] === 'apply_patch') {
+      const decoded = resolveStringArgument(script, arg.text, match.index);
+      calls.push(...(decoded == null
+        ? [{ name: 'apply_patch', input: { script: arg.text } }]
+        : applyPatchCalls(decoded)));
+    } else {
+      calls.push({ name: match[1], input: parseToolInput(script, arg.text, match.index) });
+    }
+    re.lastIndex = arg.end;
+  }
+  return calls.length ? calls : null;
+}
+
+function structuredResults(value) {
+  let parsed = value;
+  if (typeof parsed === 'string') {
+    try { parsed = JSON.parse(parsed); } catch { return null; }
+  }
+  if (Array.isArray(parsed)) {
+    for (let i = parsed.length - 1; i >= 0; i--) {
+      const text = parsed[i] && typeof parsed[i] === 'object' ? parsed[i].text : null;
+      if (typeof text !== 'string') continue;
+      try {
+        const object = JSON.parse(text);
+        if (object && typeof object === 'object' && !Array.isArray(object)) return Object.values(object);
+      } catch { /* try previous block */ }
+    }
+    return null;
+  }
+  return parsed && typeof parsed === 'object' ? Object.values(parsed) : null;
+}
+
+function applyCustomOutput(messages, value) {
+  const values = structuredResults(value);
+  if (values && values.length === messages.length) {
+    messages.forEach((message, index) => {
+      const result = values[index];
+      message.tool.result = outputText(result);
+      message.tool.outcome = resultOutcome(result, message.tool.result);
+      message.tool.isError = message.tool.outcome === 'failed';
+    });
+    return;
+  }
+  const raw = outputText(value).replace(/^Script completed[^\n]*\n(?:Wall time[^\n]*\n)?(?:Output:\n?)?/i, '');
+  const declined = /^aborted by user(?:\s+after\s+[\d.]+s)?\s*$/i.test(raw.trim());
+  messages.forEach((message, index) => {
+    message.tool.result = index === messages.length - 1 ? raw : '';
+    // A single extracted call has an exact persisted outcome. With several calls and one unstructured
+    // wrapper result, the rollout cannot identify which nested call produced it, so keep every card neutral.
+    message.tool.outcome = declined && messages.length === 1 ? 'declined'
+      : messages.length === 1 ? 'success' : 'completed';
+  });
+}
+
+export function createCodexTranscriptParser() {
+  const messages = [];
+  const pending = new Map();
+  let lineIndex = 0;
+
+  const toolMessage = (i, ts, name, input, diff, item) => ({
+    i, role: 'assistant', type: 'tool', ts,
+    ...(item?.internal_chat_message_metadata_passthrough?.turn_id
+      ? { turnId: item.internal_chat_message_metadata_passthrough.turn_id }
+      : {}),
+    tool: { name, input, result: null, isError: false, ...(diff ? { diff } : {}) },
+  });
+
+  function push(lines) {
+    for (const raw of lines) {
+      const i = lineIndex++;
+      const source = typeof raw === 'string' ? raw.trim() : '';
+      if (!source) continue;
+      let row;
+      try { row = JSON.parse(source); } catch { continue; }
+      const ts = typeof row.timestamp === 'string' ? row.timestamp : undefined;
+
+      if (row.type === 'compacted') { messages.push({ i, type: 'compact', ts }); continue; }
+      if (row.type !== 'response_item' || !row.payload || typeof row.payload !== 'object') continue;
+      const item = row.payload;
+
+      if (item.type === 'message') {
+        const text = messageText(item.content);
+        if (/^\s*<turn_aborted>/.test(text)) { messages.push({ i, type: 'interrupt', ts }); continue; }
+        if (item.role === 'developer') continue;
+        if (!['user', 'assistant'].includes(item.role) || !text.trim()) continue;
+        if (item.role === 'user') {
+          if (isCodexSyntheticUserText(text)) continue;
+          const slash = SLASH_CMD_RE.exec(text.trim());
+          if (slash) {
+            const marker = { i, type: 'slash', name: `/${slash[1]}`, ts };
+            if (slash[2]?.trim()) marker.args = slash[2].trim();
+            messages.push(marker);
+            continue;
+          }
+        }
+        const turnId = item.internal_chat_message_metadata_passthrough?.turn_id;
+        messages.push({ i, role: item.role, type: 'text', text, ts, ...(turnId ? { turnId } : {}) });
+        continue;
+      }
+
+      if (item.type === 'reasoning') {
+        const text = (Array.isArray(item.summary) ? item.summary : [])
+          .map((part) => part?.text || '').filter(Boolean).join('\n');
+        if (text.trim()) messages.push({ i, role: 'assistant', type: 'thinking', text, ts });
+        continue;
+      }
+
+      if (item.type === 'function_call') {
+        const message = toolMessage(i, ts, item.name || '', parseInput(item.arguments), null, item);
+        messages.push(message);
+        if (item.call_id) pending.set(item.call_id, [message]);
+        continue;
+      }
+      if (item.type === 'function_call_output') {
+        const targets = item.call_id && pending.get(item.call_id);
+        if (targets?.length === 1) {
+          const output = classicOutput(item.output);
+          targets[0].tool.result = output.result;
+          targets[0].tool.isError = output.isError;
+          targets[0].tool.outcome = output.outcome;
+          pending.delete(item.call_id);
+        }
+        continue;
+      }
+
+      if (item.type === 'tool_search_call') {
+        const message = toolMessage(i, ts, 'tool_search', parseInput(item.arguments), null, item);
+        if (item.status && item.status !== 'in_progress') {
+          message.tool.result = '';
+          message.tool.isError = item.status === 'failed';
+          message.tool.outcome = item.status === 'failed' ? 'failed' : 'success';
+        }
+        messages.push(message);
+        if (item.call_id) pending.set(item.call_id, [message]);
+        continue;
+      }
+      if (item.type === 'tool_search_output') {
+        const targets = item.call_id && pending.get(item.call_id);
+        if (targets?.length === 1) {
+          targets[0].tool.result = outputText(item.tools);
+          targets[0].tool.isError = item.status === 'failed';
+          targets[0].tool.outcome = item.status === 'failed' ? 'failed' : 'success';
+          pending.delete(item.call_id);
+        }
+        continue;
+      }
+
+      if (item.type === 'custom_tool_call') {
+        const script = typeof item.input === 'string' ? item.input : '';
+        const calls = extractCustomCalls(script);
+        const targets = calls
+          ? calls.map((call) => toolMessage(i, ts, call.name, call.input, call.diff, item))
+          : [toolMessage(i, ts, item.name || 'exec', { script: cap(script, SCRIPT_CAP) }, null, item)];
+        messages.push(...targets);
+        if (item.call_id) pending.set(item.call_id, targets);
+        continue;
+      }
+      if (item.type === 'custom_tool_call_output') {
+        const targets = item.call_id && pending.get(item.call_id);
+        if (targets) {
+          applyCustomOutput(targets, item.output);
+          pending.delete(item.call_id);
+        }
+      }
+    }
+    return messages;
+  }
+
+  return { push, messages };
+}
+
+export function parseCodexTranscript(lines) {
+  return createCodexTranscriptParser().push(lines);
+}

package/{hooks/handmux-codex-usage.cjs → src/codexUsageSnapshot.cjs}

@@ -1,6 +1,5 @@
-#!/usr/bin/env node
-// Persistent machine-wide Codex usage snapshot. This file is standalone CommonJS because hook installers
-// copy it into ~/.codex/hooks/, while the ESM server also requires the bundled copy directly.
+// Persistent machine-wide Codex usage snapshot utilities. Kept as CommonJS so the ESM usage service can
+// load the same bounded rollout reader without adding a second package boundary.
 const fs = require('node:fs');
 const path = require('node:path');
 
@@ -127,15 +126,4 @@ function writeSnapshot(snapshotPath, usage, { checkedAt } = {}) {
   }
 }
 
-function captureTranscript(transcriptPath, snapshotPath) {
-  const usage = readLatestUsage(transcriptPath);
-  if (!usage) return readSnapshot(snapshotPath)?.usage || null;
-  return writeSnapshot(snapshotPath, usage);
-}
-
-module.exports = {
-  readLatestUsage,
-  readSnapshot,
-  writeSnapshot,
-  captureTranscript,
-};
+module.exports = { readLatestUsage, readSnapshot, writeSnapshot };

package/src/httpApi.js

@@ -25,6 +25,7 @@ import { transcriptRoutes } from './routes/transcript.js';
 import { DEFAULT_SHORTCUTS } from './shortcutConfig.js';
 import { workspaceRoutes } from './routes/workspace.js';
 import { browserRoutes } from './browser/routes.js';
+import { codexRoutes } from './routes/codex.js';
 
 // Re-exported for tests (test/keys.test.js) and any caller that imported it by this path historically.
 export { isAllowedKey } from './routes/terminal.js';
@@ -38,6 +39,7 @@ export function createApiRouter({
   browserBootstrap,
   previewDomain,
   workspace,
+  codexApp,
   home = homedir(), stateFile = process.env.CLAUDE_STATE_FILE || claudeStatePath(homedir()),
 } = {}) {
   const r = express.Router();
@@ -47,7 +49,7 @@ export function createApiRouter({
 
   const deps = {
     token, commands, docs, git, push, notifications, claudeEvents,
-    uploadExts, maxUploadBytes, asrEnv, previews, shortcuts, home, stateFile, workspace, browser, browserBootstrap, previewDomain,
+    uploadExts, maxUploadBytes, asrEnv, previews, shortcuts, home, stateFile, workspace, browser, browserBootstrap, previewDomain, codexApp,
   };
 
   r.use(sessionRoutes(deps));
@@ -63,6 +65,7 @@ export function createApiRouter({
   // the worker-owned bootstrap ticket store.
   r.use('/browser-proxy', browserRoutes(browser ? deps : { ...deps, previewDomain: null }));
   r.use(transcriptRoutes(deps));
+  r.use(codexRoutes(deps));
   if (workspace) r.use(workspaceRoutes(deps));
 
   return r;

package/src/orphans.js

@@ -65,7 +65,9 @@ export async function takeoverOrphan(
   if (o.sessionId !== sessionId) return { error: 'session changed', status: 409 };
   if (!o.cwd) return { error: 'no cwd', status: 409 };
   const agent = getAgent(o.agent);
-  const cmd = agent.sessions.resumeArgs(sessionId).join(' ');
+  const cmd = agent.sessions.managedResumeCmd
+    ? agent.sessions.managedResumeCmd(sessionId)
+    : agent.sessions.resumeArgs(sessionId).join(' ');
 
   let sid;
   let wid;