@volter/supercode-teams 0.2.158 → 0.2.160

package/bin/workspace.mjs

@@ -680,7 +680,8 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
   }
   if (verb === 'connect') {
     let saved = state.read();
-    const path = realpathSync(resolve(flags.cwd ?? '.'));
+    const path = realpathSync(resolve(flags.cwd ?? flags.root ?? '.'));
+    if (flags.cwd && flags.root && path !== realpathSync(resolve(flags.root))) usage('teams connect: --cwd and --root must name the same folder');
     // A broad root is refused before enrolling anything. The service reruns connect without a terminal, and
     // without --force, for the root accepted here; a broad root enrolled before rules covered subfolders keeps
     // its exact-folder sync there.
@@ -707,7 +708,7 @@ 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)) };
+      const serviceEnv = { ...process.env, SUPERCODE_POPUPS: process.env.SUPERCODE_POPUPS ?? '0', SUPERCODE_TEAMS_ENTRY: fileURLToPath(new URL('./teams.mjs', import.meta.url)) };
       // Refuse source-backed installs before Windows stops the running connector.
       try {
         execFileSync(serviceBin, ['__teams-connector-service', 'validate', contextName, path, context.server_id, context.team_id], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: serviceEnv });
@@ -754,7 +755,7 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     const connector = new TeamsConnector({ server: context.origin, teamId: context.team_id, machineId: saved.machine.id, sourceId: saved.source.id, credential: saved.credential.token, stateDir: state.directory, core, largeCore, slowCore, liveCore, hostKeyId });
     // A connected machine is a person's: each pane it launches opens a window on its screen (SUPERCODE_POPUPS=0: none).
     const machineEvents = new MachineEvents({home:daemonHome,server:context.origin,teamId:context.team_id,credential:saved.credential.token,machineName:saved.machine.name,binary});
-    const machine = new TeamsMachine({ home: daemonHome, supercode: binary, popups: process.env.SUPERCODE_POPUPS !== '0', ...(flags.tmux_socket ? { tmuxSocket: String(flags.tmux_socket) } : {}), link: { server: context.origin, teamId: context.team_id, machineId: saved.machine.id, credential: saved.credential.token, incarnationId: connector.state.incarnation_id, configuration: () => connector.configuration() }, onTurn: (turn) => connector.noteTurn(turn), onTurnWithdrawn: (turn) => connector.withdrawTurn(turn) });
+    const machine = new TeamsMachine({ home: daemonHome, supercode: binary, popups: (process.env.SUPERCODE_POPUPS ?? '0') !== '0', ...(flags.tmux_socket ? { tmuxSocket: String(flags.tmux_socket) } : {}), link: { server: context.origin, teamId: context.team_id, machineId: saved.machine.id, credential: saved.credential.token, incarnationId: connector.state.incarnation_id, configuration: () => connector.configuration() }, onTurn: (turn) => connector.noteTurn(turn), onTurnWithdrawn: (turn) => connector.withdrawTurn(turn) });
     machine.machineEvents = machineEvents;
     machine.on('link', (event) => { if (event.event === 'replaced') process.stderr.write(`supercode teams: ${event.error}. Two connectors were running for this machine; stop one of them (\`supercode teams disconnect\` where it should not run).\n`); });
     // The link's state for the watch after start: down until it is up, down again (since when) when it drops. A

package/codex-startup.mjs

@@ -1,9 +1,58 @@
 // 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';
-import { realpathSync } from 'node:fs';
+import { realpathSync, accessSync, constants, statSync } from 'node:fs';
+import { join, isAbsolute } from 'node:path';
+import { homedir } from 'node:os';
+import { spawnSync } from 'node:child_process';
 const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+export function codexProgram(env = process.env) {
+  const program = env.SUPERCODE_CODEX_BIN?.trim() || join(homedir(), '.local', 'bin', process.platform === 'win32' ? 'codex.cmd' : 'codex');
+  if (!isAbsolute(program)) throw new Error('SUPERCODE_CODEX_BIN must name an absolute executable path');
+  try {
+    accessSync(program, constants.X_OK);
+    if (!statSync(program).isFile()) throw new Error('not a file');
+  } catch {
+    throw new Error(`consolidated Codex executable is unavailable at ${program}; install it there or set SUPERCODE_CODEX_BIN on this machine`);
+  }
+  return program;
+}
+
+export function codexVersion(program, env) {
+  const command = process.platform === 'win32' && /\.cmd$/i.test(program)
+    ? { program: 'powershell.exe', args: ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(`& '${program.replaceAll("'", "''")}' --version`, 'utf16le').toString('base64')] }
+    : { program, args: ['--version'] };
+  const observed = spawnSync(command.program, command.args, { encoding: 'utf8', timeout: 3000, env, maxBuffer: 4096 });
+  if (observed.error || observed.status !== 0 || !/^codex(?:-cli)?\s+\S+/.test(observed.stdout?.trim() ?? '')) throw new Error(`consolidated Codex at ${program} did not report its CLI version`);
+  return observed.stdout.trim();
+}
+
+export function codexStartupArguments(args = []) {
+  const normalized = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === '--') { normalized.push(...args.slice(index)); break; }
+    if (argument === '-c' || argument === '--config') {
+      const value = args[index + 1];
+      if (value?.split('=')[0].trim() === 'check_for_update_on_startup') { index += 1; continue; }
+    } else if (/^(?:--config=|-c=?)/.test(argument)) {
+      const value = argument.replace(/^(?:--config=|-c=?)/, '');
+      if (value.split('=')[0].trim() === 'check_for_update_on_startup') continue;
+    }
+    normalized.push(argument);
+  }
+  return ['-c', 'check_for_update_on_startup=false', ...normalized];
+}
+
+export function codexUpdatePrompt(screen) {
+  const text = String(screen).replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
+  const start = text.toLowerCase().lastIndexOf('update available');
+  if (start < 0) return false;
+  const menu = text.slice(start);
+  return /1\.\s*Update now/i.test(menu) && /2\.\s*Skip/i.test(menu) && !/(?:\? for shortcuts|context left|esc to interrupt)/i.test(menu);
+}
+
 // CLI and portable SDK callers can name a directory through a filesystem alias.
 // Resolve only on the executing machine, before the native seed/server is built.
 export function canonicalCodexFolderTrust(cwd, args = []) {

package/connector/index.mjs

@@ -514,16 +514,36 @@ export class TeamsConnector {
   }
   labelTurns(key,entries,messages){
     const labels={...this.state.turn_labels?.[key]},notes=[...(this.state.turn_notes?.[key]??[])];let found=false;
+    const annotations=source=>Object.fromEntries([['source_via',source.via],['source_principal_id',source.from?.principalId],['source_name',source.from?.name]].filter(([,item])=>typeof item==='string'&&item));
+    const identities=messages.map(message=>{
+      if(message.value?.role!=='user')return null;
+      const stamp=message.value.metadata?.timestamp,native=typeof stamp==='string'?Date.parse(stamp):NaN;
+      const at=Number.isFinite(native)?native:message.recorded_at;
+      if(!Number.isFinite(at))return null;
+      return {at,key:`turn:${hash(canonicalJson([Number.isFinite(native)?stamp:at,messageText(message.value)]))}`};
+    });
+    // Positional native keys can be reused after compaction. Upgrade a legacy
+    // label only when its dated, fully annotated row matches the prior capture.
+    const legacy=new Set(Object.keys(labels).filter(id=>!id.startsWith('turn:'))),prior=new Map();
+    const origin=this.state.origins[key];
+    if(legacy.size)for(const [index,id]of(origin?.observed_keys??[]).entries())if(legacy.has(id))prior.set(id,origin.observed_digests?.[index]);
+    messages.forEach((message,index)=>{
+      const identity=identities[index],source=labels[message.native_key];
+      if(!identity||labels[identity.key]||!source||!Number.isFinite(Date.parse(message.value.metadata?.timestamp??'')))return;
+      const value={...message.value,metadata:{...message.value.metadata,...annotations(source)}};
+      if(prior.get(message.native_key)!==hash(canonicalJson(value)))return;
+      labels[identity.key]=source;delete labels[message.native_key];found=true;
+    });
     for(const note of [...notes]){
-      const match=messages.find(message=>!labels[message.native_key]&&message.value?.role==='user'&&(message.recorded_at==null||message.recorded_at>=note.at-60000)&&messageText(message.value)===note.text);
-      if(match){labels[match.native_key]=note.source;notes.splice(notes.indexOf(note),1);found=true;}
+      const index=messages.findIndex((message,index)=>identities[index]&&!labels[identities[index].key]&&identities[index].at>=note.at-60000&&messageText(message.value)===note.text);
+      if(index>=0){labels[identities[index].key]=note.source;notes.splice(notes.indexOf(note),1);found=true;}
     }
     if(found){(this.state.turn_labels??={})[key]=labels;if(notes.length)this.state.turn_notes[key]=notes;else delete this.state.turn_notes[key];this.save();}
     messages.forEach((message,index)=>{
-      const source=labels[message.native_key];if(!source)return;
-      const annotations=Object.fromEntries([['source_via',source.via],['source_principal_id',source.from?.principalId],['source_name',source.from?.name]].filter(([,item])=>typeof item==='string'&&item));
-      message.value={...message.value,metadata:{...message.value.metadata,...annotations}};
-      const entry=entries[index];if(entry.value)entry.value={...entry.value,metadata:{...entry.value.metadata,...annotations}};else entry.metadata={...entry.metadata,...annotations};
+      const identity=identities[index],source=identity&&labels[identity.key];if(!source)return;
+      const value=annotations(source);
+      message.value={...message.value,metadata:{...message.value.metadata,...value}};
+      const entry=entries[index];if(entry.value)entry.value={...entry.value,metadata:{...entry.value.metadata,...value}};else entry.metadata={...entry.metadata,...value};
     });
   }
   /**

package/machine.mjs

@@ -52,7 +52,7 @@ import { popupTerminal, openPopup } from './popup-terminals.mjs';
 import { JobOwner, executionCapabilities, streamProgram, serveWorkspace } from './execution.mjs';
 import { TerminalMailbox, retainedTerminalMail } from './terminal-mail.mjs';
 import { confirmNativeInitialInput } from './native-initial-input.mjs';
-import { canonicalCodexFolderTrust, settleCodexHookReview } from './codex-startup.mjs';
+import { canonicalCodexFolderTrust, codexProgram, codexStartupArguments, codexUpdatePrompt, codexVersion, 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));
@@ -869,13 +869,13 @@ 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, nativeInput }) {
+  #deliverInitialInput({ key, contextKey, session, kind, by, input, act, nativeInput, executable = {} }) {
     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,
+        this.launches.record({ key, pane: contextKey, kind, by, ...executable, 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}`);
@@ -884,19 +884,19 @@ export class TeamsMachine extends MachineCore {
       const readyBy = await this.#awaitInputReady(session, contextKey, kind, abort.signal);
       if (readyBy === 'aborted') return;
       if (readyBy === 'pane-gone' || readyBy === 'deadline') {
-        this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: false, inputReadyBy: readyBy });
+        this.launches.record({ key, pane: contextKey, kind, by, ...executable, status: 'ready', inputDelivered: false, inputReadyBy: readyBy });
         act('launch', `pane:${contextKey}`, 'failed', `first input undelivered: ${readyBy}`);
         return;
       }
       const result = await this.#deliverPaneText(session, contextKey, input, { signal: abort.signal });
-      this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: result.delivered,
+      this.launches.record({ key, pane: contextKey, kind, by, ...executable, status: 'ready', inputDelivered: result.delivered,
         inputReadyBy: readyBy, ...(!result.delivered ? { inputError: result.reason } : {}) });
       act('launch', `pane:${contextKey}`, result.delivered ? 'ok' : 'failed',
         result.delivered ? `first input delivered (${readyBy})` : `first input unconfirmed: ${result.reason}`);
     })().catch((error) => {
       // Nothing above is expected to throw; if something does, the launch record
       // is where it is answerable, not a crashed daemon.
-      this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: false, inputError: error?.message ?? String(error) });
+      this.launches.record({ key, pane: contextKey, kind, by, ...executable, status: 'ready', inputDelivered: false, inputError: error?.message ?? String(error) });
     }).finally(() => {
       if (this.pendingInitialInputs.get(key)?.task === task) this.pendingInitialInputs.delete(key);
     });
@@ -937,6 +937,7 @@ export class TeamsMachine extends MachineCore {
 
   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' };
     if (['codex', 'grok', 'gemini', 'goose', 'opencode', 'pi', 'hermes', 'openclaw'].includes(kind)) return this.#terminalMail(session, contextKey, kind, submission(text, false), options);
     if(this.inputRepairs[contextKey])return {delivered:false,reason:'input-cleanup-pending',cleanup_required:true};
     if (this.inputInFlight.has(session.id)) return { delivered: false, reason: 'input-in-flight' };
@@ -1435,6 +1436,8 @@ export class TeamsMachine extends MachineCore {
       case 'launch': {
         // A pane launch. Operators only; the body may carry secrets and is never logged.
         if (!operator) throw Object.assign(new Error('launch is for operators'), { code: 403 });
+        const programName = String(params.program).split(/[\\/]/).pop().replace(/\.(?:exe|cmd)$/i, '');
+        if (programName === 'codex') params = { ...params, kind: 'codex' };
         const key = params.key ?? `lk_${randomBytes(9).toString('base64url')}`;
         const existing = this.launches.find(key);
         // A key whose launch is in flight, or whose pane still lives, is reused; a failed
@@ -1453,7 +1456,12 @@ export class TeamsMachine extends MachineCore {
         if (params.kind === 'claude-code' && params.cwd && (params.arguments ?? []).includes('--dangerously-skip-permissions')) trustClaudeFolder(params.cwd);
         let session;
         let nativeInput;
+        let executable = {};
         try {
+          if (params.kind === 'codex') {
+            params = { ...params, program: codexProgram(this.env), arguments: codexStartupArguments(params.arguments) };
+            executable = { program: params.program, cliVersion: codexVersion(params.program, this.env) };
+          }
           if (process.platform !== 'win32' && !String(params.program).includes('/')) {
             const search = params.env?.PATH ?? this.env.PATH ?? '';
             const program = search.split(':').map(dir => resolve(dir || params.cwd || process.cwd(), params.program)).find(path => {
@@ -1474,11 +1482,11 @@ export class TeamsMachine extends MachineCore {
             name: contextKey,
           });
         } catch (error) {
-          this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, status: 'failed', error: error.message });
+          this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, ...executable, status: 'failed', error: error.message });
           act('launch', `pane:${contextKey}`, 'failed', error.code ?? error.message);
           throw error;
         }
-        this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, status: 'ready' });
+        this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, ...executable, 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()) {
@@ -1495,7 +1503,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, nativeInput });
+        if (params.initialInput) this.#deliverInitialInput({ key, contextKey, session, kind: params.kind ?? null, by, input: params.initialInput, act, nativeInput, executable });
         // 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));
@@ -1504,7 +1512,7 @@ export class TeamsMachine extends MachineCore {
           // Finished (it ran to a clean end) is an answer; exited (it failed at once) is the caller's error.
           const exit = settled?.dead ? deadPaneExit(settled) : paneExit(contextKey);
           const status = exit && !exit.failed ? 'finished' : 'exited';
-          this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, status, error: exit?.failed ? exit.how : undefined });
+          this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, ...executable, status, error: exit?.failed ? exit.how : undefined });
           return { key, pane: contextKey, reused: false, status, exit: exit?.how ?? null };
         }
         if (this.popups && params.popup !== false) this.#popupWindow(contextKey, session);
@@ -1585,6 +1593,7 @@ export class TeamsMachine extends MachineCore {
         if (this.inputInFlight.has(session.id)) return { delivered: false, reason: 'input-in-flight' };
         let result;
         if (params.keys || params.submit === false) {
+          if (!params.keys && this.#paneKind(params.pane, session) === 'codex' && codexUpdatePrompt(await this.host.capture(session.id, { lines: 120 }))) return { delivered: false, reason: 'codex-update-prompt: delivery paste refused' };
           if (!params.keys && [...this.terminalMailboxes.values()].some(queue => queue.session?.id === session.id && (queue.state.active || queue.state.pending.length))) return { delivered: false, reason: 'terminal mailbox has an unconfirmed paste' };
           this.inputInFlight.add(session.id);
           try {

package/package.json

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

@@ -4,6 +4,7 @@ import { mkdirSync, readFileSync, writeFileSync, renameSync, appendFileSync, sta
 import { join } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { StringDecoder } from 'node:string_decoder';
+import { codexUpdatePrompt } from './codex-startup.mjs';
 
 const hash = value => createHash('sha256').update(value).digest('hex');
 const textOf = content => typeof content === 'string' ? content : Array.isArray(content) && content.every(p => ['text', 'input_text'].includes(p.type)) ? content.map(p => p.text).join('') : null;
@@ -116,6 +117,10 @@ export class TerminalMailbox {
       this.state.receipts.push(receipt);
       this.state.active = null; this.save(); this.log(receipt); return;
     }
+    if (batch.kind === 'codex' && codexUpdatePrompt(await this.host.capture(this.session.id, { lines: 120 }))) {
+      batch.error = 'codex-update-prompt: delivery retained; restart Codex with check_for_update_on_startup=false';
+      this.save(); this.log({ delivered: false, queued: true, reason: batch.error, message_ids: batch.message_ids }); return;
+    }
     if (batch.phase === 'prepared') {
       // Persist uncertainty before I/O. A daemon restart checks the transcript;
       // it never guesses that an unacknowledged paste did not happen.
@@ -129,6 +134,9 @@ export class TerminalMailbox {
       batch.error = 'paste outcome uncertain; native transcript confirmation pending'; this.save(); return;
     }
     if (batch.enters < 3 && Date.now() - batch.last_enter >= 5000) {
+      if (batch.kind === 'codex' && codexUpdatePrompt(await this.host.capture(this.session.id, { lines: 120 }))) {
+        batch.error = 'codex-update-prompt: Enter refused'; this.save(); return;
+      }
       batch.enters += 1; batch.last_enter = Date.now(); this.save();
       await this.host.sendInput(this.session.id, '\r', { submitMode: 'single' });
       const attempt = { delivered: false, queued: true, batch: batch.id, message_ids: batch.message_ids, attempt: batch.enters, at: Date.now() };