@volter/supercode-teams 0.3.127 → 0.3.129

package/live-sessions.mjs

@@ -147,7 +147,7 @@ export class LiveSessions extends EventEmitter {
     // session is live while its process is; the daemon pane it runs in, when it does, from the panes the records read
     this.grokHome = env.GROK_HOME || join(homedir(), '.grok');
     this.grok = new Map(); // session id → { pid, ppid, cwd, openedAt, pane }
-    this.grokPaneRoots = [];
+    this.paneRoots = [];
     this.projectHooks = new Map(); // directory → whether its .codex/hooks.json carries the hook
     this.userHook = false;
     this.watchers = [];
@@ -468,15 +468,23 @@ export class LiveSessions extends EventEmitter {
 
   /** The daemon pane a Grok session runs in: the pane whose process it is, or whose process started it. */
   #grokPane(entry) {
-    entry.pane = this.grokPaneRoots.find((root) => root.pid === entry.pid || (entry.ppid != null && root.pid === entry.ppid))?.pane ?? null;
+    entry.pane = this.paneRoots.find((root) => root.pid === entry.pid || (entry.ppid != null && root.pid === entry.ppid))?.pane ?? null;
   }
 
-  /** The daemon's live panes and their root processes (`[{ pane, pid }]`), as the records read them: Grok's panes. */
-  grokPanes(roots) {
-    this.grokPaneRoots = (roots ?? []).filter((root) => root?.pane && Number.isInteger(root.pid));
-    const before = JSON.stringify([...this.grok].map(([id, entry]) => [id, entry.pane]));
+  /** The daemon pane a Claude session runs in: the tmux pane its registry names, else the pane whose process it is.
+   *  Claude names its pane only from tmux's environment, so on Windows (no tmux) only the pane's process says it. */
+  #claudePane(entry) {
+    return entry.tmux ?? this.paneRoots.find((root) => root.pid === entry.pid)?.pane ?? null;
+  }
+
+  /** The daemon's live panes and their root processes (`[{ pane, pid }]`), as the records read them: the panes of the
+   *  sessions whose own records name none (Grok's; Claude's on Windows). */
+  panes(roots) {
+    const placed = () => JSON.stringify([...[...this.grok].map(([id, entry]) => [id, entry.pane]), ...[...this.claude.values()].map((entry) => [entry.sessionId, this.#claudePane(entry)])]);
+    const before = placed();
+    this.paneRoots = (roots ?? []).filter((root) => root?.pane && Number.isInteger(root.pid));
     for (const entry of this.grok.values()) this.#grokPane(entry);
-    if (JSON.stringify([...this.grok].map(([id, entry]) => [id, entry.pane])) !== before) this.#changed();
+    if (placed() !== before) this.#changed();
   }
 
   /** The messaging tools' markers kept here, and those servers from before wrote into the mail folder, taken in once
@@ -647,7 +655,7 @@ export class LiveSessions extends EventEmitter {
       if (entry.name.startsWith(RELAY_PREFIX) || !alive(entry.pid)) continue;
       const address = this.#address('claude-code', entry.sessionId);
       if (seen.has(address)) continue; seen.add(address);
-      out.push({ address, name: `${entry.name}@${this.machine}`, status: entry.status, door: 'native', pid: entry.pid, cwd: entry.cwd, pane: entry.tmux, tools: this.hasTools(entry.pid), socket: entry.socket ?? null });
+      out.push({ address, name: `${entry.name}@${this.machine}`, status: entry.status, door: 'native', pid: entry.pid, cwd: entry.cwd, pane: this.#claudePane(entry), tools: this.hasTools(entry.pid), socket: entry.socket ?? null });
     }
     const codex = new Set([...this.codexRunning.keys(), ...this.codexPaneOf.keys()]);
     for (const sessionId of codex) {

package/machine.mjs

@@ -922,8 +922,8 @@ export class TeamsMachine extends MachineCore {
         const titles = readJson(this.p.titles, { v: 1, titles: {} }).titles;
         const panes = rows.filter((row) => row.session?.id).map(({ session: s }) => ({ pane: s.contextKey, dead: Boolean(s.dead), pid: s.rootPid ?? null, label: s.label ?? null, title: titles[`pane:${s.contextKey}`] ?? s.label ?? null, cwd: s.cwd ?? null }));
         const live = panes.filter((pane) => !pane.dead && pane.pid);
-        // the pane each Grok session runs in (Grok's registry names its process; its pane is the one rooted at it)
-        this.live?.grokPanes(live.map((pane) => ({ pane: pane.pane, pid: pane.pid })));
+        // the pane each session whose record names none runs in (Grok's; Claude's on Windows): the one rooted at it
+        this.live?.panes(live.map((pane) => ({ pane: pane.pane, pid: pane.pid })));
         // the harness session under each live pane, as the board reads it: unread is said, never no session
         let activities = [], sessions_unread = null;
         if (live.length) {
@@ -1845,10 +1845,24 @@ export class TeamsMachine extends MachineCore {
   /** Whether the machine's stable supercode serves `command` in TypeScript (its front door's own list), asked once: a dev
    *  or cargo build's native, run with no front door, serves no hook verb. */
   #frontDoorServes(command) {
+    // asked once, kept while it answered; an ask that found nothing is asked again a minute on, never kept for the
+    // daemon's life (one slow or failed start of the front door refused every relay send until a restart)
+    if (this.frontDoorServed !== undefined && !this.frontDoorServed.size && Date.now() - (this.frontDoorAskedAt ?? 0) > 60_000) this.frontDoorServed = undefined;
     if (this.frontDoorServed === undefined) {
       this.frontDoorServed = new Set();
+      this.frontDoorAskedAt = Date.now();
       try {
-        const answer = spawnSync(this.#stableSupercode(), ['front-door', '--json'], { env: this.env, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
+        const stable = this.#stableSupercode();
+        // On Windows the stable supercode is a `.cmd` shim, which Node starts only through a shell (EINVAL otherwise,
+        // since Node 20.12): asked plainly it answered nothing, so every relay was refused as "no front door here" and
+        // no mail reached a Claude session on the machine. The shim is supercode's own one line (claude_relay.rs:
+        // `@"<node>" "<front door>" %*`), so what it runs is run directly: no shell, nothing of its path read by one
+        // (#1270 review: cmd.exe /s cut a home path with a space at the space). A shim of another form goes through
+        // cmd.exe, the whole line in an outer pair of quotes, so /s takes off only those.
+        const direct = /\.(cmd|bat)$/i.test(stable) ? shimTarget(stable) : [stable];
+        const answer = direct
+          ? spawnSync(direct[0], [...direct.slice(1), 'front-door', '--json'], { env: this.env, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true })
+          : spawnSync(this.env.ComSpec || process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', `""${stable}" front-door --json"`], { env: this.env, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true, windowsVerbatimArguments: true });
         if (answer.status === 0) for (const row of JSON.parse(answer.stdout).typescript ?? []) this.frontDoorServed.add(row.command);
       } catch { /* none served */ }
     }
@@ -1864,6 +1878,14 @@ export class TeamsMachine extends MachineCore {
       const path = answer.status === 0 ? answer.stdout.trim() : '';
       if (path && isAbsolute(path) && existsSync(path)) this.stableSupercodePath = path;
     } catch { /* this daemon's own supercode */ }
+    // On Windows the daemon runs this release's per-version copy (service\bin\<version>, so an upgrade can replace the
+    // npm one), and `__stable-program` refuses it as not the machine's own supercode: the daemon fell back to that
+    // native, which serves no front door, so every relay was refused and no mail reached a Claude session here. The
+    // shim the machine's own supercode keeps in <SUPERCODE_HOME>\bin is the machine's stable supercode.
+    if (this.stableSupercodePath === null && process.platform === 'win32') {
+      const shim = join(supercodeHome(this.env), 'bin', 'supercode.cmd');
+      if (existsSync(shim)) this.stableSupercodePath = shim;
+    }
     return this.stableSupercodePath ?? this.supercodeBin;
   }
 
@@ -4329,3 +4351,13 @@ function healthEntry(env) {
   const sibling = fileURLToPath(new URL('../health/bin/health.mjs', import.meta.url));
   return existsSync(sibling) ? sibling : null;
 }
+
+/** What supercode's Windows shim runs, from its one line (`@"<node>" "<front door>" %*`, or `@"<native>" %*`;
+ *  claude_relay.rs writes it): `[program, ...args]`, or null for a shim of another form. */
+function shimTarget(path) {
+  let text;
+  try { text = readFileSync(path, 'utf8'); } catch { return null; }
+  const line = text.split(/\r?\n/).map((row) => row.trim()).find((row) => row.startsWith('@"'));
+  const m = line ? /^@"([^"]+)"(?: "([^"]+)")? %\*$/.exec(line) : null;
+  return m ? [m[1], ...(m[2] ? [m[2]] : [])] : null;
+}

package/mail/relay.mjs

@@ -270,7 +270,7 @@ export class Relays {
   async #ensure(spec, step = () => {}, { stale = false } = {}) {
     // a relay's hooks are the front door's verbs (mail step 1b): a stable supercode with no front door (a dev or cargo
     // build's native) would answer none of them, and every mail the relay is handed would be blocked unfiled
-    if (!this.hooksServed()) throw new Error('relays run their hooks through the machine\'s stable supercode, which has no front door here (a dev or cargo build); install supercode from npm to send to Claude sessions by relay');
+    if (!this.hooksServed()) throw new Error('relays run their hooks through the machine\'s stable supercode, and none here serves them (no stable supercode was found, or it is a dev or cargo build); install supercode from npm to send to Claude sessions by relay');
     const endpoint = await this.endpoint();
     step('relay endpoint');
     if (!endpoint) throw new Error('the relay endpoint is not served by this machine\'s daemon (its log says why); a Claude session can be sent mail once the daemon starts again');

package/native-codex-pane.mjs

@@ -8,7 +8,10 @@ import { basename, dirname, join } from 'node:path';
 
 const path = process.argv[2];
 const seed = JSON.parse(readFileSync(path, 'utf8'));
-const directory = mkdtempSync(join(tmpdir(), 'sc-codex-'));
+// A local socket's path holds at most 104 bytes (macOS; 108 on Linux): under a long TMPDIR (a scratch home's) the
+// endpoint goes under /tmp, private to this user as mkdtemp makes it, or neither side could open it.
+const base = process.platform !== 'win32' && Buffer.byteLength(join(tmpdir(), 'sc-codex-XXXXXX', 'native.sock')) > 103 ? '/tmp' : tmpdir();
+const directory = mkdtempSync(join(base, 'sc-codex-'));
 const socketPath = join(directory, 'native.sock');
 const endpoint = `unix://${socketPath}`;
 // Configuration is evaluated by the native server. Remote resume/fork refuses

package/native-questions.mjs

@@ -26,7 +26,9 @@ export async function codexQuestions({ threadId, threadIds, answer, socketPath,
   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 });
+  // The connection's own failure (a gone or unopenable endpoint) can be emitted before the request listens to it: it
+  // is the WebSocket's error then (the handshake times out), never an unhandled one that ends the machine daemon.
+  const socket = new WebSocket('ws://localhost/', { perMessageDeflate: false, createConnection: () => connect(socketPath).on('error', () => {}), handshakeTimeout: timeoutMs });
   let nextId = 0;
   const pending = new Map();
   const questions = new Map();

package/package.json

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