@volter/supercode-teams 0.2.113 → 0.2.115

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/connector/index.mjs

@@ -92,6 +92,11 @@ const fileStamp=stat=>`${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
 const recordedAt=entry=>{if(Number.isSafeInteger(entry.recorded_at))return entry.recorded_at;if(Number.isSafeInteger(entry.timestamp))return entry.timestamp;const value=entry.metadata?.timestamp??entry.value?.metadata?.timestamp??entry.timestamp;if(typeof value!=='string')return null;const parsed=Date.parse(value);return Number.isSafeInteger(parsed)?parsed:null;};
 const serverOrigin=value=>{const url=new URL(value),loopback=url.hostname==='localhost'||url.hostname==='::1'||url.hostname==='[::1]'||/^127(?:\.\d{1,3}){3}$/.test(url.hostname);if(!['http:','https:'].includes(url.protocol)||url.username||url.password||url.search||url.hash||(url.pathname!==''&&url.pathname!=='/')||(url.protocol==='http:'&&!loopback))throw new TypeError('server must be an HTTPS origin (HTTP is loopback-only)');return url.origin;};
 const SAVE_COALESCE_MS = 2000;
+// The catalog is conversation history, not a model's compacted continuation
+// context. Keep the native artifact separately for continuation/export.
+const captureRead = (harness, options = {}) => harness === 'codex'
+  ? { ...options, view: { displayHistory: true, tailMessages: 5000, includeSubagents: false } } : options;
+
 
 function atomic(path, value) {
   const temporary = `${path}.${process.pid}.${randomBytes(12).toString('hex')}.tmp`;
@@ -460,7 +465,7 @@ export class TeamsConnector {
       this.lastCaptures.set(key,now);
       const {locator}=options,path=locator?.storage?.kind==='file'&&existsSync(locator.storage.path)?realpathSync(locator.storage.path):null;
       const artifactBefore=path?statSync(path):null;
-      options={...options,preloaded:{loaded:await (options.live?this.liveCore:this.core).session(locator).load(),artifactBefore}};
+      options={...options,preloaded:{loaded:await (options.live?this.liveCore:this.core).session(locator).load(captureRead(options.harness)),artifactBefore}};
     }
     // A capture the server refused and the outbox dropped stays that session's problem; any other capture clears it.
     const work=this.work.then(()=>this.captureSerial(options)).then(receipt=>{if(!this.droppedCaptures?.delete(`${options.harness}:${options.nativeSessionId}`))this.clearSessionProblem(options.harness,options.nativeSessionId);return receipt;});
@@ -540,7 +545,7 @@ export class TeamsConnector {
         this.largeCaptures??=new Map();const last=this.largeCaptures.get(key),wait=last&&!this.watched?.has(key)?Math.min(LARGE_CAPTURE_EVERY_MS,Math.max(LARGE_CAPTURE_FLOOR_MS,last.ms*10))-(this.clock.nowMs()-last.at):0;
         if(wait>0){this.largeRetry??=new Map();if(!this.largeRetry.has(key))this.largeRetry.set(key,setTimeout(()=>{this.largeRetry.delete(key);this.captureLarge(options);},wait).unref?.());continue;}
         started=this.clock.nowMs();
-        const loaded=await lane.core.session(options.locator).load({timeoutMs:Math.max(30000,Math.ceil(artifactBefore.size/(1024*1024))*1000)});
+        const loaded=await lane.core.session(options.locator).load(captureRead(options.harness,{timeoutMs:Math.max(30000,Math.ceil(artifactBefore.size/(1024*1024))*1000)}));
         this.largeCaptures.set(key,{at:started,ms:this.clock.nowMs()-started});
         await this.capture({...options,preloaded:{loaded,artifactBefore}});
       }catch(error){
@@ -560,10 +565,11 @@ export class TeamsConnector {
     const artifactSource=locator?.storage?.kind==='file'&&existsSync(locator.storage.path)?realpathSync(locator.storage.path):null;
     const artifactBefore=preloaded?preloaded.artifactBefore:artifactSource?statSync(artifactSource):null;
     const large=(artifactBefore?.size??0)>=LARGE_CAPTURE_BYTES;
-    const loaded=preloaded?preloaded.loaded:await this.core.session(locator).load(large?{timeoutMs:Math.max(30000,Math.ceil(artifactBefore.size/(1024*1024))*1000)}:undefined),configuredBackfill=rule.backfill??backfill??'all',backfillPolicy=typeof configuredBackfill==='string'?{mode:configuredBackfill,since:null}:configuredBackfill;
+    const loaded=preloaded?preloaded.loaded:await this.core.session(locator).load(captureRead(harness,large?{timeoutMs:Math.max(30000,Math.ceil(artifactBefore.size/(1024*1024))*1000)}:{})),configuredBackfill=rule.backfill??backfill??'all',backfillPolicy=typeof configuredBackfill==='string'?{mode:configuredBackfill,since:null}:configuredBackfill;
     const key=`${harness}:${nativeSessionId}`,previous=this.state.origins[key]??null;
     let messages=(loaded.messages??loaded.turns??[]).map((entry,index)=>{const value=entry.value??Object.fromEntries(Object.entries(entry).filter(([key])=>!['id','native_key','recorded_at','timestamp'].includes(key)));return{native_key:entry.id??entry.native_key??String(index),recorded_at:recordedAt(entry),value};});
     this.labelTurns(key,loaded.messages??loaded.turns??[],messages);
+    if (harness === 'codex' && loaded.total_message_count > messages.length) coverage = { ...coverage, completeness: 'partial', reasons: [...new Set([...coverage.reasons, 'prefix_not_captured'])] };
     // A session published without its native bundle is captured again, with the same messages, once the bundle can be built.
     const nativeWanted=backfillPolicy.mode==='all'&&typeof this.core.translateSession==='function'&&!((artifactBefore?.size??0)>NATIVE_MAX_BYTES);
     const retryNative=Boolean(previous?.native_deferred&&nativeWanted&&artifactBefore?.isFile()&&!previous?.baseline&&this.nativeReady(key,artifactBefore));

package/machine.mjs

@@ -30,6 +30,7 @@ import { appendFileSync, readFileSync, writeFileSync, writeSync, statSync, readd
 import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir, hostname } from 'node:os';
+import { readMailHistory } from './mail-history.mjs';
 import { randomBytes, createHash } from 'node:crypto';
 import { WebSocket } from 'ws';
 import { TmuxTerminalHost, classifyAttentionSignal, composerHoldsDraft, composerReadyForInput } from '@volter/supercode-terminal';
@@ -49,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));
@@ -187,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); });
@@ -215,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();
   }
@@ -451,6 +457,7 @@ export class TeamsMachine extends MachineCore {
     const { admitted, principal } = entry;
     const request = stream.params?.request;
     if (request?.op === 'turn') return this.#serveTurn(entry, request, stream, accept, refuse);
+    if (request?.op === 'history') return this.#serveMailHistory(entry, request, stream, accept, refuse);
     const to = typeof request?.to === 'string' ? request.to : '*';
     const target = to.startsWith('sc:') ? `mail:${to}` : 'mail:*';
     if (!request || !['send', 'file', 'list'].includes(request.op)) return refuse('mail needs a send, file, list or turn request');
@@ -475,6 +482,24 @@ export class TeamsMachine extends MachineCore {
     child.stdin.end(JSON.stringify({ ...request, via_principal: principal ?? null }));
   }
 
+  #serveMailHistory(entry, request, stream, accept, refuse) {
+    const { admitted, principal } = entry;
+    const granted = (admitted?.grants ?? []).filter(grant => grant.caps.includes('observe')).flatMap(grant => grant.targets).filter(target => target.startsWith('session:') && target !== 'session:*');
+    const named = typeof request.harness === 'string' && typeof request.session === 'string' ? `${request.harness}/${request.session}` : granted.length === 1 ? granted[0].slice(8) : '';
+    const [harness, session, extra] = named.split('/');
+    const target = `session:${named}`;
+    if (!harness || !session || extra || !holds(admitted, 'observe', target)) return refuse('no observe grant for this session');
+    accept();
+    const controller = new AbortController();
+    stream.on('close', () => controller.abort());
+    void readMailHistory({ binary: this.supercodeBin, env: this.env, harness, session, signal: controller.signal }).then(rows => {
+      if (!stream.closed) stream.write(JSON.stringify({ code: 0, rows }));
+      this.log.append({ principal, cap: 'observe', target, outcome: 'mail-history' });
+    }, error => {
+      if (!stream.closed) stream.write(JSON.stringify({ code: 1, text: error.message }));
+    }).finally(() => { if (!stream.closed) stream.close('complete'); });
+  }
+
   #serveTurn(entry, request, stream, accept, refuse) {
     // A person's line typed into one session here as that session's own user turn (a Room member in a Conversation
     // bound to the session): `interact` on `session:<harness>/<id>`. Who typed it comes from the caller's claim
@@ -783,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 ------------------------------------------
 
   /**
@@ -1303,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: {} });
@@ -1357,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

@@ -0,0 +1,51 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { hostname } from 'node:os';
+import { spawn } from 'node:child_process';
+import { teamsHome } from '@volter/teams/home';
+
+// 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) {
+  let name = hostname();
+  try {
+    const root = join(teamsHome(env), 'workspaces');
+    const contexts = JSON.parse(readFileSync(join(root, 'contexts.json'), 'utf8'));
+    const context = contexts.contexts[contexts.current];
+    name = JSON.parse(readFileSync(join(root, 'connectors', context.server_id, context.team_id, 'enrollment.json'), 'utf8')).machine.name || name;
+  } catch { /* An unenrolled machine's mail uses its hostname. */ }
+  return name.split('.')[0].toLowerCase().replace(/[^a-z0-9_-]/g, '-') || 'localhost';
+}
+
+/** Read actual inbound/outbound envelopes. --session is deliberately read-only;
+ * sessions.inbox acknowledges mail and must never be used by a viewer. */
+export function readMailHistory({ binary, env, harness, session, signal }) {
+  if (!/^[a-z0-9-]+$/.test(harness) || !/^[a-zA-Z0-9_-]+$/.test(session)) throw new Error('invalid session address');
+  // A local Teams preview may keep its enrollment separate from the native
+  // sessions it displays. This explicitly selects their read-only mail store.
+  if (env.SUPERCODE_SESSION_MAIL_HOME) {
+    env = { ...env, SUPERCODE_HOME: env.SUPERCODE_SESSION_MAIL_HOME };
+    delete env.SUPERCODE_TEAMS_HOME;
+  }
+  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)]),
+    });
+    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 => {
+      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',
+        })));
+      } catch (error) { reject(error); }
+    });
+  });
+}

package/package.json

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