@volter/supercode-teams 0.2.177 → 0.2.179

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

@@ -1080,6 +1080,16 @@ export class TeamsMachine extends MachineCore {
 
   listPorts() { return listAnnouncedPorts(this.portsDir); }
 
+  /** The attach clients on each pane's tmux session, by its label; null where panes are not tmux's (a ConPTY host). */
+  #viewerCounts() {
+    if (process.platform === 'win32') return null;
+    const listed = spawnSync('tmux', [...(this.tmuxSocket ? ['-L', this.tmuxSocket] : []), 'list-clients', '-F', '#{session_name}'], { timeout: 3_000, encoding: 'utf8' });
+    const counts = new Map();
+    if (listed.status !== 0) return counts; // no server, or no clients: nothing shows any pane
+    for (const name of listed.stdout.split('\n').filter(Boolean)) counts.set(name, (counts.get(name) ?? 0) + 1);
+    return counts;
+  }
+
   /**
    * A terminal window on this machine's screen showing the pane, so the people at the machine see what runs on it:
    * in whichever capable terminal is installed (popup-terminals.mjs), running an attach client. The pane ending ends
@@ -1087,7 +1097,7 @@ export class TeamsMachine extends MachineCore {
    */
   #popupWindow(contextKey, session) {
     const terminal = popupTerminal(this.env);
-    if (!terminal) return;
+    if (!terminal) return false;
     const attach = process.platform === 'win32'
       ? [process.execPath, fileURLToPath(new URL('./bin/fleet.mjs', import.meta.url)), 'attach', contextKey, '--mode', 'control']
       // Presented as `supercode open`'s own client is (crates/cli/src/open.rs `attach`): the terminal sets its own
@@ -1095,7 +1105,7 @@ export class TeamsMachine extends MachineCore {
       // screen override, so the window's own scrollback, wheel and selection work instead of the wheel arriving
       // in the pane as up/down arrows.
       : ['/usr/bin/env', 'TERM=screen-256color', spawnSync('which', ['tmux'], { encoding: 'utf8' }).stdout.trim() || 'tmux', ...(this.tmuxSocket ? ['-L', this.tmuxSocket] : []), '-T', 'RGB', 'attach-session', '-t', session.label ?? contextKey];
-    openPopup(terminal, attach, { ...this.env, TMUX: '' });
+    return openPopup(terminal, attach, { ...this.env, TMUX: '' });
   }
 
   /**
@@ -1445,9 +1455,12 @@ export class TeamsMachine extends MachineCore {
         // hand here: a list that made a caller ask a second door "and is anything
         // wrong with these?" would be a list that knows and will not say.
         const rows = await this.attentionEvidence();
+        // how many clients each pane has now (a popped window, a `supercode open`, a relay streaming it elsewhere): what a caller must
+        // know before it opens another view of a pane on the same screen
+        const viewers = this.#viewerCounts();
         // `title` is what a viewer should show: the override if one is set, else the tmux label.
         return rows.filter((row) => row.session.id && shown(row.session.contextKey)).map(({ session: s, attention, rank, notify, evidence }) => ({
-          pane: s.contextKey, dead: Boolean(s.dead), label: s.label, title: titles[`pane:${s.contextKey}`] ?? s.label, cwd: s.cwd, owned: s.owned, activeCommand: s.activeCommand, pid: s.rootPid ?? null, size: s.size, suspended: this.suspended.has(s.contextKey),
+          pane: s.contextKey, dead: Boolean(s.dead), label: s.label, title: titles[`pane:${s.contextKey}`] ?? s.label, cwd: s.cwd, owned: s.owned, activeCommand: s.activeCommand, pid: s.rootPid ?? null, size: s.size, suspended: this.suspended.has(s.contextKey), viewers: viewers ? (viewers.get(s.label) ?? 0) : null,
           attention, rank, notify, evidence, input_cleanup: this.inputRepairs[s.contextKey] ? {pending:true,at:this.inputRepairs[s.contextKey].at,reason:this.inputRepairs[s.contextKey].reason} : null,
         }));
       }
@@ -1541,9 +1554,11 @@ export class TeamsMachine extends MachineCore {
           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 (params.popup !== false) this.#popupWindow(contextKey, session);
+        // the window this machine's screen shows the pane in, when one opened: the caller is told, so it does not open a
+        // second view of a pane that is already in front of the person at the machine
+        const window = params.popup !== false && this.#popupWindow(contextKey, session);
         if (params.notify) this.#noticeWhenEnded({ key, pane: contextKey, notify: params.notify, label: params.name ?? params.kind ?? params.program });
-        return { key, pane: contextKey, reused: false, status: 'ready' };
+        return { key, pane: contextKey, reused: false, status: 'ready', window };
       }
       case 'launches.get': {
         if (!operator) throw Object.assign(new Error('operators only'), { code: 403 });
@@ -1799,11 +1814,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.177",
+  "version": "0.2.179",
   "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/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>`);