@volter/supercode-teams 0.3.151 → 0.3.153

package/native-codex-pane.mjs

@@ -2,12 +2,14 @@
 // Supercode hosts neither the agent nor its run loop; it can attach to native
 // question requests while the stock TUI remains the session's UI.
 import { spawn } from 'node:child_process';
-import { readFileSync, writeFileSync, renameSync, mkdtempSync, existsSync, rmSync, appendFileSync, mkdirSync } from 'node:fs';
+import { readFileSync, mkdtempSync, existsSync, rmSync, appendFileSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
+import { nativeLaunchBinding } from './native-launch-binding.mjs';
 
 const path = process.argv[2];
-const seed = JSON.parse(readFileSync(path, 'utf8'));
+const home = process.argv[3];
+const { seed } = await nativeLaunchBinding(path, { home });
 // 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();
@@ -51,7 +53,7 @@ if(writableRoots.length)config.push('-c',`sandbox_workspace_write.writable_roots
 // maintainer off for three hours). It is kept in a folder beside the bindings' (never among them: the carrier reads
 // every file there on each poll, mail_question.rs `poll`), at most LOG_BYTES of it.
 const LOG_BYTES = 8 * 1024 * 1024;
-const serverLog = join(dirname(path), '..', 'native-launch-logs', `${basename(path).replace(/\.json$/, '')}.app-server.log`);
+const serverLog = join(dirname(dirname(dirname(path))), 'native-launch-logs', `${basename(path).replace(/\.json$/, '')}.app-server.log`);
 try { mkdirSync(dirname(serverLog), { recursive: true, mode: 0o700 }); } catch { /* its log is best kept */ }
 let logged = 0;
 const server = spawn(seed.program, [...config, 'app-server', '--listen', endpoint], { stdio: ['ignore', 'ignore', 'pipe'] });
@@ -79,9 +81,7 @@ try {
   const deadline = Date.now() + 15_000;
   while (!existsSync(socketPath) && !ended && !serverError && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 50));
   if (!existsSync(socketPath) || serverError || ended) throw serverError ?? new Error('Native Codex question endpoint did not start; no TUI input was sent.');
-  const staged = `${path}.${process.pid}`;
-  writeFileSync(staged, JSON.stringify({ ...seed, socketPath, ownerPid: process.pid }), { mode: 0o600 });
-  renameSync(staged, path);
+  await nativeLaunchBinding(path, { socketPath, home });
   const args = [...tuiArguments, '--remote', endpoint];
   if (!args.some((arg) => arg === '-C' || arg === '--cd' || arg.startsWith('--cd='))) args.push('--cd', process.cwd());
   if (seed.initialInput) args.push('--', seed.initialInput);

package/native-initial-input.mjs

@@ -1,7 +1,7 @@
 // Native CLIs accept an initial prompt before their TUI starts. Their own
 // transcript, not a collapsed paste badge or an empty editor, confirms receipt.
-import { open, readdir, readFile, stat } from 'node:fs/promises';
-import { join, win32 } from 'node:path';
+import { open, readdir, stat } from 'node:fs/promises';
+import { basename, join, win32 } from 'node:path';
 import { StringDecoder } from 'node:string_decoder';
 import { codexQuestions } from './native-questions.mjs';
 
@@ -52,7 +52,7 @@ function codexRolloutIsLaunch(meta, { cwd, startedAt, continuing }) {
   return Date.parse(meta.timestamp) >= startedAt - 1000;
 }
 
-export async function confirmNativeInitialInput({ binding, kind, text, startedAt, codexSessions, cwd, continuing = false, resumeId = null }, { signal, deadlineMs, live }) {
+export async function confirmNativeInitialInput({ binding, kind, text, startedAt, codexSessions, cwd, continuing = false, resumeId = null }, { signal, deadlineMs, live, store }) {
   const readers = new Map();
   const expired = () => signal.aborted || Date.now() >= deadlineMs;
   try {
@@ -63,10 +63,10 @@ export async function confirmNativeInitialInput({ binding, kind, text, startedAt
         if (codexSessions) {
           paths = await codexRolloutsSince(codexSessions, startedAt, continuing, resumeId);
         } else if (kind === 'claude-code') {
-          paths = [JSON.parse(await readFile(binding.replace(/\.json$/, '.session.json'), 'utf8'))];
+          paths = [store.record('native_launches', basename(binding).replace(/\.json$/, '.session.json')) ?? {}];
         } else {
-          const seed = JSON.parse(await readFile(binding, 'utf8'));
-          if (seed.socketPath) {
+          const seed = store.record('native_launches', basename(binding));
+          if (seed?.socketPath) {
             const snapshot = await codexQuestions({ socketPath: seed.socketPath, discover: true, pathsOnly: true,
               timeoutMs: Math.min(2000, Math.max(1, deadlineMs - Date.now())) });
             paths = snapshot.threads.map(({ path }) => ({ path, offset: 0 }));

package/native-launch-binding.mjs

@@ -0,0 +1,35 @@
+// A pane bootstrap asks the daemon for its launch record. The legacy path is
+// an identifier only: no helper opens, rewrites or watches the old mail tree.
+import { dirname, join, resolve, sep } from 'node:path';
+import { openMachine } from './machine-door.mjs';
+import { nodeRpc } from './client.mjs';
+
+export function nativeLaunchKey(binding, mailRoot) {
+  const root = resolve(mailRoot, 'native-launches');
+  const path = resolve(String(binding ?? ''));
+  const key = path.slice(root.length + 1);
+  if (!path.startsWith(root + sep) || !/^[A-Za-z0-9_-]+\.json$/.test(key)) throw Object.assign(new Error(`${path} is not a native launch binding`), { code: 400 });
+  return key;
+}
+
+export async function nativeLaunchBinding(binding, { socketPath = null, home = null } = {}) {
+  const base = dirname(dirname(dirname(resolve(binding))));
+  const channel = await openMachine({ home: home ?? join(base, 'teams') });
+  try {
+    const rpc = await nodeRpc(channel);
+    const deadline = Date.now() + 10_000;
+    for (;;) {
+      try {
+        return await rpc.call('harness.v1.mail.native_launch', {
+          binding, ...(socketPath ? { socket_path: socketPath } : {}), claim: { pid: process.pid },
+        }, { timeoutMs: Math.max(1, deadline - Date.now()) });
+      } catch (error) {
+        if (error.code === -32601) throw new Error('this native pane needs a daemon that serves launch bindings; upgrade or restart its owned daemon before opening this pane. No TUI was started.');
+        // Only a positive "receipt not published yet" answer can be retried.
+        // An unanswered publication is never issued again automatically.
+        if (error.code !== 425 || Date.now() >= deadline) throw error;
+        await new Promise((done) => setTimeout(done, 50));
+      }
+    }
+  } finally { channel.close(); }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.151",
+  "version": "0.3.153",
   "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",
@@ -62,7 +62,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=20.19"
+    "node": ">=22.13.0"
   },
   "scripts": {},
   "dependencies": {

package/session-people.mjs

@@ -20,8 +20,7 @@
 //   - A terminal start with no recorded launch answers `person`: a person at a terminal, or a launcher that left no
 //     record (another program typing into a terminal), which nothing on the machine tells apart.
 // Files only grow, so each is read until its answer is known and then from where it was left.
-import { open, readdir, readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { open } from 'node:fs/promises';
 
 const facts = new Map(); // path → { offset, rest, started, firstInput, personTurns }
 const CHUNK = 4 * 1024 * 1024;
@@ -142,13 +141,13 @@ function reopens(kind, args) {
 }
 
 /** What this daemon's launches recorded: transcript paths, native session ids and first inputs. */
-async function launched(launchesDir, journalPath) {
+async function launched(store, journalPath) {
   if (journalPath) await readJournal(journalPath);
-  const names = (await readdir(launchesDir).catch(() => [])).filter((name) => name.endsWith('.json'));
-  for (const name of names) {
+  const records = store.records('native_launches').filter(({ key }) => key.endsWith('.json'));
+  const names = records.map(({ key }) => key);
+  for (const { key: name, value: record } of records) {
     if (bindings.has(name)) continue;
     try {
-      const record = JSON.parse(await readFile(join(launchesDir, name), 'utf8'));
       bindings.set(name, name.endsWith('.session.json')
         ? (record.path ? { path: record.path } : null)
         : {
@@ -184,8 +183,8 @@ export function sessionPeople(sessions, options) {
   return answer;
 }
 
-async function answerPeople(sessions, { launchesDir, journalPath }) {
-  const launches = await launched(launchesDir, journalPath);
+async function answerPeople(sessions, { store, journalPath }) {
+  const launches = await launched(store, journalPath);
   const answers = [];
   for (const { harness, path, id } of sessions) {
     if ((typeof id === 'string' && launches.sessions.has(id)) || (typeof path === 'string' && launches.paths.has(path))) {

package/terminal-mail.mjs

@@ -1,7 +1,6 @@
 // Per-recipient terminal mailbox. A retained paste is never repeated: retries
 // press Enter and look for the exact user message in the native transcript.
-import { mkdirSync, readFileSync, writeFileSync, renameSync, appendFileSync, statSync, openSync, readSync, closeSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { statSync, openSync, readSync, closeSync } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { StringDecoder } from 'node:string_decoder';
@@ -100,20 +99,15 @@ function confirmed(batch) {
 }
 
 export class TerminalMailbox {
-  constructor(root, recipient, log, load) {
-    this.dir = join(root, 'terminal-delivery', hash(recipient));
-    mkdirSync(this.dir, { recursive: true, mode: 0o700 });
-    this.file = join(this.dir, 'queue.json'); this.log = log; this.load = load;
-    try { this.state = JSON.parse(readFileSync(this.file, 'utf8')); }
-    catch (error) { if (error.code !== 'ENOENT') throw error; this.state = { recipient, pending: [], active: null, receipts: [], accepted: {} }; }
+  constructor(store, recipient, log, load) {
+    this.store = store; this.recipient = recipient; this.log = log; this.load = load;
+    this.state = store.terminalState(recipient) ?? { recipient, pending: [], active: null, receipts: [], accepted: {} };
     this.work = null;
   }
   save() {
     const encoded = JSON.stringify(this.state) + '\n';
     if (encoded === this.saved) return;
-    const temporary = `${this.file}.${process.pid}.tmp`;
-    writeFileSync(temporary, encoded, { mode: 0o600 });
-    renameSync(temporary, this.file); this.saved = encoded;
+    this.store.saveTerminalState(this.recipient, this.state); this.saved = encoded;
   }
   receipt(ids) {
     const delivered = ids.every(id => this.state.receipts.some(r => r.message_ids.includes(id)));
@@ -233,7 +227,7 @@ export class TerminalMailbox {
     }
     if (seen) {
       const receipt = { batch: batch.id, message_ids: batch.message_ids, delivered: true, receipt: seen.fragments > 1 ? 'native-user-messages' : 'native-user-message', fragments: seen.fragments ?? 1, at: Date.now() };
-      appendFileSync(join(this.dir, 'receipts.jsonl'), JSON.stringify(receipt) + '\n', { mode: 0o600 });
+      this.store.terminalEvent(this.recipient, 'receipt', receipt);
       if (batch.inputOwner) await this.releaseOwner(batch);
       this.state.receipts.push(receipt);
       this.state.active = null; this.save(); this.log(receipt); return;
@@ -340,7 +334,7 @@ export class TerminalMailbox {
       batch.enters += 1; batch.last_enter = Date.now(); this.save();
       await this.host.sendInput(this.session.id, '\r', { submitMode: 'single', ...(batch.kind === 'claude-code' ? { inputOwner: batch.inputOwner } : {}) });
       const attempt = { delivered: false, queued: true, batch: batch.id, message_ids: batch.message_ids, attempt: batch.enters, at: Date.now() };
-      appendFileSync(join(this.dir, 'attempts.jsonl'), JSON.stringify(attempt) + '\n', { mode: 0o600 });
+      this.store.terminalEvent(this.recipient, 'attempt', attempt);
       this.log(attempt);
     }
     batch.error = batch.kind !== 'claude-code' && batch.enters >= 3 ? 'native transcript unconfirmed after Enter retries' : 'native transcript confirmation pending';
@@ -348,9 +342,4 @@ export class TerminalMailbox {
   }
 }
 
-export function retainedTerminalMail(root) {
-  const directory = join(root, 'terminal-delivery');
-  let names; try { names = readdirSync(directory); } catch (error) { if (error.code === 'ENOENT') return []; throw error; }
-  return names.map(name => JSON.parse(readFileSync(join(directory, name, 'queue.json'), 'utf8')))
-    .filter(state => state.active || state.pending.length);
-}
+export function retainedTerminalMail(store) { return store.retainedTerminalStates(); }