@volter/supercode-teams 0.2.33 → 0.2.35

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 supercode contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/fleet.mjs

@@ -83,6 +83,8 @@ async function main() {
           cwd: flags.cwd,
           initialInput: flags.input,
           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 } : {}),
         }));
       } finally {
         channel.close();

package/bin/workspace/args.mjs

@@ -11,7 +11,7 @@ const VALUES = new Set([
   'out', 'ttl', 'type', 'name', 'visibility', 'backfill', 'format', 'to',
   'grant', 'binding', 'caps', 'fidelity', 'cwd', 'root', 'workspace-from', 'since', 'until', 'session',
   'on', 'timeout', 'plan', 'tmux-socket', 'volter-issuer', 'delegated-issuer', 'workplace', 'organization', 'key', 'room',
-  'conversation', 'rh2',
+  'conversation', 'rh2', 'scope',
 ]);
 
 export function parseArgs(argv) {

package/bin/workspace.mjs

@@ -721,7 +721,8 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     const daemonHome = teamsHome();
     const hostKeyId = publicKeyId(loadOrCreateKeyPair(paths(daemonHome).machineKey).publicKeyPem);
     const connector = new TeamsConnector({ server: context.origin, teamId: context.team_id, machineId: saved.machine.id, sourceId: saved.source.id, credential: saved.credential.token, stateDir: state.directory, core, hostKeyId });
-    const machine = new TeamsMachine({ home: daemonHome, supercode: binary, ...(flags.tmux_socket ? { tmuxSocket: String(flags.tmux_socket) } : {}), link: { server: context.origin, teamId: context.team_id, machineId: saved.machine.id, credential: saved.credential.token, incarnationId: connector.state.incarnation_id, configuration: () => connector.configuration() } });
+    // A connected machine is a person's: each pane it launches opens a window on its screen (SUPERCODE_POPUPS=0: none).
+    const machine = new TeamsMachine({ home: daemonHome, supercode: binary, popups: process.env.SUPERCODE_POPUPS !== '0', ...(flags.tmux_socket ? { tmuxSocket: String(flags.tmux_socket) } : {}), link: { server: context.origin, teamId: context.team_id, machineId: saved.machine.id, credential: saved.credential.token, incarnationId: connector.state.incarnation_id, configuration: () => connector.configuration() } });
     machine.on('link', (event) => { if (event.event === 'replaced') process.stderr.write(`supercode teams: ${event.error}. Two connectors were running for this machine; stop one of them (\`supercode teams disconnect\` where it should not run).\n`); });
     const stopAll = async () => { await machine.stop().catch(() => {}); await connector.stop(); await core.close(); await lifecycle.close(); state.update(current => current ? ({ ...current, process: undefined }) : null); };
     try { await connector.start({ roots: () => saved.roots }); await machine.start(); } catch (error) { await stopAll(); throw error; }
@@ -758,7 +759,7 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
  * `--workplace-only`. `unpublish --record-only` deletes the record here and leaves the workplace alone.
  */
 async function publishCommand(verb, sub, { flags, rest, output, context, team, client, home, env }) {
-  only(flags, ['json', 'help', 'context', 'room', 'workplace', 'organization', 'name', 'key', 'machine', 'token_stdin', 'record_only', 'workplace_only']);
+  only(flags, ['json', 'help', 'context', 'room', 'workplace', 'organization', 'name', 'key', 'machine', 'token_stdin', 'record_only', 'workplace_only', 'scope']);
   const recordOnly = Boolean(flags.record_only);
   if (!flags.room || !flags.workplace || (!recordOnly && !flags.organization)) usage(`teams ${verb} needs --room ROOM --workplace ORIGIN --organization ORG`);
   const workplace = new URL(flags.workplace).origin;
@@ -807,7 +808,9 @@ async function publishCommand(verb, sub, { flags, rest, output, context, team, c
   const key = flags.key ?? `${sub === 'pane' ? 'pane' : 'folder'}-${label.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48) || createHash('sha256').update(target).digest('hex').slice(0, 8)}`;
   const kind = sub === 'pane' ? 'pane' : 'folder';
   const existed = (await recorded()).some(item => item.target === target && item.workplace === workplace && item.room === flags.room);
-  const publication = (await client.request('POST', publications, { body: { kind, target, workplace, room: flags.room, surface_key: key } })).data;
+  // --scope view caps what the workplace's tokens can open the surface as (they can watch it, not drive it).
+  if (flags.scope !== undefined && flags.scope !== 'view' && flags.scope !== 'control') usage('--scope must be view or control');
+  const publication = (await client.request('POST', publications, { body: { kind, target, workplace, room: flags.room, surface_key: key, ...(flags.scope ? { max_scope: flags.scope } : {}) } })).data;
   if (recordOnly) return output({ version: 1, context: scope(context), data: { publication } });
   let payload;
   try {
@@ -913,7 +916,7 @@ function printHelp() {
   login [ORIGIN] [--team TEAM] [--as CONTEXT] [--token-stdin|--invite-stdin]   (Volter sign-in in the browser by default)
   identity link
   server start [--volter-issuer ORIGIN] [--delegated-issuer ORIGIN]
-  publish pane|root TARGET --room ROOM --workplace ORIGIN --organization ORG [--name] [--key] [--machine] [--token-stdin] [--record-only]
+  publish pane|root TARGET --room ROOM --workplace ORIGIN --organization ORG [--scope view|control] [--name] [--key] [--machine] [--token-stdin] [--record-only]
   unpublish SURFACE --room ROOM --workplace ORIGIN --organization ORG [--machine] [--token-stdin] [--record-only|--workplace-only]
   connect|disconnect|status
   members invite|list|remove|role

package/machine.mjs

@@ -29,7 +29,7 @@ import { EventEmitter } from 'node:events';
 import { readFileSync, writeFileSync, writeSync, statSync, readdirSync, mkdirSync, renameSync, rmSync, existsSync, openSync, readSync, closeSync } from 'node:fs';
 import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { hostname } from 'node:os';
+import { homedir, hostname } from 'node:os';
 import { randomBytes, createHash } from 'node:crypto';
 import { WebSocket } from 'ws';
 import { TmuxTerminalHost, classifyAttentionSignal, composerHoldsDraft, composerReadyForInput } from '@volter/supercode-terminal';
@@ -67,16 +67,64 @@ const COMPOSER_RECHECK_MS = 400;
  *  must have stopped changing for this long before the pane counts as ready. */
 const INITIAL_INPUT_SETTLE_MS = 1_000;
 
+/** The WezTerm this machine has, on PATH or where its installer puts it, or null. */
+function weztermProgram() {
+  const candidates = process.platform === 'win32'
+    ? [join(process.env.ProgramFiles ?? 'C:\\Program Files', 'WezTerm', 'wezterm.exe')]
+    : ['/opt/homebrew/bin/wezterm', '/usr/local/bin/wezterm', '/Applications/WezTerm.app/Contents/MacOS/wezterm', '/usr/bin/wezterm'];
+  const onPath = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['wezterm'], { encoding: 'utf8', timeout: 3_000 });
+  const found = onPath.status === 0 ? onPath.stdout.split(/\r?\n/).map((line) => line.trim()).find(Boolean) : null;
+  return found ?? candidates.find((path) => existsSync(path)) ?? null;
+}
+
+/** How long a launch watches its new pane before answering, so a program that ends at once is reported. */
+const LAUNCH_SETTLE_MS = 500;
+
+/**
+ * What a pane runs for a launch: the program with its arguments, or, when the caller named a whole command line
+ * as the program (`open --new "npm run build"`), that line through this machine's own shell, so a caller on
+ * another machine need not know which shell or platform this one has.
+ */
+function launchCommand(program, args) {
+  const line = typeof program === 'string' ? program.trim() : '';
+  if (!args.length && /\s/.test(line) && !existsSync(line)) {
+    return process.platform === 'win32'
+      ? { program: 'powershell.exe', arguments: ['-NoProfile', '-Command', line] }
+      : { program: process.env.SHELL || '/bin/sh', arguments: ['-lc', line] };
+  }
+  return { program, arguments: args };
+}
+
+/**
+ * How a pane that is gone ended, from the pane-exit log its tmux server's hooks write (under SUPERCODE_HOME, or the
+ * user's ~/.config/supercode when the server's environment has none): { failed, how } or null when nothing is
+ * recorded. A pane that failed has a `died` line with its status or signal; one that ended cleanly only `closed`.
+ */
+function paneExit(pane) {
+  const logs = [process.env.SUPERCODE_HOME, join(homedir(), '.config', 'supercode')].filter(Boolean).map((dir) => join(dir, 'pane-exits.log'));
+  for (const log of logs) {
+    let lines;
+    try { lines = readFileSync(log, 'utf8').split('\n'); } catch { continue; }
+    const died = lines.findLast((entry) => entry.includes(` ${pane} died `));
+    const match = died && /status=(\d*) signal=(\S*)/.exec(died);
+    if (match) return { failed: true, how: match[1] ? `status ${match[1]}` : match[2] ? `signal ${match[2]}` : 'failed' };
+    if (lines.some((entry) => entry.endsWith(` ${pane} closed`))) return { failed: false, how: 'status 0' };
+  }
+  return null;
+}
+
 export class TeamsMachine extends MachineCore {
   /**
    * `link`: { server, teamId, machineId, credential, incarnationId, configuration } to hold the
    * server link; `configuration()` resolves the machine's current configuration from the server
    * (custodian and machine grants). Without it the daemon serves its local door only.
    */
-  constructor({ home = teamsHome(), supercode = 'supercode', tmuxSocket, floor = null, limits = null, env = process.env, link = null } = {}) {
+  constructor({ home = teamsHome(), supercode = 'supercode', tmuxSocket, floor = null, limits = null, env = process.env, link = null, popups = false } = {}) {
     super({ home, floor, limits, env, link });
     this.supercodeBin = supercode;
     this.tmuxSocket = tmuxSocket ?? null;
+    // Each pane launched here opens a terminal window on this machine's screen (popupWindow).
+    this.popups = Boolean(popups);
     this.launches = new Launches(this.p.launches);
     // Windows has no tmux: its panes are ConPTY children of this daemon, and end with it.
     if (process.platform === 'win32' && !terminal.PtyTerminalHost) throw new Error('panes on Windows need a newer @volter/supercode-terminal (one with PtyTerminalHost)');
@@ -627,6 +675,26 @@ export class TeamsMachine extends MachineCore {
 
   listPorts() { return listAnnouncedPorts(this.portsDir); }
 
+  /**
+   * A terminal window on this machine's screen showing the pane, so the people at the machine see what runs on it.
+   * WezTerm runs one process per window (`start --always-new-process`) with an attach client in it: the pane ending
+   * ends the client and the window closes, and a person closing the window ends only the client, never the pane (the
+   * pane lives in tmux, or in this daemon's ConPTY host on Windows). No OS automation permission is involved. Without
+   * WezTerm there is no window, as before.
+   */
+  #popupWindow(contextKey, session) {
+    const wezterm = weztermProgram();
+    if (!wezterm) return;
+    const attach = process.platform === 'win32'
+      ? [process.execPath, fileURLToPath(new URL('./bin/fleet.mjs', import.meta.url)), 'attach', contextKey, '--mode', 'control']
+      : ['tmux', ...(this.tmuxSocket ? ['-L', this.tmuxSocket] : []), 'attach-session', '-t', session.label ?? contextKey];
+    try {
+      const child = spawn(wezterm, ['start', '--always-new-process', '--', ...attach], { detached: true, stdio: 'ignore', env: { ...this.env, TMUX: '' } });
+      child.on('error', () => {});
+      child.unref();
+    } catch { /* no window; the pane runs regardless */ }
+  }
+
   /**
    * Rename the tmux window behind an owned pane. The terminal host exposes
    * no rename, so this is `tmux` on the host's own socket; automatic-rename is
@@ -939,7 +1007,7 @@ export class TeamsMachine extends MachineCore {
         let session;
         try {
           session = await this.host.createSession({
-            command: { program: params.program, arguments: params.arguments ?? [] },
+            command: launchCommand(params.program, params.arguments ?? []),
             contextKey,
             cwd: params.cwd,
             env: this.#paneEnv(contextKey, params.env),
@@ -961,6 +1029,17 @@ export class TeamsMachine extends MachineCore {
         // 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 });
+        // 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));
+        if (!await this.#paneByContext(contextKey)) {
+          // Finished (it ran to a clean end) is an answer; exited (it failed at once) is the caller's error.
+          const exit = 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 });
+          return { key, pane: contextKey, reused: false, status, exit: exit?.how ?? null };
+        }
+        if (this.popups && params.popup !== false) this.#popupWindow(contextKey, session);
         return { key, pane: contextKey, reused: false, status: 'ready' };
       }
       case 'launches.get': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.33",
+  "version": "0.2.35",
   "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",
@@ -39,6 +39,7 @@
     "supercode-teams-fleet": "./bin/fleet.mjs"
   },
   "files": [
+    "LICENSE-MIT",
     "*.mjs",
     "workspace-client.d.ts",
     "porthole-hook.cjs",