@volter/supercode-teams 0.2.111 → 0.2.112

package/machine.mjs

@@ -48,6 +48,7 @@ import { request as httpRequest } from 'node:http';
 import { DEFAULT_RANK, normalizeRank, judge } from './attention.mjs';
 import { popupTerminal, openPopup } from './popup-terminals.mjs';
 import { JobOwner, executionCapabilities, streamProgram, serveWorkspace } from './execution.mjs';
+import { confirmNativeInitialInput } from './native-initial-input.mjs';
 
 /** The preload every launched pane carries: it announces the ports a pane's node processes listen on. */
 const PORTHOLE_HOOK = fileURLToPath(new URL('./porthole-hook.cjs', import.meta.url));
@@ -577,6 +578,52 @@ export class TeamsMachine extends MachineCore {
     return env;
   }
 
+  // Native session hooks carry the launcher's identity across Codex's shared
+  // app-server process boundary. Process ancestry alone cannot recover it.
+  #nativeQuestionCommand(params, pane, by, nativeInput) {
+    const args = params.arguments ?? [];
+    const name = String(params.program ?? '').split(/[\\/]/).pop();
+    if (process.platform === 'win32' || !((params.kind === 'codex' && name === 'codex') ||
+      (params.kind === 'claude-code' && name === 'claude'))) return launchCommand(params.program, args);
+    this.nativeQuestionHooksSupported ??= spawnSync(this.supercodeBin, ['message', 'native-question-hook', '--help'], { env: this.env, timeout: 2000, stdio: 'ignore' }).status === 0;
+    if (!this.nativeQuestionHooksSupported) return launchCommand(params.program, args);
+    const mailHome = this.env.SUPERCODE_HOME || join(this.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'supercode');
+    const dir = join(mailHome, 'mail', 'native-launches');
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    // A reused pane key still gets a new receipt baseline. A late hook from
+    // its previous process cannot publish evidence for this launch.
+    const binding = join(dir, `${pane}-${randomBytes(9).toString('base64url')}.json`);
+    const initialInput = params.initialInput && !args.includes('--') &&
+      !args.some((arg) => arg === '--remote' || arg.startsWith('--remote=')) ? params.initialInput : null;
+    writeFileSync(binding, JSON.stringify({ kind: params.kind, pane, by, program: params.program, arguments: args, initialInput }), { mode: 0o600 });
+    if (initialInput) nativeInput({ binding, kind: params.kind, text: initialInput, startedAt: Date.now() });
+    const claudeCommand = (next) => launchCommand(params.program, initialInput ? [...next, '--', initialInput] : next);
+    const quote = (value) => `'${String(value).replaceAll("'", "'\\''")}'`;
+    const command = `env SUPERCODE_HOME=${quote(mailHome)} ${quote(this.supercodeBin)} message native-question-hook ${quote(binding)}`;
+    const handler = { type: 'command', command, timeout: 3600 };
+    if (params.kind === 'claude-code') {
+      const hooks = { SessionStart: [{ hooks: [handler] }], PreToolUse: [{ matcher: 'AskUserQuestion', hooks: [handler] }], PostToolUse: [{ matcher: 'AskUserQuestion', hooks: [handler] }] };
+      // Claude accepts only one settings value. Preserve an existing inline
+      // object or file, including its hook arrays, in that same argument.
+      const next = [...args];
+      const at = next.findIndex((arg) => arg === '--settings' || arg.startsWith('--settings='));
+      if (at < 0) return claudeCommand([...next, '--settings', JSON.stringify({ hooks })]);
+      const inline = next[at].startsWith('--settings=');
+      const value = inline ? next[at].slice('--settings='.length) : next[at + 1];
+      const settings = JSON.parse(value?.trimStart().startsWith('{') ? value : readFileSync(resolve(params.cwd || process.cwd(), value), 'utf8'));
+      if (!settings || Array.isArray(settings) || typeof settings !== 'object') throw new Error('Claude --settings must be an object to add native question mail');
+      settings.hooks ??= {};
+      for (const [event, groups] of Object.entries(hooks)) settings.hooks[event] = [...(settings.hooks[event] ?? []), ...groups];
+      next.splice(at, inline ? 1 : 2, '--settings', JSON.stringify(settings));
+      return claudeCommand(next);
+    }
+    // The stock TUI's default embedded server has no attachable question
+    // door. Give this pane its own native server, through Codex's --remote
+    // Unix endpoint; never attach to another running session by inference.
+    if (args.some((arg) => arg === '--remote' || arg.startsWith('--remote='))) return launchCommand(params.program, args);
+    return launchCommand(process.execPath, [fileURLToPath(new URL('./native-codex-pane.mjs', import.meta.url)), binding]);
+  }
+
   /**
    * A session acts only on the panes it started: input, a turn, a suspend or a close from a session (`caller`, its
    * address) on a pane another session, a board or a person started is refused, naming who started it. A person (no
@@ -747,9 +794,18 @@ export class TeamsMachine extends MachineCore {
    * Never rejects. The only caller is a fire-and-forget from the request path,
    * where an unhandled rejection would take the daemon down over one pane.
    */
-  #deliverInitialInput({ key, contextKey, session, kind, by, input, act }) {
+  #deliverInitialInput({ key, contextKey, session, kind, by, input, act, nativeInput }) {
     const abort = new AbortController();
     const task = (async () => {
+      if (nativeInput) {
+        const result = await confirmNativeInitialInput(nativeInput, { signal: abort.signal,
+          deadlineMs: Date.now() + INITIAL_INPUT_READY_DEADLINE_MS, live: async () => Boolean(await this.#paneByContext(contextKey)) });
+        this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: result.delivered,
+          inputReadyBy: 'native-prompt', ...(result.delivered ? { inputReceipt: result.receipt } : { inputError: result.reason }) });
+        act('launch', `pane:${contextKey}`, result.delivered ? 'ok' : 'failed',
+          result.delivered ? 'first input confirmed by native user message' : `native first input unconfirmed: ${result.reason}`);
+        return;
+      }
       const readyBy = await this.#awaitInputReady(session, contextKey, kind, abort.signal);
       if (readyBy === 'aborted') return;
       if (readyBy === 'pane-gone' || readyBy === 'deadline') {
@@ -1229,9 +1285,10 @@ export class TeamsMachine extends MachineCore {
         this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, status: 'issued' });
         if (params.kind === 'claude-code' && params.cwd && (params.arguments ?? []).includes('--dangerously-skip-permissions')) trustClaudeFolder(params.cwd);
         let session;
+        let nativeInput;
         try {
           session = await this.host.createSession({
-            command: launchCommand(params.program, params.arguments ?? []),
+            command: this.#nativeQuestionCommand(params, contextKey, by, (value) => { nativeInput = value; }),
             contextKey,
             cwd: params.cwd,
             // A pane that runs one verb for its launcher (`close`/`stop` on another machine) acts as that launcher.
@@ -1261,7 +1318,7 @@ export class TeamsMachine extends MachineCore {
         // outcome is recorded against the launch key, so `launches.get|list`
         // answers "did my message go in, and was it late?" without anyone
         // reading the screen.
-        if (params.initialInput) this.#deliverInitialInput({ key, contextKey, session, kind: params.kind ?? null, by, input: params.initialInput, act });
+        if (params.initialInput) this.#deliverInitialInput({ key, contextKey, session, kind: params.kind ?? null, by, input: params.initialInput, act, nativeInput });
         // A program that ends at once (not found, not runnable, failing on its first line) takes its pane with it:
         // the caller is told, with its exit status, instead of being handed a pane that is already gone.
         await new Promise((resolve) => setTimeout(resolve, LAUNCH_SETTLE_MS));

package/native-codex-pane.mjs

@@ -0,0 +1,54 @@
+// A native Codex TUI and its native app-server share one private local endpoint.
+// Supercode hosts neither the agent nor its run loop; it can attach to native
+// question requests while the stock TUI remains the session's UI.
+import { spawn } from 'node:child_process';
+import { readFileSync, writeFileSync, renameSync, mkdtempSync, existsSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const path = process.argv[2];
+const seed = JSON.parse(readFileSync(path, 'utf8'));
+const directory = mkdtempSync(join(tmpdir(), 'sc-codex-'));
+const socketPath = join(directory, 'native.sock');
+const endpoint = `unix://${socketPath}`;
+// Configuration is evaluated by the native server. Model, approval and
+// workspace options remain the TUI's own thread-start/resume arguments.
+const config = [];
+for (let index = 0; index < seed.arguments.length; index += 1) {
+  const arg = seed.arguments[index];
+  if (['-c', '--config', '--enable', '--disable'].includes(arg)) config.push(arg, seed.arguments[++index]);
+  else if (/^--(?:config|enable|disable)=/.test(arg)) config.push(arg);
+}
+const server = spawn(seed.program, ['app-server', '--listen', endpoint, ...config], { stdio: ['ignore', 'ignore', 'inherit'] });
+let tui;
+let ended = false;
+let serverError;
+server.on('error', (error) => { serverError = error; });
+server.on('exit', () => { ended = true; tui?.kill('SIGTERM'); });
+const stop = () => { tui?.kill('SIGTERM'); server.kill('SIGTERM'); };
+for (const signal of ['SIGTERM', 'SIGHUP', 'SIGINT']) process.on(signal, stop);
+// A killed tmux pane can orphan the wrapper without delivering a signal.
+// Its original parent disappearing closes only these two owned processes.
+const parent = process.ppid;
+const guard = setInterval(() => { if (process.ppid !== parent) stop(); }, 1000);
+try {
+  const deadline = Date.now() + 15_000;
+  while (!existsSync(socketPath) && !ended && !serverError && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 50));
+  if (!existsSync(socketPath) || serverError || ended) throw serverError ?? new Error('Native Codex question endpoint did not start; no TUI input was sent.');
+  const staged = `${path}.${process.pid}`;
+  writeFileSync(staged, JSON.stringify({ ...seed, socketPath, ownerPid: process.pid }), { mode: 0o600 });
+  renameSync(staged, path);
+  const args = [...seed.arguments, '--remote', endpoint];
+  if (!args.some((arg) => arg === '-C' || arg === '--cd' || arg.startsWith('--cd='))) args.push('--cd', process.cwd());
+  if (seed.initialInput) args.push('--', seed.initialInput);
+  tui = spawn(seed.program, args, { stdio: 'inherit' });
+  process.exitCode = await new Promise((resolve, reject) => { tui.once('exit', (code) => resolve(code ?? 1)); tui.once('error', reject); });
+} catch (error) {
+  process.stderr.write(`supercode: ${error.message}\n`);
+  process.exitCode = 1;
+} finally {
+  clearInterval(guard);
+  stop();
+  if (!ended) await Promise.race([new Promise((resolve) => server.once('exit', resolve)), new Promise((resolve) => setTimeout(() => { server.kill('SIGKILL'); resolve(); }, 3000))]);
+  rmSync(directory, { recursive: true, force: true });
+}

package/native-initial-input.mjs

@@ -0,0 +1,64 @@
+// Native CLIs accept an initial prompt before their TUI starts. Their own
+// transcript, not a collapsed paste badge or an empty editor, confirms receipt.
+import { open, readFile } from 'node:fs/promises';
+import { StringDecoder } from 'node:string_decoder';
+import { codexQuestions } from './native-questions.mjs';
+
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export async function confirmNativeInitialInput({ binding, kind, text, startedAt }, { signal, deadlineMs, live }) {
+  const readers = new Map();
+  const expired = () => signal.aborted || Date.now() >= deadlineMs;
+  try {
+    while (!expired()) {
+      if (!await live()) return { delivered: false, reason: 'pane-gone' };
+      let paths = [];
+      try {
+        if (kind === 'claude-code') {
+          paths = [JSON.parse(await readFile(binding.replace(/\.json$/, '.session.json'), 'utf8'))];
+        } else {
+          const seed = JSON.parse(await readFile(binding, 'utf8'));
+          if (seed.socketPath) {
+            const snapshot = await codexQuestions({ socketPath: seed.socketPath, discover: true, pathsOnly: true,
+              timeoutMs: Math.min(2000, Math.max(1, deadlineMs - Date.now())) });
+            paths = snapshot.threads.map(({ path }) => ({ path, offset: 0 }));
+          }
+        }
+      } catch { /* Startup may not yet have published its native session. */ }
+      for (const entry of paths) {
+        if (!entry.path) continue;
+        let reader = readers.get(entry.path);
+        if (!reader) {
+          try {
+            reader = { file: await open(entry.path, 'r'), position: entry.offset, decoder: new StringDecoder('utf8'), buffered: '' };
+            readers.set(entry.path, reader);
+          } catch { continue; }
+        }
+        const bytes = Buffer.alloc(64 * 1024);
+        while (!expired()) {
+          const { bytesRead } = await reader.file.read(bytes, 0, bytes.length, reader.position);
+          if (!bytesRead) break;
+          reader.position += bytesRead;
+          reader.buffered += reader.decoder.write(bytes.subarray(0, bytesRead));
+          let newline;
+          while ((newline = reader.buffered.indexOf('\n')) >= 0) {
+            const line = reader.buffered.slice(0, newline); reader.buffered = reader.buffered.slice(newline + 1);
+            let record;
+            try { record = JSON.parse(line); } catch { continue; }
+            let content;
+            if (kind === 'claude-code' && record.type === 'user' && !record.isMeta) content = record.message?.content;
+            if (kind === 'codex' && record.type === 'response_item' && record.payload?.type === 'message' &&
+                record.payload.role === 'user' && Date.parse(record.timestamp) >= startedAt) content = record.payload.content;
+            const value = typeof content === 'string' ? content : Array.isArray(content) &&
+              content.every((part) => ['text', 'input_text'].includes(part.type)) ? content.map((part) => part.text).join('') : null;
+            if (value === text) return { delivered: true, receipt: 'native-user-message' };
+          }
+        }
+      }
+      await pause(250);
+    }
+    return { delivered: false, reason: signal.aborted ? 'aborted' : 'native-input-unconfirmed' };
+  } finally {
+    await Promise.all([...readers.values()].map(({ file }) => file.close()));
+  }
+}

package/native-questions.mjs

@@ -0,0 +1,160 @@
+// Native Codex TUI questions, through the same local app-server that owns the
+// TUI's running thread. This never starts a runtime or writes terminal input.
+import { connect } from 'node:net';
+import { open } from 'node:fs/promises';
+import { StringDecoder } from 'node:string_decoder';
+import { pathToFileURL } from 'node:url';
+import WebSocket from 'ws';
+
+const questionMethod = 'item/tool/requestUserInput';
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const failure = (code, message) => Object.assign(new Error(message), { code });
+
+function identity(params) {
+  return { threadId: params.threadId, turnId: params.turnId, itemId: params.itemId };
+}
+
+function sameQuestion(left, right) {
+  return ['threadId', 'turnId', 'itemId'].every((key) => typeof left?.[key] === 'string' && left[key] === right?.[key]);
+}
+
+/** Read or answer one running native TUI thread. A response's id is scoped to
+ * its connection, so reattach and match the stable thread/turn/item identity;
+ * never persist the JSON-RPC id as the identity of a question.
+ */
+export async function codexQuestions({ threadId, threadIds, answer, socketPath, discover = false, pathsOnly = false, timeoutMs = 15_000 } = {}) {
+  const targets = new Set(threadIds ?? (threadId ? [threadId] : []));
+  if ((!targets.size && !(discover && socketPath)) || [...targets].some((id) => typeof id !== 'string' || !id) || (answer && targets.size !== 1)) throw failure('invalid-request', 'Native thread ids are required; answer only one thread at a time.');
+  if (!socketPath) throw failure('native-question-unavailable', 'This launch has no native question endpoint.');
+  const socket = new WebSocket('ws://localhost/', { perMessageDeflate: false, createConnection: () => connect(socketPath), handshakeTimeout: timeoutMs });
+  let nextId = 0;
+  const pending = new Map();
+  const questions = new Map();
+  const threads = [];
+  let submitted = null;
+  let resolved = false;
+  let transcript;
+  let transcriptPath;
+  let ended = null;
+  const request = (method, params) => new Promise((resolve, reject) => {
+    const id = ++nextId;
+    pending.set(id, { resolve, reject });
+    socket.send(JSON.stringify({ id, method, params }));
+  });
+  const failPending = (error) => {
+    ended = error;
+    for (const waiter of pending.values()) waiter.reject(error);
+    pending.clear();
+  };
+  socket.on('error', failPending);
+  socket.on('close', () => failPending(failure('native-question-disconnected', 'The native question connection closed.')));
+  socket.on('message', (bytes) => {
+    let message;
+    try { message = JSON.parse(bytes); } catch { return; }
+    if (!message.method) {
+      const waiter = pending.get(message.id);
+      if (waiter) {
+        pending.delete(message.id);
+        if (message.error) waiter.reject(failure('native-question-refused', message.error.message));
+        else waiter.resolve(message.result);
+      }
+      return;
+    }
+    if (!targets.has(message.params?.threadId)) return;
+    if (message.method === questionMethod) questions.set(message.id, message.params);
+    if (message.method === 'serverRequest/resolved') {
+      questions.delete(message.params.requestId);
+      if (submitted === message.params.requestId) resolved = true;
+    }
+  });
+  const timer = setTimeout(() => {
+    failPending(failure('native-question-timeout', submitted === null ? 'The native question did not answer in time.' : 'The answer is unconfirmed; do not resend it automatically.'));
+    socket.terminate();
+  }, timeoutMs);
+  try {
+    await new Promise((resolve, reject) => { socket.once('open', resolve); socket.once('error', reject); });
+    await request('initialize', { clientInfo: { name: 'supercode_native_questions', version: '1' }, capabilities: { experimentalApi: true } });
+    socket.send(JSON.stringify({ method: 'initialized' }));
+    // Resuming a persisted thread would start another native execution. Only
+    // attach when the daemon itself lists this thread as already loaded.
+    let cursor;
+    const loaded = new Set();
+    do {
+      const page = await request('thread/loaded/list', { ...(cursor ? { cursor } : {}), limit: 100 });
+      for (const id of page.data ?? []) if (discover || targets.has(id)) loaded.add(id);
+      cursor = page.nextCursor;
+    } while (cursor && (discover || loaded.size < targets.size));
+    if (answer && !loaded.has(threadId)) throw failure('native-thread-not-running', 'The native daemon does not have this thread loaded; nothing was started.');
+    for (const id of loaded) {
+      const snapshot = await request('thread/read', { threadId: id, includeTurns: false });
+      if (snapshot.thread?.ephemeral) continue;
+      if (answer) transcriptPath = snapshot.thread?.path;
+      targets.add(id);
+      threads.push({ id, path: snapshot.thread?.path });
+      if (pathsOnly) continue;
+      if (!answer && snapshot.thread?.status?.type === 'idle') continue;
+      await request('thread/resume', { threadId: id, excludeTurns: true });
+    }
+    // The native server replays unresolved requests after its resume response.
+    if (!pathsOnly) await pause(200);
+    if (ended) throw ended;
+    if (!answer) return { threads, questions: [...questions.values()].map((question) => ({ ...identity(question), questions: question.questions })), transport: 'codex-native-app-server' };
+    const current = [...questions].find(([, question]) => sameQuestion(question, answer.question));
+    if (!current) return { delivered: false, reason: 'question-no-longer-pending' };
+    const [id, question] = current;
+    const wanted = question.questions.map((entry) => entry.id);
+    if (!answer.answers || Object.keys(answer.answers).length !== wanted.length || wanted.some((key) => !Array.isArray(answer.answers[key]?.answers) || answer.answers[key].answers.length === 0 || answer.answers[key].answers.some((text) => typeof text !== 'string'))) {
+      throw failure('invalid-answer', 'Answer every native question id with a nonempty answers array.');
+    }
+    // Synchronous from the last pending-state read through send: no sleep,
+    // subprocess or terminal operation can insert an answer to another prompt.
+    if (!transcriptPath) return { delivered: false, reason: 'native-receipt-unavailable' };
+    transcript = await open(transcriptPath, 'r');
+    let position = (await transcript.stat()).size;
+    let buffered = '';
+    const decoder = new StringDecoder('utf8');
+    const bytes = Buffer.alloc(64 * 1024);
+    submitted = id;
+    socket.send(JSON.stringify({ id, result: { answers: answer.answers } }));
+    // A resolved request alone could have been answered by the TUI racing us.
+    // Confirm the native tool result carries these answers for this call id.
+    let matched = false;
+    while (!ended) {
+      const { bytesRead } = await transcript.read(bytes, 0, bytes.length, position);
+      position += bytesRead;
+      buffered += decoder.write(bytes.subarray(0, bytesRead));
+      let newline;
+      while ((newline = buffered.indexOf('\n')) >= 0) {
+        const line = buffered.slice(0, newline); buffered = buffered.slice(newline + 1);
+        let item;
+        try { item = JSON.parse(line).payload; } catch { continue; }
+        if (item?.type !== 'function_call_output' || item.call_id !== answer.question.itemId) continue;
+        let result;
+        try { result = typeof item.output === 'string' ? JSON.parse(item.output) : item.output; } catch { continue; }
+        matched = wanted.every((key) => JSON.stringify(result?.answers?.[key]?.answers) === JSON.stringify(answer.answers[key].answers));
+        if (!matched) return { delivered: false, reason: 'native-question-answered-differently' };
+      }
+      if (resolved && matched) return { delivered: true, question: identity(answer.question), transport: 'codex-native-app-server', receipt: 'native-tool-result' };
+      await pause(25);
+    }
+    throw ended;
+  } finally {
+    clearTimeout(timer);
+    await transcript?.close();
+    socket.close();
+  }
+}
+
+// The Rust mailbox calls this narrow adapter. stdin carries JSON so answer
+// text never becomes shell syntax or a process-list argument.
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  try {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    const result = await codexQuestions(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+  } catch (error) {
+    process.stdout.write(`${JSON.stringify({ delivered: false, reason: error.code ?? 'native-question-error', detail: error.message })}\n`);
+    process.exitCode = 1;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.111",
+  "version": "0.2.112",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",