@volter/supercode-teams 0.3.106 → 0.3.108

package/codex-startup.mjs

@@ -131,3 +131,30 @@ export async function settleCodexHookReview(host, sessionId, { signal, deadlineM
   }
   return signal.aborted ? 'aborted' : 'deadline';
 }
+
+/** The most one bracketed paste carries into a Windows Codex: ConPTY and Codex drop a whole paste past about 8190
+ *  characters (measured 2026-10-06, codex-cli 0.160.1: 8180 arrived, 8200 did not), while consecutive pastes join
+ *  into one composer entry. */
+export const CODEX_WINDOWS_PASTE_CHARS = 8000;
+
+/** One character as a Windows Codex reads it from its console. Codex drops some BMP characters that arrive as plain
+ *  text through ConPTY (measured: `—`, `…`, `✓` vanish while `é`, `日`, and astral `🙂` arrive), so every BMP
+ *  character past ASCII goes as a win32-input-mode key event carrying its UTF-16 unit (VK_PACKET, 231), which ConPTY
+ *  hands Codex as exactly that character. ASCII and astral characters go as they are. */
+function codexWindowsCharacter(character) {
+  const unit = character.codePointAt(0);
+  if (unit < 0x80 || unit > 0xffff) return character;
+  return `\u001b[231;0;${unit};1;0;1_\u001b[231;0;${unit};0;0;1_`;
+}
+
+/** Text as the raw writes that paste it into a Windows Codex composer: bracketed pastes of at most
+ *  CODEX_WINDOWS_PASTE_CHARS characters each, non-ASCII BMP characters as key events. Written as they are (a terminal
+ *  host turns `\n` into `\r`, which Codex keeps as a line break inside a paste); never submitted here. */
+export function codexWindowsPastes(text) {
+  const characters = Array.from(String(text));
+  const pastes = [];
+  for (let at = 0; at < characters.length; at += CODEX_WINDOWS_PASTE_CHARS) {
+    pastes.push(`\u001b[200~${characters.slice(at, at + CODEX_WINDOWS_PASTE_CHARS).map(codexWindowsCharacter).join('')}\u001b[201~`);
+  }
+  return pastes;
+}

package/machine.mjs

@@ -93,7 +93,7 @@ import { JobOwner, executionCapabilities, streamProgram, serveWorkspace } from '
 import { TerminalMailbox, retainedTerminalMail } from './terminal-mail.mjs';
 import { confirmNativeInitialInput } from './native-initial-input.mjs';
 import { sessionPeople } from './session-people.mjs';
-import { canonicalCodexFolderTrust, codexProgram, codexStartupArguments, codexUpdatePrompt, codexVersion, settleCodexHookReview } from './codex-startup.mjs';
+import { canonicalCodexFolderTrust, codexProgram, codexStartupArguments, codexUpdatePrompt, codexVersion, codexWindowsPastes, settleCodexHookReview } from './codex-startup.mjs';
 import { sessionNoticeTarget } from './session-notice-target.mjs';
 import { serveAppDoor } from './app-door.mjs';
 
@@ -203,6 +203,26 @@ const TURN_CONFIRM_MS = 60_000;
  * as the program (`open --new "npm run build"`), that line through this machine's own shell, so a caller on
  * another machine need not know which shell or platform this one has.
  */
+/** How long the Windows pane host's command line for `program args` is, quoted as it quotes a batch program's
+ *  arguments (sdk/terminal `batchArgument`: `"` doubled, a `\` run before a `"` doubled, `%` as `%%cd:~,%`), plus
+ *  the `cmd /e:ON /v:OFF /d /s /c "…"` around it. An upper bound for a program cmd does not run. */
+function windowsCommandLineLength(program, args) {
+  const quoted = (value) => {
+    let length = 2;
+    let backslashes = 0;
+    for (const character of String(value)) {
+      if (character === '\\') backslashes += 1;
+      else {
+        if (character === '"') length += backslashes + 1;
+        backslashes = 0;
+      }
+      length += character === '%' ? 8 : 1;
+    }
+    return length + backslashes;
+  };
+  return [program, ...args].reduce((total, value) => total + quoted(value) + 1, 0) + 32;
+}
+
 function launchCommand(program, args) {
   const line = typeof program === 'string' ? program.trim() : '';
   if (!args.length && /\s/.test(line) && !existsSync(line)) {
@@ -478,6 +498,10 @@ export class TeamsMachine extends MachineCore {
     // Set by a service-run connector: how `machine.restart` ends this daemon so its service manager starts it again.
     this.restartHandler = null;
     this.launches = new Launches(this.p.launches);
+    // the panes' stable porthole hook and the machine's stable supercode brought up to this release's at start, under
+    // every pane already running
+    this.#portholeHook();
+    this.#stableSupercode();
     // Windows has no tmux: its panes live in the machine's pane server, a process of their own that outlives this
     // daemon (a restart or an upgrade never ends a pane), as tmux panes live in tmux's server.
     if (process.platform === 'win32' && !terminal.PaneServerHost) throw new Error('panes on Windows need a newer @volter/supercode-terminal (one with PaneServerHost)');
@@ -1754,6 +1778,49 @@ export class TeamsMachine extends MachineCore {
     }
   }
 
+  /**
+   * The porthole hook as a pane names it: one stable path in the machine's home, never this package's own. A pane keeps
+   * the NODE_OPTIONS it was launched with for as long as it runs, and `--require` of a missing file kills every node
+   * program in it; a path inside a Teams package goes missing when the daemon moves to another package and the old one
+   * is removed (yuerans, 2026-10-06: the daemon moved from ~/.local to /opt/homebrew, ~/.local's packages were
+   * removed, and every node program in the older panes, supercode itself among them, died with MODULE_NOT_FOUND). The
+   * package's hook is copied there whenever it differs (replaced whole, by rename), so every pane, old or new, runs
+   * the daemon's current hook; a home that cannot hold it falls back to the package's path.
+   */
+  /**
+   * The machine's stable supercode (`<SUPERCODE_HOME>/bin/supercode`, claude_relay.rs `stable_program_path`), pointed at
+   * this daemon's native once per daemon (`__stable-program`), for a command a pane records; this daemon's own
+   * supercode when its native has no such verb or the shim cannot be written.
+   */
+  #stableSupercode() {
+    if (this.stableSupercodePath !== undefined) return this.stableSupercodePath ?? this.supercodeBin;
+    this.stableSupercodePath = null;
+    try {
+      const answer = spawnSync(this.supercodeBin, ['__stable-program'], { env: this.env, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
+      const path = answer.status === 0 ? answer.stdout.trim() : '';
+      if (path && isAbsolute(path) && existsSync(path)) this.stableSupercodePath = path;
+    } catch { /* this daemon's own supercode */ }
+    return this.stableSupercodePath ?? this.supercodeBin;
+  }
+
+  #portholeHook() {
+    if (this.portholeHookPath) return this.portholeHookPath;
+    const stable = join(supercodeHome(this.env), 'porthole-hook.cjs');
+    try {
+      const hook = readFileSync(PORTHOLE_HOOK);
+      let current = null;
+      try { current = readFileSync(stable); } catch { /* not there yet */ }
+      if (!current?.equals(hook)) {
+        mkdirSync(dirname(stable), { recursive: true });
+        const staged = `${stable}.${process.pid}.tmp`;
+        writeFileSync(staged, hook, { mode: 0o644 });
+        renameSync(staged, stable);
+      }
+      this.portholeHookPath = stable;
+    } catch { this.portholeHookPath = PORTHOLE_HOOK; }
+    return this.portholeHookPath;
+  }
+
   /**
    * The environment every launched pane carries: the porthole hook preloaded into
    * each node process the pane runs, the announce directory it writes into, and the pane's
@@ -1766,9 +1833,10 @@ export class TeamsMachine extends MachineCore {
     env.PATH ??= this.env.PATH;
     // Its CLI reads this machine's contexts and sockets, not whatever home that server started with.
     if (this.env.SUPERCODE_HOME) env.SUPERCODE_HOME ??= this.env.SUPERCODE_HOME;
-    const inherited = env.NODE_OPTIONS ?? this.env.NODE_OPTIONS ?? '';
+    // an inherited porthole preload (a daemon started from a pane, or an older daemon's path) is replaced, never stacked
+    const inherited = String(env.NODE_OPTIONS ?? this.env.NODE_OPTIONS ?? '').replace(/\s*--require[= ]("[^"]*porthole-hook\.cjs"|\S*porthole-hook\.cjs)/g, '');
     // Quoted: NODE_OPTIONS splits on spaces, and a home path may hold one (Windows user folders often do).
-    env.NODE_OPTIONS = `${inherited} --require ${JSON.stringify(PORTHOLE_HOOK)}`.trim();
+    env.NODE_OPTIONS = `${inherited} --require ${JSON.stringify(this.#portholeHook())}`.trim();
     env.SUPERCODE_TEAMS_PORTS_DIR = this.portsDir;
     env.SUPERCODE_TEAMS_PANE = contextKey;
     return env;
@@ -1782,20 +1850,24 @@ export class TeamsMachine extends MachineCore {
     const name = String(params.program ?? '').split(/[\\/]/).pop();
     // Windows has no Unix endpoint for a pane's own native server, so a fresh Codex there starts with no session to
     // type into: its rollout appears only with its first turn. Its first input is therefore Codex's own argv prompt,
-    // as it is on the other platforms, and the receipt is the rollout that records it under CODEX_HOME. A batch
-    // command line cannot carry a line break, so multi-line input keeps the pane and is typed as before.
+    // as it is on the other platforms, and the receipt is the rollout that records it under CODEX_HOME. Input a
+    // command line cannot carry — a line break (a batch line ends there), or past cmd's 8191 characters
+    // (CreateProcess's 32767 for an .exe) — is pasted into the composer once it is up instead
+    // (#typeCodexFirstInput), under the same receipt.
     if (process.platform === 'win32' && params.kind === 'codex' && /^codex(?:\.cmd|\.exe)?$/i.test(name)) {
-      const initialInput = params.initialInput && !/[\r\n\0]/.test(params.initialInput) && !args.includes('--') &&
+      const initialInput = params.initialInput && !args.includes('--') &&
         !args.some((arg) => arg === '--remote' || arg.startsWith('--remote=')) ? params.initialInput : null;
       if (!initialInput) return launchCommand(params.program, args);
+      const typed = /[\r\n\0]/.test(initialInput) || windowsCommandLineLength(params.program, [...args, '--', initialInput]) >
+        (/\.(cmd|bat)$/i.test(params.program) ? 8000 : 32000);
       const codexHome = params.env?.CODEX_HOME || this.env.CODEX_HOME || join(homedir(), '.codex');
       // A resume appends to the rollout it names (`resume <id>`; `--last` names none). A fork writes a new
       // rollout, so its receipt is found as a fresh session's is.
       const verb = args.indexOf('resume');
       const named = verb >= 0 ? args.slice(verb + 1).find((arg) => /^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(arg)) : null;
       nativeInput({ kind: params.kind, text: initialInput, startedAt: Date.now(), codexSessions: join(codexHome, 'sessions'),
-        cwd: params.cwd || null, continuing: verb >= 0, resumeId: named ?? null });
-      return launchCommand(params.program, [...args, '--', initialInput]);
+        cwd: params.cwd || null, continuing: verb >= 0, resumeId: named ?? null, typed });
+      return launchCommand(params.program, typed ? args : [...args, '--', initialInput]);
     }
     if (process.platform === 'win32' || !((params.kind === 'codex' && name === 'codex') ||
       (params.kind === 'claude-code' && name === 'claude'))) return launchCommand(params.program, args);
@@ -1817,7 +1889,8 @@ export class TeamsMachine extends MachineCore {
     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)}`;
+    // the machine's stable supercode: the session outlives this daemon's install path (an upgrade or a move)
+    const command = `env SUPERCODE_HOME=${quote(mailHome)} ${quote(this.#stableSupercode())} 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] }] };
@@ -2093,11 +2166,26 @@ export class TeamsMachine extends MachineCore {
   #deliverInitialInput({ key, contextKey, session, kind, by, input, act, nativeInput, executable = {}, resumed = {} }) {
     const abort = new AbortController();
     const task = (async () => {
+      let nativeReadyBy = 'native-prompt';
+      if (nativeInput?.typed) {
+        // A Windows Codex input its command line could not carry: pasted once the composer is up, and confirmed by
+        // the same rollout receipt as an argv prompt. Its pane has no native session to mail yet.
+        nativeReadyBy = await this.#awaitInputReady(session, contextKey, kind, abort.signal);
+        if (nativeReadyBy === 'aborted') return;
+        const typed = nativeReadyBy === 'pane-gone' || nativeReadyBy === 'deadline' ? { delivered: false, reason: nativeReadyBy }
+          : await this.#typeCodexFirstInput(session, input, abort.signal);
+        if (!typed.delivered) {
+          this.launches.record({ key, pane: contextKey, kind, by, ...resumed, ...executable, status: 'ready', inputDelivered: false,
+            inputReadyBy: nativeReadyBy, inputError: typed.reason });
+          act('launch', `pane:${contextKey}`, 'failed', `first input undelivered: ${typed.reason}`);
+          return;
+        }
+      }
       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, ...resumed, ...executable, status: 'ready', inputDelivered: result.delivered,
-          inputReadyBy: 'native-prompt', ...(result.delivered ? { inputReceipt: result.receipt } : { inputError: result.reason }),
+          inputReadyBy: nativeReadyBy, ...(result.delivered ? { inputReceipt: result.receipt } : { inputError: result.reason }),
           ...(result.native_session ? { native_session: result.native_session } : {}) });
         act('launch', `pane:${contextKey}`, result.delivered ? 'ok' : result.queued ? 'input-pending' : 'failed',
           result.delivered ? 'first input confirmed by native user message' : `native first input unconfirmed: ${result.reason}`);
@@ -2239,6 +2327,41 @@ export class TeamsMachine extends MachineCore {
     return filed?.code === 0 ? null : `the line was typed but its sender was not recorded: ${filed?.text ?? 'the filing door answered nothing'}`;
   }
 
+  /**
+   * A fresh Windows Codex's first input, pasted into its empty composer and submitted once: the input its command
+   * line could not carry. Each bracketed paste stays under CODEX_WINDOWS_PASTE_CHARS, and Codex joins consecutive
+   * ones into one entry. Delivery is not claimed here — the caller's rollout receipt confirms what Codex took.
+   */
+  async #typeCodexFirstInput(session, text, signal) {
+    const body = String(text).replace(/\r\n?/g, '\n').replace(/\n+$/u, '');
+    if (!body.trim() || /[\u0000-\u0008\u000b-\u001f\u007f]/u.test(body)) return { delivered: false, reason: 'unsupported-text' };
+    if (this.inputInFlight.has(session.id)) return { delivered: false, reason: 'input-in-flight' };
+    this.inputInFlight.add(session.id);
+    try {
+      const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      // Styled, so the composer's dim placeholder ("Ask Codex to do anything") reads as empty.
+      const composer = async () => terminal.composerText?.('codex', await this.host.capture(session.id, { preserveEscapes: true })) ?? null;
+      if (await composer() !== '') return { delivered: false, reason: 'composer-not-empty' };
+      for (const paste of codexWindowsPastes(body)) {
+        if (signal.aborted) return { delivered: false, reason: 'aborted' };
+        await this.host.sendInput(session.id, paste, { submitMode: 'none' });
+        await pause(300);
+      }
+      let held = false;
+      for (let attempt = 0; attempt < 20 && !held && !signal.aborted; attempt += 1) {
+        held = Boolean(await composer());
+        if (!held) await pause(150);
+      }
+      if (!held) return { delivered: false, reason: 'paste-unconfirmed' };
+      await this.host.sendInput(session.id, '\r', { submitMode: 'single' });
+      return { delivered: true };
+    } catch (error) {
+      return { delivered: false, reason: error?.message ?? String(error) };
+    } finally {
+      this.inputInFlight.delete(session.id);
+    }
+  }
+
   async #deliverPaneText(session, contextKey, text, options = {}) {
     const kind = this.#paneKind(contextKey, session);
     if (kind === 'codex' && codexUpdatePrompt(await this.host.capture(session.id, { lines: 120 }))) return { delivered: false, reason: 'codex-update-prompt: delivery refused; restart Codex with check_for_update_on_startup=false' };

package/native-initial-input.mjs

@@ -7,6 +7,9 @@ import { codexQuestions } from './native-questions.mjs';
 
 const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+/** Input as a composer takes it: line ends as `\n`, without the outer whitespace a submit trims. */
+const normalizedInput = (text) => String(text).replace(/\r\n?/g, '\n').trim();
+
 /** Rollouts one daemon's launches have already taken as their receipt, with when: a launch that began before a
  *  claim does not answer from that transcript, while a later launch (a resume of the same session) still can, since
  *  its receipt must be newer than it anyway. This orders launches; it does not prove ownership — two panes in one
@@ -100,7 +103,10 @@ export async function confirmNativeInitialInput({ binding, kind, text, startedAt
               content.every((part) => ['text', 'input_text'].includes(part.type)) ? content.map((part) => part.text).join('') : null;
             // The transcript that confirms the input also names the session it belongs to: the launch records it,
             // so a session can be told apart as one an agent launched (Claude Code's sessionId; Codex's rollout id).
-            if (value === text) {
+            // A Windows Codex input may have been pasted: its line ends normalized and trailing newlines dropped.
+            const same = codexSessions && typeof value === 'string'
+              ? normalizedInput(value) === normalizedInput(text) : value === text;
+            if (same) {
               const native = kind === 'claude-code' ? record.sessionId : /([0-9a-f]{8}-[0-9a-f-]{27})\.jsonl$/.exec(entry.path)?.[1];
               if (codexSessions) claimedRollouts.set(entry.path, Date.now());
               return { delivered: true, receipt: 'native-user-message', ...(typeof native === 'string' && native ? { native_session: native } : {}) };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.106",
+  "version": "0.3.108",
   "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",

package/terminal-mail.mjs

@@ -5,7 +5,7 @@ import { join } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { StringDecoder } from 'node:string_decoder';
-import { codexUpdatePrompt } from './codex-startup.mjs';
+import { codexUpdatePrompt, codexWindowsPastes } from './codex-startup.mjs';
 
 // When process `pid` started (ms), from `ps -o etime=` ([[dd-]hh:]mm:ss); null when it cannot be read.
 function startedAt(pid) {
@@ -154,8 +154,14 @@ export class TerminalMailbox {
       // it never guesses that an unacknowledged paste did not happen.
       Object.assign(batch, { phase: 'paste_started', terminal: this.session.id, pid: this.session.rootPid ?? null, pasted_at: Date.now() }); this.save();
       // The terminal host's final newline selects one bracketed paste;
-      // submitMode:none holds the separate Enter until the paste completes.
-      await this.host.sendInput(this.session.id, `${batch.text}\n`, { submitMode: 'none' });
+      // submitMode:none holds the separate Enter until the paste completes. A Windows Codex takes its own pastes:
+      // at most 8000 characters each, non-ASCII as key events (codex-startup.mjs codexWindowsPastes).
+      if (process.platform === 'win32' && batch.kind === 'codex') {
+        for (const paste of codexWindowsPastes(batch.text)) {
+          await this.host.sendInput(this.session.id, paste, { submitMode: 'none' });
+          await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+      } else await this.host.sendInput(this.session.id, `${batch.text}\n`, { submitMode: 'none' });
       batch.phase = 'pasted'; this.save();
     }
     if (batch.phase === 'paste_started') {