@volter/supercode-teams 0.2.120 → 0.2.121

package/bin/teams.mjs

@@ -164,7 +164,7 @@ async function main() {
     case 'describe':
       return withNode(async (rpc) => out(await rpc.call('describe')));
     case 'panes': {
-      if (sub === 'ls') return withNode(async (rpc) => out(await rpc.call('panes.list')));
+      if (sub === 'ls') return withNode(async (rpc) => out(await rpc.call(flags['presence-only'] ? 'panes.present' : 'panes.list')));
       if (sub === 'capture') return withNode(async (rpc) => out((await rpc.call('panes.capture', { pane: rest[0], lines: Number(flags.lines ?? 200) })).text));
       if (sub === 'close') return withNode(async (rpc) => out(await rpc.call('panes.close', { pane: rest[0] })));
       die('panes ls|capture|close');
@@ -229,6 +229,10 @@ async function main() {
       // `input <pane> <text>`: one delivery through the host's own sendInput; gated like control.
       // `--when-composer-empty`: a user's own turn, typed only into an empty composer
       // (answers `delivered: false` with the reason when it holds a draft).
+      if (flags['clear-draft']) {
+        if (rest.length || flags.key || flags['no-enter'] || flags['when-composer-empty']) die('input <pane> --clear-draft only clears the current draft; send a new message separately');
+        return withNode(async rpc => out(await rpc.call('panes.clearDraft', { pane: sub, caller: caller() })));
+      }
       if (flags.key !== undefined) {
         if (flags.key === true || rest.length) die('input <pane> --key NAMES: keys by tmux name, space- or comma-separated (Escape, Enter, Tab, BTab, BSpace, Space, Up, Down, Left, Right, Home, End, PPage, NPage, DC, C-a … C-z)');
         return withNode(async (rpc) => out(await rpc.call('panes.input', { pane: sub, text: keyBytes(String(flags.key)), submit: false, keys: true, caller: caller() })));
@@ -301,6 +305,10 @@ async function main() {
       return;
     }
     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 === '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.

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 { Workspaces, inspectCheckout } from './workspaces.mjs';
 import { readMailHistory } from './mail-history.mjs';
 import { randomBytes, createHash } from 'node:crypto';
 import { WebSocket } from 'ws';
@@ -1287,6 +1288,18 @@ export class TeamsMachine extends MachineCore {
       }
       case 'describe':
         return this.describe();
+      case 'panes.present': {
+        // No harness callback: discovery may be the harness's own caller.
+        const whole = operator || holds(admitted, 'view', '*');
+        if (!whole && !observesPanes(admitted)) need('view', '*');
+        const sessions = (await this.host.listSessions()).filter(s => s.contextKey && (whole || holds(admitted, 'observe', `pane:${s.contextKey}`)));
+        return Promise.all(sessions.map(async session => {
+          const screen = await this.host.capture(session.id, { lines: 100, preserveEscapes: true }).catch(() => null);
+          const kind = this.#paneKind(session.contextKey, session);
+          const composer = screen && terminal.composerText?.(kind, screen);
+          return { pane: session.contextKey, idleComposer: composer != null && !/\besc to (?:interrupt|cancel)\b/iu.test(screen) };
+        }));
+      }
       case 'panes.list': {
         // A participant lists the panes its grants let it observe; view on the whole
         // machine (or operator) lists them all.
@@ -1400,7 +1413,10 @@ export class TeamsMachine extends MachineCore {
         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}`);
+        if (!session) {
+          act('close', `pane:${params.pane}`, 'ok', 'already absent');
+          return { closed: params.pane, alreadyAbsent: true };
+        }
         await this.host.closeSession(session.id);
         act('close', `pane:${params.pane}`);
         return { closed: params.pane };
@@ -1454,6 +1470,34 @@ export class TeamsMachine extends MachineCore {
         act('control', `pane:${params.pane}`, result.delivered ? 'input' : 'failed', result.reason);
         return result;
       }
+      case 'panes.clearDraft': {
+        need('control', `pane:${params.pane}`);
+        this.#refuseForeign(params.pane, await this.#callerOf(entry, params));
+        const session = await this.#paneByContext(params.pane);
+        if (!session) throw new Error(`no pane with context ${params.pane}`);
+        if (this.suspended.has(params.pane)) throw new Error('pane is suspended; resume remote input first');
+        if (this.inputInFlight.has(session.id)) return { cleared: false, reason: 'input-in-flight' };
+        this.inputInFlight.add(session.id);
+        try {
+          const kind = this.#paneKind(params.pane, session);
+          if (!['codex', 'claude-code'].includes(kind) || !terminal.composerText) return { cleared: false, reason: 'unsupported-composer' };
+          const read = async () => {
+            const screen = await this.host.capture(session.id, { lines: 200, preserveEscapes: true });
+            return /\besc to (?:interrupt|cancel)\b/iu.test(screen) ? null : terminal.composerText(kind, screen);
+          };
+          const before = await read();
+          await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
+          if (before === null || before !== await read()) return { cleared: false, reason: 'composer-not-stable' };
+          if (before === '') return { cleared: true, alreadyEmpty: true };
+          // Explicit deletion, never submit. Readline end/kill-left clears the observed line;
+          // a multiline or changed editor is reported unconfirmed, never sent as a turn.
+          await this.host.sendInput(session.id, '\u0005\u0015', { submitMode: 'single' });
+          await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
+          const after = await read(), cleared = after === '';
+          act('control', `pane:${params.pane}`, cleared ? 'draft-cleared' : 'draft-clear-unconfirmed');
+          return { cleared, reason: cleared ? null : 'composer-not-empty', beforeHash: createHash('sha256').update(before).digest('hex') };
+        } finally { this.inputInFlight.delete(session.id); }
+      }
       case 'panes.turn': {
         // A user's own turn, as its own submitted turn: typed only into an empty
         // composer, read twice so a person who just started typing is not typed
@@ -1558,6 +1602,16 @@ 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': {
+        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.list' ? registry.list()
+          : registry.resolve(params.repository, params.branch, { solo: params.solo, card: params.card, create: params.create });
+        act('workspace', '*', 'ok', method);
+        return result;
+      }
       case 'jobs.list': {
         // The execution jobs this daemon owns now (execution.mjs): a pilot changes its binding
         // only when the target it leaves and the one it takes run none.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.120",
+  "version": "0.2.121",
   "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",
@@ -32,7 +32,8 @@
     "./connector/native-continuation": {
       "types": "./connector/native-continuation.d.ts",
       "default": "./connector/native-continuation.mjs"
-    }
+    },
+    "./workspaces": "./workspaces.mjs"
   },
   "bin": {
     "supercode-teams": "./bin/teams.mjs",

package/workspaces.mjs

@@ -0,0 +1,81 @@
+// Each machine owns its repository/branch → checkout map. Cards carry only identity.
+import { appendFileSync, readFileSync, mkdirSync, realpathSync, existsSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+export { teamsHome } from '@volter/teams/home';
+
+const git = (path, args, optional = false) => {
+  const r = spawnSync('git', ['-C', path, ...args], { encoding: 'utf8', timeout: 30_000 });
+  if (r.status !== 0) { if (optional) return null; throw new Error(`git ${args[0]} in ${path}: ${(r.stderr || r.error?.message || 'failed').trim()}`); }
+  return r.stdout.trim();
+};
+export function repositoryId(value) {
+  let s = String(value ?? '').trim().replace(/\.git\/?$/, '').replace(/\/$/, '');
+  if (/^[^/@]+@[^:]+:/.test(s)) s = s.replace(/^[^@]+@/, '').replace(':', '/');
+  else if (/^[a-z]+:\/\//i.test(s)) { const u = new URL(s); s = u.host + u.pathname; }
+  s = s.replace(/^github\.com\//i, '');
+  if (!/^[\w.-]+(?:\/[\w.-]+)+$/.test(s) || s.split('/').some(p => p === '.' || p === '..')) throw new Error('repository must be a git remote identity, for example volter-ai/editor; not a machine path');
+  return s;
+}
+export function inspectCheckout(path) {
+  const raw = git(path, ['rev-parse', '--path-format=absolute', '--show-toplevel', '--git-dir', '--git-common-dir']);
+  const [root, dir, common] = raw.split('\n').map(p => realpathSync(resolve(path, p)));
+  const remote = git(root, ['remote', 'get-url', 'origin'], true);
+  return { path: realpathSync(path), root, linked: dir !== common, repository: remote ? repositoryId(remote) : null, branch: git(root, ['branch', '--show-current']) || null };
+}
+export class Workspaces {
+  constructor(home) { this.file = join(home, 'workspaces.jsonl'); }
+  list() {
+    let text; try { text = readFileSync(this.file, 'utf8'); } catch (e) { if (e.code === 'ENOENT') return []; throw e; }
+    const map = new Map();
+    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);
+    }
+    return [...map.values()];
+  }
+  register(path, repository = null) {
+    const info = inspectCheckout(path), id = repositoryId(repository ?? info.repository);
+    if (info.repository && id !== info.repository) throw new Error(`checkout origin is ${info.repository}, not ${id}`);
+    const row = { repository: id, branch: info.branch, path: info.root, primary: !info.linked };
+    mkdirSync(dirname(this.file), { recursive: true });
+    appendFileSync(this.file, JSON.stringify(row) + '\n', { mode: 0o600 });
+    return row;
+  }
+  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>`);
+    const exact = branch && rows.find(r => r.branch === branch);
+    const primary = rows.find(r => r.primary);
+    if (!solo) {
+      const row = branch ? exact : primary;
+      if (!row) throw new Error(`repository ${id}, branch ${branch ?? '(primary)'} is missing from this machine's workspace map`);
+      const facts = inspectCheckout(row.path);
+      if (facts.repository !== id || facts.branch !== row.branch) throw new Error(`workspace map for ${id} is stale; register the current checkout`);
+      return facts;
+    }
+    if (!primary) throw new Error(`repository ${id} has no main checkout registered on this machine for a solo worktree`);
+    const root = inspectCheckout(primary.path);
+    if (root.linked || root.repository !== id) throw new Error(`registered main checkout for ${id} is stale or already a linked worktree`);
+    if (!card || !/^[\w-]+$/.test(card)) throw new Error('solo worktree needs a card id');
+    const wanted = branch || `wt/${card}`;
+    if (!git(root.root, ['check-ref-format', '--branch', wanted], true)) throw new Error(`invalid worktree branch ${wanted}`);
+    const target = join(root.root, '.worktrees', card);
+    if (!existsSync(target) && create) {
+      mkdirSync(dirname(target), { recursive: true });
+      const exists = git(root.root, ['show-ref', '--verify', `refs/heads/${wanted}`], true);
+      const upstream = git(root.root, ['show-ref', '--verify', `refs/remotes/origin/${wanted}`], true);
+      git(root.root, ['worktree', 'add', ...(exists ? [] : ['-b', wanted]), target, ...(exists ? [wanted] : upstream ? [`refs/remotes/origin/${wanted}`] : [])]);
+    }
+    if (existsSync(target)) {
+      const facts = inspectCheckout(target);
+      if (!facts.linked || facts.repository !== id || facts.branch !== wanted) throw new Error(`card worktree ${target} does not match ${id}, branch ${wanted}`);
+      if (create) this.register(target, id);
+    }
+    return { repository: id, branch: wanted, path: target, root: root.root, linked: true };
+  }
+}