@volter/supercode-teams 0.2.100 → 0.2.102

package/bin/fleet.mjs

@@ -16,6 +16,7 @@
 // `--on` names an enrolled machine of the selected context, reached through
 // its Teams server. Omitted, every verb acts on this OS user's own daemon, so
 // the remote arm and the local arm are one code path.
+import { spawnSync } from 'node:child_process';
 import { attachPane, attachRuntime } from '../client.mjs';
 import { openOn, harnessRequest, nodeRequest, fleetDiscover } from '../fleet.mjs';
 
@@ -45,6 +46,20 @@ function channelForOn() {
   return openOn(onName(), { context: contextName() });
 }
 
+// Who starts a pane: supercode names it when it runs this CLI (empty: a person); run on its own, supercode is asked
+// (`teams caller`), and a launch no supercode answers for records no starter (so no session may act on the pane).
+let launcherAnswer;
+function launcher() {
+  if (launcherAnswer === undefined) {
+    if (process.env.SUPERCODE_CALLER !== undefined) launcherAnswer = process.env.SUPERCODE_CALLER || null;
+    else {
+      const r = spawnSync(process.env.SUPERCODE_BIN || 'supercode', ['teams', 'caller'], { encoding: 'utf8', shell: process.platform === 'win32', windowsHide: true });
+      try { launcherAnswer = JSON.parse(r.stdout.trim().split('\n').pop()).caller ?? null; } catch { launcherAnswer = null; }
+    }
+  }
+  return launcherAnswer;
+}
+
 async function main() {
   switch (verb) {
     case 'discover': {
@@ -85,6 +100,10 @@ async function main() {
           name: flags.name,
           // `open` attaching this terminal to the pane itself asks the machine for no window of its own.
           ...(flags.popup === 'false' ? { popup: false } : {}),
+          // Who starts the pane (the session or board supercode resolved; unset for a person), and whether the pane
+          // runs its one verb as that caller (`close`/`stop` on another machine).
+          ...(launcher() ? { caller: launcher() } : {}),
+          ...(flags['act-for-caller'] ? { actForCaller: true } : {}),
           // `open --notify-when-ended`: the launching session's address, told once when the pane ends, and the
           // machine's mail name the notice comes from.
           ...(typeof flags.notify === 'string' ? { notify: { to: flags.notify, machine: String(flags['notify-machine'] ?? flags.on ?? '') } } : {}),

package/bin/teams.mjs

@@ -26,6 +26,7 @@
 // members, groups, sources, sync, machines, sessions) is the Teams workspace
 // CLI in ./workspace.mjs.
 import { createWriteStream, readFileSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
 
 // A Windows scheduled task keeps no output (launchd and systemd name log files), so its unit names one here.
@@ -106,6 +107,24 @@ async function machineChannel() {
   return openMachine({ machine: flags.machine ? String(flags.machine) : null, context: flags.context ? String(flags.context) : null, home });
 }
 
+// The session (or board) this command acts for: the pane doors refuse a session acting on a pane it did not start.
+// supercode names it when it runs this CLI (empty: a person); run on its own (`supercode-teams`), this CLI asks
+// supercode (`teams caller`), which reads the session from this process's ancestry, and refuses when none answers.
+let callerAnswer;
+function caller() {
+  if (callerAnswer === undefined) {
+    if (process.env.SUPERCODE_CALLER !== undefined) callerAnswer = process.env.SUPERCODE_CALLER || null;
+    else {
+      const r = spawnSync(process.env.SUPERCODE_BIN || 'supercode', ['teams', 'caller'], { encoding: 'utf8', shell: process.platform === 'win32', windowsHide: true });
+      let answer;
+      try { answer = JSON.parse(r.stdout.trim().split('\n').pop()); } catch { /* no answer */ }
+      if (!answer || !('caller' in answer)) die(`cannot tell which session runs this, so the pane doors cannot hold it to the panes it started; nothing was done. Run it as \`supercode teams …\` (${(r.error?.message ?? r.stderr ?? '').trim().slice(0, 200)})`, 1);
+      callerAnswer = answer.caller ?? null;
+    }
+  }
+  return callerAnswer ?? undefined;
+}
+
 async function withNode(fn) {
   const channel = await machineChannel();
   try {
@@ -149,7 +168,7 @@ async function main() {
     case 'panes': {
       if (sub === 'ls') return withNode(async (rpc) => out(await rpc.call('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] })));
+      if (sub === 'close') return withNode(async (rpc) => out(await rpc.call('panes.close', { pane: rest[0], caller: caller() })));
       die('panes ls|capture|close');
     }
     case 'title': {
@@ -173,9 +192,9 @@ async function main() {
       die('attention ls | rank | request <pane> [--urgency now|soon|whenever] [--reason text] | clear <pane>');
     }
     case 'suspend':
-      return withNode(async (rpc) => out(await rpc.call('panes.suspend', { pane: sub, interrupt: Boolean(flags.interrupt) })));
+      return withNode(async (rpc) => out(await rpc.call('panes.suspend', { pane: sub, interrupt: Boolean(flags.interrupt), caller: caller() })));
     case 'resume':
-      return withNode(async (rpc) => out(await rpc.call('panes.resume', { pane: sub, input: flags.input ? String(flags.input) : null })));
+      return withNode(async (rpc) => out(await rpc.call('panes.resume', { pane: sub, input: flags.input ? String(flags.input) : null, caller: caller() })));
     case 'files': {
       const path = rest[0];
       if (sub === 'ls') return withNode(async (rpc) => out(await rpc.call('files.list', { path })));
@@ -214,10 +233,10 @@ async function main() {
       // (answers `delivered: false` with the reason when it holds a draft).
       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 })));
+        return withNode(async (rpc) => out(await rpc.call('panes.input', { pane: sub, text: keyBytes(String(flags.key)), submit: false, keys: true, caller: caller() })));
       }
-      if (flags['when-composer-empty']) return withNode(async (rpc) => out(await rpc.call('panes.turn', { pane: sub, text: rest.join(' ') })));
-      return withNode(async (rpc) => out(await rpc.call('panes.input', { pane: sub, text: rest.join(' '), submit: !flags['no-enter'] })));
+      if (flags['when-composer-empty']) return withNode(async (rpc) => out(await rpc.call('panes.turn', { pane: sub, text: rest.join(' '), caller: caller() })));
+      return withNode(async (rpc) => out(await rpc.call('panes.input', { pane: sub, text: rest.join(' '), submit: !flags['no-enter'], caller: caller() })));
     case 'port': {
       // `port <pane>/<n> [--listen host:port]`: a machine port forwarded here. Stays up until ctrl-c.
       const spec = String(sub ?? '');

package/machine.mjs

@@ -577,6 +577,19 @@ export class TeamsMachine extends MachineCore {
     return env;
   }
 
+  /**
+   * A session acts only on the panes it started: input, a turn, a suspend or a close from a session (`caller`, its
+   * address) on a pane another session, a board or a person started is refused, naming who started it. A person (no
+   * caller) and a board (its cards' own door) act on any pane.
+   */
+  #refuseForeign(pane, caller) {
+    if (typeof caller !== 'string' || !caller || /^sc:[^:]+:board:/.test(caller)) return;
+    const by = this.launches.all().find((entry) => entry.pane === pane)?.by ?? null;
+    if (by === caller) return;
+    const starter = by ? `was started by ${by}` : 'was not started by a session (a person or an earlier daemon started it)';
+    throw Object.assign(new Error(`pane ${pane} ${starter}, not by ${caller}: a session acts only on the panes it started. Nothing was done; reach that session through its own doors (supercode message send)`), { code: 403 });
+  }
+
   async #paneByContext(contextKey) {
     const sessions = await this.host.listSessions();
     return sessions.find((s) => s.contextKey === contextKey) ?? null;
@@ -701,13 +714,13 @@ export class TeamsMachine extends MachineCore {
    * Never rejects. The only caller is a fire-and-forget from the request path,
    * where an unhandled rejection would take the daemon down over one pane.
    */
-  #deliverInitialInput({ key, contextKey, session, kind, input, act }) {
+  #deliverInitialInput({ key, contextKey, session, kind, by, input, act }) {
     const abort = new AbortController();
     const task = (async () => {
       const readyBy = await this.#awaitInputReady(session, contextKey, kind, abort.signal);
       if (readyBy === 'aborted') return;
       if (readyBy === 'pane-gone') {
-        this.launches.record({ key, pane: contextKey, kind, status: 'ready', inputDelivered: false, inputReadyBy: readyBy });
+        this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: false, inputReadyBy: readyBy });
         act('launch', `pane:${contextKey}`, 'failed', 'first input undelivered: the pane ended before it was ready');
         return;
       }
@@ -719,7 +732,7 @@ export class TeamsMachine extends MachineCore {
       try {
         await this.host.sendInput(session.id, submission(input), { submitMode: 'single' });
       } catch (error) {
-        this.launches.record({ key, pane: contextKey, kind, status: 'ready', inputDelivered: false, inputReadyBy: readyBy, inputError: error.message });
+        this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: false, inputReadyBy: readyBy, inputError: error.message });
         act('launch', `pane:${contextKey}`, 'failed', `first input undelivered: ${error.code ?? error.message}`);
         return;
       }
@@ -728,12 +741,12 @@ export class TeamsMachine extends MachineCore {
       // vouched for. A launch that reads `ready` without it was given its
       // message by an input box that existed.
       const late = readyBy === 'deadline';
-      this.launches.record({ key, pane: contextKey, kind, status: 'ready', inputDelivered: true, inputReadyBy: readyBy, ...(late ? { inputDeliveredLate: true } : {}) });
+      this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: true, inputReadyBy: readyBy, ...(late ? { inputDeliveredLate: true } : {}) });
       act('launch', `pane:${contextKey}`, 'ok', `first input delivered (${readyBy})`);
     })().catch((error) => {
       // Nothing above is expected to throw; if something does, the launch record
       // is where it is answerable, not a crashed daemon.
-      this.launches.record({ key, pane: contextKey, kind, status: 'ready', inputDelivered: false, inputError: error?.message ?? String(error) });
+      this.launches.record({ key, pane: contextKey, kind, by, status: 'ready', inputDelivered: false, inputError: error?.message ?? String(error) });
     }).finally(() => {
       if (this.pendingInitialInputs.get(key)?.task === task) this.pendingInitialInputs.delete(key);
     });
@@ -1140,10 +1153,13 @@ export class TeamsMachine extends MachineCore {
           return { key, pane: existing.pane, reused: true, status: existing.status };
         }
         const contextKey = params.pane ?? `p_${randomBytes(9).toString('base64url')}`;
+        // Who started the pane: the launching session's (or board's) address, null for a person. A session's later
+        // input and close on the pane are refused unless it is this one (#refuseForeign).
+        const by = typeof params.caller === 'string' && params.caller ? params.caller : null;
         // Who to tell when the pane ends (`open --new … --notify-when-ended`): a session's mail address, and this
         // machine's name as the address a notice from its pane comes from.
         if (params.notify !== undefined && !(params.notify && typeof params.notify.to === 'string' && /^sc:[^:\s]+:[^:\s]+:\S+$/.test(params.notify.to) && typeof params.notify.machine === 'string' && /^[a-z0-9][a-z0-9-]*$/.test(params.notify.machine))) throw Object.assign(new Error('launch notify is { to: <sc: address>, machine: <this machine\'s mail name> }'), { code: 400 });
-        this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, status: 'issued' });
+        this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, status: 'issued' });
         if (params.kind === 'claude-code' && params.cwd && (params.arguments ?? []).includes('--dangerously-skip-permissions')) trustClaudeFolder(params.cwd);
         let session;
         try {
@@ -1151,17 +1167,18 @@ export class TeamsMachine extends MachineCore {
             command: launchCommand(params.program, params.arguments ?? []),
             contextKey,
             cwd: params.cwd,
-            env: this.#paneEnv(contextKey, params.env),
+            // A pane that runs one verb for its launcher (`close`/`stop` on another machine) acts as that launcher.
+            env: this.#paneEnv(contextKey, params.actForCaller && by ? { ...params.env, SUPERCODE_CALLER: by } : params.env),
             // The pane's own tmux session is always its key: the exit hooks record and clean up p_* sessions only, and
             // a pane named otherwise lingered dead with its exit status lost. A launch's name is its title.
             name: contextKey,
           });
         } catch (error) {
-          this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, status: 'failed', error: error.message });
+          this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, status: 'failed', error: error.message });
           act('launch', `pane:${contextKey}`, 'failed', error.code ?? error.message);
           throw error;
         }
-        this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, status: 'ready' });
+        this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, status: 'ready' });
         act('launch', `pane:${contextKey}`, 'ok', params.kind ?? params.program);
         if (typeof params.name === 'string' && params.name.trim()) {
           const titles = readJson(this.p.titles, { v: 1, titles: {} });
@@ -1177,7 +1194,7 @@ export class TeamsMachine extends MachineCore {
         // outcome is recorded against the launch key, so `launches.get|list`
         // answers "did my message go in, and was it late?" without anyone
         // reading the screen.
-        if (params.initialInput) this.#deliverInitialInput({ key, contextKey, session, kind: params.kind ?? null, input: params.initialInput, act });
+        if (params.initialInput) this.#deliverInitialInput({ key, contextKey, session, kind: params.kind ?? null, by, input: params.initialInput, act });
         // A program that ends at once (not found, not runnable, failing on its first line) takes its pane with it:
         // the caller is told, with its exit status, instead of being handed a pane that is already gone.
         await new Promise((resolve) => setTimeout(resolve, LAUNCH_SETTLE_MS));
@@ -1186,7 +1203,7 @@ export class TeamsMachine extends MachineCore {
           // Finished (it ran to a clean end) is an answer; exited (it failed at once) is the caller's error.
           const exit = settled?.dead ? deadPaneExit(settled) : paneExit(contextKey);
           const status = exit && !exit.failed ? 'finished' : 'exited';
-          this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, status, error: exit?.failed ? exit.how : undefined });
+          this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, status, error: exit?.failed ? exit.how : undefined });
           return { key, pane: contextKey, reused: false, status, exit: exit?.how ?? null };
         }
         if (this.popups && params.popup !== false) this.#popupWindow(contextKey, session);
@@ -1210,12 +1227,13 @@ export class TeamsMachine extends MachineCore {
         const rows = [];
         for (const found of this.launches.all()) {
           const session = found.pane ? await this.#paneByContext(found.pane) : null;
-          rows.push({ key: found.key, pane: found.pane ?? null, kind: found.kind ?? null, status: found.status ?? null, at: found.t, live: Boolean(session), ...initialInputFacts(found) });
+          rows.push({ key: found.key, pane: found.pane ?? null, kind: found.kind ?? null, by: found.by ?? null, status: found.status ?? null, at: found.t, live: Boolean(session), ...initialInputFacts(found) });
         }
         return rows;
       }
       case 'panes.close': {
         need(operator ? 'control' : 'control', `pane:${params.pane}`);
+        this.#refuseForeign(params.pane, params.caller);
         const session = await this.#paneByContext(params.pane);
         if (!session) throw new Error(`no pane with context ${params.pane}`);
         await this.host.closeSession(session.id);
@@ -1228,6 +1246,7 @@ export class TeamsMachine extends MachineCore {
         // working, only `{input}` is refused — until `resume`, which may carry
         // the input that hands the pane back. Local tmux input is never touched.
         need('control', `pane:${params.pane}`);
+        this.#refuseForeign(params.pane, params.caller);
         const session = await this.#paneByContext(params.pane);
         if (!session) throw new Error(`no pane with context ${params.pane}`);
         const doc = readJson(this.p.suspended, { v: 1, panes: {} });
@@ -1249,6 +1268,7 @@ export class TeamsMachine extends MachineCore {
         // mechanics) for callers that are services rather than terminals. Same gate as an
         // attachment in control mode, same suspend rule as remote input everywhere.
         need('control', `pane:${params.pane}`);
+        this.#refuseForeign(params.pane, params.caller);
         const session = await this.#paneByContext(params.pane);
         if (!session) throw Object.assign(new Error(`no pane with context ${params.pane}`), { code: 404 });
         if (this.suspended.has(params.pane)) throw Object.assign(new Error(`pane ${params.pane} is suspended: remote input is refused until resume`), { code: 423 });
@@ -1267,6 +1287,7 @@ export class TeamsMachine extends MachineCore {
         // answer, not an error: the caller keeps the turn and asks again. Its own
         // method, so a daemon without it refuses instead of typing into a draft.
         need('control', `pane:${params.pane}`);
+        this.#refuseForeign(params.pane, params.caller);
         const session = await this.#paneByContext(params.pane);
         if (!session) throw Object.assign(new Error(`no pane with context ${params.pane}`), { code: 404 });
         if (this.suspended.has(params.pane)) throw Object.assign(new Error(`pane ${params.pane} is suspended: remote input is refused until resume`), { code: 423 });

package/package.json

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