@volter/supercode-teams 0.2.176 → 0.2.178

package/bin/teams.mjs

@@ -307,12 +307,13 @@ async function main() {
     case 'workspace': {
       if (sub === 'list') return withNode(async (rpc) => out(await rpc.call('workspace.list', {})));
       if (sub === 'register' && rest[0]) return withNode(async (rpc) => out(await rpc.call('workspace.register', { path: rest[0], repository: flags.repo ?? null })));
+      if (sub === 'unregister' && rest[0]) return withNode(async (rpc) => out(await rpc.call('workspace.unregister', { path: rest[0] })));
       if (sub === 'resolve' && rest[0]) return withNode(async (rpc) => out(await rpc.call('workspace.resolve', { repository: rest[0], branch: flags.branch ?? null, solo: Boolean(flags.solo), card: flags.card ?? null, create: Boolean(flags.create) })));
       if (sub === 'inspect' && rest[0]) return withNode(async (rpc) => out(await rpc.call('workspace.inspect', { path: rest[0] })));
       // `workspace move --from A --to B --path P [--to-path Q]`: the project leaves A and arrives
       // at B, published there only if every byte arrived (sha256 on commit) and neither machine
       // runs an exec job. A is left as it was; B's path must not exist.
-      if (sub !== 'move' || !flags.from || !flags.to || !flags.path) die('workspace move --from MACHINE --to MACHINE --path P [--to-path Q]');
+      if (sub !== 'move' || !flags.from || !flags.to || !flags.path) die('workspace list | register PATH [--repo R] | unregister PATH | resolve REPO | inspect PATH | move --from MACHINE --to MACHINE --path P [--to-path Q]');
       try {
         out(await moveWorkspace({ from: String(flags.from), to: String(flags.to), path: String(flags.path), toPath: String(flags['to-path'] ?? flags.path), context: flags.context ? String(flags.context) : null, home }));
       } catch (error) { die(error.message, error.exitCode ?? 1); }

package/machine.mjs

@@ -1799,11 +1799,12 @@ export class TeamsMachine extends MachineCore {
         act('title', params.target, 'ok', renamed);
         return { ok: true, target: params.target, title: params.title ?? null, window: renamed };
       }
-      case 'workspace.inspect': case 'workspace.register': case 'workspace.list': case 'workspace.resolve': {
+      case 'workspace.inspect': case 'workspace.register': case 'workspace.unregister': case 'workspace.list': case 'workspace.resolve': {
         if (!operator) throw Object.assign(new Error('operators only'), { code: 403 });
         const registry = new Workspaces(this.home);
         const result = method === 'workspace.inspect' ? inspectCheckout(params.path)
           : method === 'workspace.register' ? registry.register(params.path, params.repository)
+          : method === 'workspace.unregister' ? registry.unregister(params.path)
           : method === 'workspace.list' ? registry.list()
           : registry.resolve(params.repository, params.branch, { solo: params.solo, card: params.card, create: params.create });
         act('workspace', '*', 'ok', method);

package/package.json

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

@@ -3,9 +3,20 @@
 import { mkdirSync, readFileSync, writeFileSync, renameSync, appendFileSync, statSync, openSync, readSync, closeSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
 import { StringDecoder } from 'node:string_decoder';
 import { codexUpdatePrompt } from './codex-startup.mjs';
 
+// When process `pid` started (ms), from `ps -o etime=` ([[dd-]hh:]mm:ss); null when it cannot be read.
+function startedAt(pid) {
+  if (!Number.isInteger(pid)) return null;
+  const out = spawnSync('ps', ['-o', 'etime=', '-p', String(pid)], { encoding: 'utf8' }).stdout?.trim();
+  const m = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(out ?? '');
+  if (!m) return null;
+  const [, d = 0, h = 0, mi, se] = m.map((v) => (v === undefined ? 0 : Number(v)));
+  return Date.now() - (((d * 24 + h) * 60 + mi) * 60 + se) * 1000;
+}
+
 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;
 
@@ -85,6 +96,13 @@ export class TerminalMailbox {
     this.state.binding = { context: session.contextKey, terminal: session.id, pid: session.rootPid, identity }; this.save();
     return messageIds;
   }
+  /** Whether `batch` was pasted into another terminal than the one the session runs in now. A batch from before
+   *  pastes recorded their terminal is judged by its last Enter: a process started after it never saw the paste. */
+  pastedElsewhere(batch) {
+    if (batch.terminal) return batch.terminal !== this.session.id || (batch.pid != null && batch.pid !== this.session.rootPid);
+    const started = startedAt(this.session.rootPid);
+    return Boolean(batch.last_enter) && started !== null && started > batch.last_enter;
+  }
   kick() {
     if (this.work) return this.work;
     this.work = this.drain().catch(error => {
@@ -117,6 +135,16 @@ export class TerminalMailbox {
       this.state.receipts.push(receipt);
       this.state.active = null; this.save(); this.log(receipt); return;
     }
+    if (batch.phase !== 'prepared' && this.session && this.pastedElsewhere(batch)) {
+      // The paste went to a terminal the session no longer runs in (its pane's process was replaced, a resume): that
+      // composer died with its process and the transcript never got the text, so the batch is pasted again here.
+      // Nothing is guessed: the transcript was read above, from the paste's own offset, and holds no such message.
+      this.log({ delivered: false, queued: true, batch: batch.id, message_ids: batch.message_ids, reason: `pasted into terminal ${batch.terminal ?? 'unrecorded'}, which the session no longer runs in; pasting again into ${this.session.id}` });
+      const baseline = batch.kind === 'codex' ? null : await this.load(this.identity.locator, { message_tail: 1 });
+      Object.assign(batch, { phase: 'prepared', enters: 0, last_enter: 0, error: null, path: this.identity.path, locator: this.identity.locator,
+        offset: batch.kind === 'codex' ? statSync(this.identity.path).size : null, messageOffset: baseline?.window?.total_messages ?? null });
+      this.save();
+    }
     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;
@@ -124,7 +152,7 @@ export class TerminalMailbox {
     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.
-      batch.phase = 'paste_started'; this.save();
+      Object.assign(batch, { phase: 'paste_started', terminal: this.session.id, pid: this.session.rootPid ?? null, pasted_at: Date.now() }); this.save();
       // The terminal host's final newline selects one bracketed paste;
       // submitMode:none holds the separate Enter until the paste completes.
       await this.host.sendInput(this.session.id, `${batch.text}\n`, { submitMode: 'none' });

package/workspaces.mjs

@@ -25,18 +25,27 @@ export function inspectCheckout(path) {
 }
 export class Workspaces {
   constructor(home) { this.file = join(home, 'workspaces.jsonl'); }
-  list() {
+  // Every registration stands until its checkout is registered again or unregistered; the newest standing row
+  // answers each repository and branch (list). Unregistering a registration made by mistake therefore gives back
+  // the one it replaced; the removal row stays in the file as the record of that act.
+  standing() {
     let text; try { text = readFileSync(this.file, 'utf8'); } catch (e) { if (e.code === 'ENOENT') return []; throw e; }
-    const map = new Map();
+    let standing = [];
     for (const line of text.split('\n').filter(Boolean)) {
       let row; try { row = JSON.parse(line); } catch { throw new Error(`invalid machine workspace map ${this.file}`); }
-      for (const [key, old] of map) {
-        if (old.path === row.path) map.delete(key);
-        else if (row.primary && old.repository === row.repository) old.primary = false;
-      }
-      map.set(`${row.repository}\n${row.branch ?? ''}`, row);
+      standing = standing.filter((old) => old.path !== row.path);
+      if (!row.removed) standing.push(row);
     }
-    return [...map.values()];
+    return standing;
+  }
+  list() {
+    const map = new Map();
+    for (const row of this.standing()) { const key = `${row.repository}\n${row.branch ?? ''}`; map.delete(key); map.set(key, { ...row }); }
+    // A repository's main checkout is its newest registered main checkout that stands.
+    const rows = [...map.values()], main = new Map();
+    for (const row of rows) if (row.primary) main.set(row.repository, row);
+    for (const row of rows) row.primary = main.get(row.repository) === row;
+    return rows;
   }
   register(path, repository = null) {
     const info = inspectCheckout(path), id = repositoryId(repository ?? info.repository);
@@ -46,6 +55,16 @@ export class Workspaces {
     appendFileSync(this.file, JSON.stringify(row) + '\n', { mode: 0o600 });
     return row;
   }
+  // A registration made by mistake is removed: the checkout at `path` (its root, as registered) leaves the map. The
+  // checkout itself is untouched.
+  unregister(path) {
+    let at = resolve(path);
+    try { at = inspectCheckout(path).root; } catch { try { at = realpathSync(at); } catch { /* a path that no longer exists */ } }
+    const row = this.standing().findLast(r => r.path === at || r.path === resolve(path));
+    if (!row) throw new Error(`${path} is not registered in this machine's workspace map`);
+    appendFileSync(this.file, JSON.stringify({ path: row.path, removed: true, repository: row.repository, branch: row.branch }) + '\n', { mode: 0o600 });
+    return { ...row, removed: true };
+  }
   resolve(repository, branch = null, { solo = false, card = null, create = false } = {}) {
     const id = repositoryId(repository), rows = this.list().filter(r => r.repository === id);
     if (!rows.length) throw new Error(`repository ${id} is missing from this machine's workspace map; register its checkout with teams workspace register <path>`);