@volter/supercode-teams 0.2.114 → 0.2.116

package/bin/workspace.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { hostname } from 'node:os';
+import { fileURLToPath } from 'node:url';
 import { existsSync, readFileSync, realpathSync, rmSync } from 'node:fs';
 import { basename, join, resolve } from 'node:path';
 import { execFileSync, spawn } from 'node:child_process';
@@ -698,10 +699,13 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     if (flags.install || (!flags.foreground && process.stdin.isTTY && process.stdout.isTTY)) {
       const serviceBin = process.env.SUPERCODE_BIN;
       if (!serviceBin) unsupported('--install requires invocation through the native supercode CLI');
+      const serviceEnv = { ...process.env, SUPERCODE_TEAMS_ENTRY: fileURLToPath(new URL('./teams.mjs', import.meta.url)) };
+      // Refuse source-backed installs before Windows stops the running connector.
+      execFileSync(serviceBin, ['__teams-connector-service', 'validate', contextName, path, context.server_id, context.team_id], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: serviceEnv });
       // Ending a Windows task ends only the console host it started, never the connector under it, so the task
       // would refuse its new run while the old connector went on: the running one is asked to stop first.
       if (process.platform === 'win32') await stopRunningConnector(saved);
-      try { service = JSON.parse(execFileSync(serviceBin, ['__teams-connector-service', 'install', contextName, path, context.server_id, context.team_id], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })); }
+      try { service = JSON.parse(execFileSync(serviceBin, ['__teams-connector-service', 'install', contextName, path, context.server_id, context.team_id], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: serviceEnv })); }
       catch (error) {
         // A platform with no service manager still connects: here, for as long as this terminal runs it. Anything else is an error.
         if (flags.install || !/no service manager/.test(String(error.stderr ?? error.message))) { core.close(); throw error; }
@@ -768,7 +772,7 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
       watchCodeChange([process.env.SUPERCODE_BIN, new URL('../package.json', import.meta.url), shim], (changed) => {
         process.stderr.write(`supercode teams: ${changed} changed under this connector (an upgrade); moving to the new code\n`);
         const cli = process.platform === 'win32' ? 'supercode' : process.env.SUPERCODE_BIN;
-        spawn(cli, ['teams', 'connect', '--install', '--context', contextName, '--cwd', path], { shell: process.platform === 'win32', detached: true, stdio: 'ignore', windowsHide: true }).unref();
+        spawn(cli, ['teams', 'connect', '--install', '--context', contextName, '--cwd', path], { env: { ...process.env, SUPERCODE_TEAMS_ENTRY: fileURLToPath(new URL('./teams.mjs', import.meta.url)) }, shell: process.platform === 'win32', detached: true, stdio: 'ignore', windowsHide: true }).unref();
         // An explicit exit: the command's own return would end the process with 0, which systemd's on-failure policy
         // does not restart.
         if (process.platform !== 'win32') setTimeout(async () => { await stopConnector?.(); process.exit(75); }, 60_000);

package/codex-startup.mjs

@@ -0,0 +1,56 @@
+// Codex can still show hook review on resume despite its invocation trust flag.
+// Act only on this exact startup menu, and never submit without reading selection.
+import { composerText } from '@volter/supercode-terminal';
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function hookReview(screen) {
+  const lines = String(screen).split('\n').map((line) => line.trim()).filter(Boolean);
+  const start = lines.lastIndexOf('Hooks need review');
+  if (start < 0) return null;
+  const menu = lines.slice(start);
+  if (menu.length !== 7 || !/^\d+ hooks? (?:is|are) new or changed\.$/.test(menu[1]) ||
+      menu[2] !== 'Hooks can run outside the sandbox after you trust them.' ||
+      !/^(?:enter confirm · esc skip|Press enter to confirm or esc to go back)$/.test(menu[6])) return null;
+  const labels = ['1. Review hooks', '2. Trust all and continue', "3. Continue without trusting (hooks won't run)"];
+  let selected = null;
+  for (let i = 0; i < labels.length; i += 1) {
+    if (menu[i + 3] === `› ${labels[i]}`) {
+      if (selected !== null) return null;
+      selected = i + 1;
+    } else if (menu[i + 3] !== labels[i]) return null;
+  }
+  return selected === null ? null : { selected, identity: menu.slice(0, 3).join('\n') };
+}
+
+export async function settleCodexHookReview(host, sessionId, { signal, deadlineMs, live, claim, release } = {}) {
+  const expired = () => signal.aborted || Date.now() >= deadlineMs;
+  const read = () => host.capture(sessionId, { lines: 120 });
+  let readySince = null;
+  while (!expired()) {
+    if (!await live()) return 'pane-gone';
+    const screen = await read();
+    const menu = hookReview(screen);
+    if (menu) {
+      if (!claim()) return 'input-in-flight';
+      try {
+        // A fresh capture protects against a person moving or closing the menu.
+        let current = hookReview(await read());
+        if (!current || current.identity !== menu.identity || expired()) return 'changed';
+        if (current.selected !== 2) {
+          await host.sendInput(sessionId, current.selected === 1 ? '\x1b[B' : '\x1b[A', { submitMode: 'none', deadlineMs });
+          await pause(100);
+          current = hookReview(await read());
+        }
+        if (!current || current.identity !== menu.identity || current.selected !== 2 || !await live() || expired()) return 'changed';
+        await host.sendInput(sessionId, '\r', { submitMode: 'single', deadlineMs });
+        // Exactly one Enter. Delivery is still established by the native receipt.
+        return 'trust-selected';
+      } finally { release(); }
+    }
+    const composer = composerText('codex', screen);
+    readySince = composer !== null ? (readySince ?? Date.now()) : null;
+    if (readySince !== null && Date.now() - readySince >= 1000) return 'composer';
+    await pause(150);
+  }
+  return signal.aborted ? 'aborted' : 'deadline';
+}

package/machine.mjs

@@ -50,6 +50,7 @@ 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';
+import { settleCodexHookReview } from './codex-startup.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));
@@ -188,6 +189,7 @@ export class TeamsMachine extends MachineCore {
     this.voiceProcesses = new Map(); // session address -> optional voice pack child
     this.inputInFlight = new Set(); // one input transaction per pane
     this.pendingInitialInputs = new Map(); // launch key → { abort, task }
+    this.pendingStartups = new Map();
     this.registerDoor('harness', (entry, stream, accept, refuse, index) => this.#serveHarness(index, entry, stream, accept, refuse));
     this.registerDoor('terminal', (entry, stream, accept, refuse) => this.#attachTerminal(entry, stream, accept, refuse));
     this.registerDoor('node', (entry, stream, accept) => { accept(); return this.#serveNodeRpc(entry, stream); });
@@ -216,7 +218,10 @@ export class TeamsMachine extends MachineCore {
     // this daemon is going away, and shoving a message at a half-booted TUI on the
     // way out is the very failure the wait exists to prevent. The launch record
     // already says the input was never delivered.
+    for (const { abort } of this.pendingStartups.values()) abort.abort();
     for (const { abort } of this.pendingInitialInputs.values()) abort.abort();
+    await Promise.allSettled([...this.pendingStartups.values()].map(({ task }) => task));
+    this.pendingStartups.clear();
     await Promise.allSettled([...this.pendingInitialInputs.values()].map(({ task }) => task));
     this.pendingInitialInputs.clear();
   }
@@ -803,6 +808,20 @@ export class TeamsMachine extends MachineCore {
     }
   }
 
+  #settleCodexStartup(key, pane, session, act) {
+    for (const pending of this.pendingStartups.values()) if (pending.pane === pane) pending.abort.abort();
+    const abort = new AbortController();
+    const task = settleCodexHookReview(this.host, session.id, {
+      signal: abort.signal, deadlineMs: Date.now() + INITIAL_INPUT_READY_DEADLINE_MS,
+      live: async () => (await this.#paneByContext(pane))?.id === session.id,
+      claim: () => { if (this.inputInFlight.has(session.id)) return false; this.inputInFlight.add(session.id); return true; },
+      release: () => this.inputInFlight.delete(session.id),
+    }).then((result) => { if (result === 'trust-selected') act('launch', `pane:${pane}`, 'ok', 'Codex startup hook review: trust selected and confirmed once'); })
+      .catch((error) => act('launch', `pane:${pane}`, 'failed', `Codex startup review: ${error.message}`))
+      .finally(() => { if (this.pendingStartups.get(key)?.task === task) this.pendingStartups.delete(key); });
+    this.pendingStartups.set(key, { pane, abort, task });
+  }
+
   // ---- launch: the first input ------------------------------------------
 
   /**
@@ -1323,6 +1342,7 @@ export class TeamsMachine extends MachineCore {
           throw error;
         }
         this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, status: 'ready' });
+        if (params.kind === 'codex' && (params.arguments ?? []).includes('--dangerously-bypass-hook-trust')) this.#settleCodexStartup(key, contextKey, session, act);
         act('launch', `pane:${contextKey}`, 'ok', params.kind ?? params.program);
         if (typeof params.name === 'string' && params.name.trim()) {
           const titles = readJson(this.p.titles, { v: 1, titles: {} });
@@ -1377,6 +1397,7 @@ export class TeamsMachine extends MachineCore {
       }
       case 'panes.close': {
         need('control', `pane:${params.pane}`);
+        for (const pending of this.pendingStartups.values()) if (pending.pane === params.pane) pending.abort.abort();
         const session = await this.#paneByContext(params.pane);
         if (!session) throw new Error(`no pane with context ${params.pane}`);
         await this.host.closeSession(session.id);

package/mail-history.mjs

@@ -4,6 +4,47 @@ import { hostname } from 'node:os';
 import { spawn } from 'node:child_process';
 import { teamsHome } from '@volter/teams/home';
 
+const directories = new Map();
+function sessionDirectory(binary, env, signal) {
+  const key = `${binary}:${teamsHome(env)}`;
+  const cached = directories.get(key);
+  if (cached && cached.until > Date.now()) return cached.value;
+  const value = new Promise((resolve, reject) => {
+    const child = spawn(binary, ['message', 'list', '--json'], { env, signal: AbortSignal.any([...(signal ? [signal] : []), AbortSignal.timeout(15_000)]), stdio: ['ignore', 'pipe', 'ignore'] });
+    let out = '';
+    child.stdout.on('data', chunk => { out += chunk; if (out.length > 4_000_000) child.kill(); });
+    child.on('error', reject);
+    child.on('close', code => { try { if (code !== 0) throw new Error('Session directory unavailable'); resolve(JSON.parse(out)); } catch (error) { reject(error); } });
+  }).catch(() => []);
+  directories.set(key, { until: Date.now() + 60_000, value });
+  return value;
+}
+
+/** Resolve from supercode's existing session directory and explicit voice
+ * backing, never by interpreting an operator mailbox's generated name. */
+function mailActors(rows, sessions, self) {
+  const directory = new Map(sessions.map(session => [session.address, session]));
+  const voices = new Map(rows.filter(row => row.envelope.voice_for).map(row => [row.envelope.from, row.envelope.voice_for]));
+  const names = new Map(rows.map(row => [row.envelope.from, row.envelope.from_name]));
+  const actor = (address) => {
+    const backing = voices.get(address) || address;
+    const native = /^sc:([^:]+):([^:]+):(.+)$/.exec(backing);
+    const session = directory.get(backing);
+    const kind = native && !['operator', 'board', 'pane'].includes(native[2]) ? 'agent' : 'automation';
+    let name = session?.name || names.get(backing) || (native?.[2] === 'board' ? 'Board' : kind === 'agent' ? native[2] : 'Automation');
+    if (native && name.endsWith(`@${native[1]}`)) name = name.slice(0, -native[1].length - 1);
+    // An unnamed session gets its harness label, not its address as a name.
+    if (/^(?:codex|claude-code|claude|gemini|pi|goose|grok|opencode)-[0-9a-f]{8,}$/i.test(name)) name = native[2] === 'codex' ? 'Codex' : native[2];
+    return { id: backing, name, kind, self: backing === self, ...(native ? { session: { machine: native[1], harness: native[2], id: native[3] } } : {}), ...(voices.has(address) ? { via: 'voice' } : {}) };
+  };
+  return rows.map(({ envelope, session: to, direction, delivery }) => ({
+    id: envelope.id, from: envelope.from, fromName: envelope.from_name, to,
+    fromActor: actor(envelope.from), toActor: actor(to),
+    text: envelope.body, at: envelope.created_at_ms, direction,
+    inReplyTo: envelope.in_reply_to ?? null, delivery: delivery?.state ?? 'unknown',
+  }));
+}
+
 // Match the CLI's local_machine_name: the native mailbox belongs to its
 // enrolled context, which can differ from a viewer connector's --home.
 function machineName(env) {
@@ -30,21 +71,17 @@ export function readMailHistory({ binary, env, harness, session, signal }) {
   const address = `sc:${machineName(env)}:${harness}:${session}`;
   return new Promise((resolve, reject) => {
     const child = spawn(binary, ['message', 'inbox', '--session', address, '--json', '--recent', '100'], {
-      env, stdio: ['ignore', 'pipe', 'pipe'], signal: AbortSignal.any([signal, AbortSignal.timeout(20_000)]),
+      env, stdio: ['ignore', 'pipe', 'pipe'], signal: AbortSignal.any([...(signal ? [signal] : []), AbortSignal.timeout(20_000)]),
     });
     let out = '', error = '';
     child.stdout.on('data', chunk => { out += chunk; if (out.length > 8_000_000) child.kill(); });
     child.stderr.on('data', chunk => { error = (error + chunk).slice(-1000); });
     child.on('error', reject);
-    child.on('close', code => {
+    child.on('close', async code => {
       if (code !== 0) return reject(new Error(error || 'Mailbox could not be read'));
       try {
         const rows = JSON.parse(out).filter(row => ['peer', 'channel'].includes(row.envelope?.kind));
-        resolve(rows.map(({ envelope, session: to, direction, delivery }) => ({
-          id: envelope.id, from: envelope.from, fromName: envelope.from_name, to,
-          text: envelope.body, at: envelope.created_at_ms, direction,
-          inReplyTo: envelope.in_reply_to ?? null, delivery: delivery?.state ?? 'unknown',
-        })));
+        resolve(mailActors(rows, await sessionDirectory(binary, env, signal), address));
       } catch (error) { reject(error); }
     });
   });

package/package.json

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