@volter/supercode-teams 0.2.34 → 0.2.36

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.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; }

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';
@@ -45,6 +45,7 @@ import { fingerprint, signBytes, canonical } from '@volter/teams/identity';
 import { teamsHome, paths, readJson, writeJson, Launches } from '@volter/teams/home';
 import { request as httpRequest } from 'node:http';
 import { DEFAULT_RANK, normalizeRank, judge } from './attention.mjs';
+import { popupTerminal, openPopup } from './popup-terminals.mjs';
 import { JobOwner, executionCapabilities, streamProgram, serveWorkspace } from './execution.mjs';
 
 /** The preload every launched pane carries: it announces the ports a pane's node processes listen on. */
@@ -67,16 +68,54 @@ 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;
 
+/** 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 +666,20 @@ 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:
+   * in whichever capable terminal is installed (popup-terminals.mjs), running an attach client. The pane ending ends
+   * the client and the window closes; a person closing the window ends only the client, never the pane.
+   */
+  #popupWindow(contextKey, session) {
+    const terminal = popupTerminal(this.env);
+    if (!terminal) return;
+    const attach = process.platform === 'win32'
+      ? [process.execPath, fileURLToPath(new URL('./bin/fleet.mjs', import.meta.url)), 'attach', contextKey, '--mode', 'control']
+      : [spawnSync('which', ['tmux'], { encoding: 'utf8' }).stdout.trim() || 'tmux', ...(this.tmuxSocket ? ['-L', this.tmuxSocket] : []), 'attach-session', '-t', session.label ?? contextKey];
+    openPopup(terminal, attach, { ...this.env, TMUX: '' });
+  }
+
   /**
    * 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 +992,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 +1014,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.34",
+  "version": "0.2.36",
   "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/popup-terminals.mjs

@@ -0,0 +1,81 @@
+// The terminal a pane's window opens in: whichever capable terminal this machine has. Each adapter opens a new window
+// running one command (the pane's attach client) through the terminal's own launch interface: never AppleScript, so
+// no automation permission is asked for. Closing the window ends only the attach client, never the pane (tmux, or the
+// daemon's ConPTY host on Windows, holds it); the pane ending ends the client, and the terminal closes the window as
+// its command exits. Adapters are tried in rank order; SUPERCODE_POPUP_TERMINAL names one (or `none`).
+import { spawn, spawnSync } from 'node:child_process';
+import { chmodSync, existsSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+
+const onPath = (name) => {
+  const found = spawnSync(process.platform === 'win32' ? 'where' : 'which', [name], { encoding: 'utf8', timeout: 3_000 });
+  return found.status === 0 ? found.stdout.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? null : null;
+};
+const firstPath = (...paths) => paths.find((path) => path && existsSync(path)) ?? null;
+const programFiles = process.env.ProgramFiles ?? 'C:\\Program Files';
+const localApps = process.env.LOCALAPPDATA ?? '';
+
+/** A shell script that deletes itself and then becomes `argv`: what a terminal opened on a file runs. */
+function selfDeletingScript(argv, extension) {
+  const path = join(tmpdir(), `supercode-pane-${randomBytes(6).toString('hex')}${extension}`);
+  const quoted = argv.map((arg) => `'${String(arg).replaceAll("'", `'"'"'`)}'`).join(' ');
+  writeFileSync(path, `#!/bin/sh\nrm -f -- "$0"\nexec ${quoted}\n`);
+  chmodSync(path, 0o700);
+  return path;
+}
+
+/** Adapters by platform, in rank order: { name, find() → program or null, launch(program, argv) → [command, args] }. */
+const ADAPTERS = {
+  darwin: [
+    { name: 'wezterm', find: () => onPath('wezterm') ?? firstPath('/Applications/WezTerm.app/Contents/MacOS/wezterm'), launch: (p, argv) => [p, ['start', '--always-new-process', '--', ...argv]] },
+    { name: 'kitty', find: () => onPath('kitty') ?? firstPath('/Applications/kitty.app/Contents/MacOS/kitty'), launch: (p, argv) => [p, argv] },
+    { name: 'ghostty', find: () => firstPath('/Applications/Ghostty.app'), launch: (p, argv) => ['open', ['-na', p, '--args', '-e', ...argv]] },
+    { name: 'alacritty', find: () => onPath('alacritty') ?? firstPath('/Applications/Alacritty.app/Contents/MacOS/alacritty'), launch: (p, argv) => [p, ['-e', ...argv]] },
+    // iTerm2 and Terminal run a script file they are asked to open: a plain `open`, not a scripting bridge.
+    { name: 'iterm2', find: () => firstPath('/Applications/iTerm.app'), launch: (p, argv) => ['open', ['-a', p, selfDeletingScript(argv, '.command')]] },
+    { name: 'terminal', find: () => firstPath('/System/Applications/Utilities/Terminal.app', '/Applications/Utilities/Terminal.app'), launch: (p, argv) => ['open', ['-a', p, selfDeletingScript(argv, '.command')]] },
+  ],
+  win32: [
+    { name: 'wezterm', find: () => onPath('wezterm') ?? firstPath(join(programFiles, 'WezTerm', 'wezterm.exe')), launch: (p, argv) => [p, ['start', '--always-new-process', '--', ...argv]] },
+    { name: 'alacritty', find: () => onPath('alacritty') ?? firstPath(join(programFiles, 'Alacritty', 'alacritty.exe')), launch: (p, argv) => [p, ['-e', ...argv]] },
+    { name: 'windows-terminal', find: () => onPath('wt') ?? firstPath(join(localApps, 'Microsoft', 'WindowsApps', 'wt.exe')), launch: (p, argv) => [p, ['-w', 'new', 'new-tab', '--', ...argv]] },
+    // A console window of its own, on every Windows: it lives exactly as long as its command.
+    { name: 'conhost', find: () => firstPath(join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'conhost.exe')), launch: (p, argv) => [p, argv] },
+  ],
+  linux: [
+    { name: 'wezterm', find: () => onPath('wezterm'), launch: (p, argv) => [p, ['start', '--always-new-process', '--', ...argv]] },
+    { name: 'kitty', find: () => onPath('kitty'), launch: (p, argv) => [p, argv] },
+    { name: 'ghostty', find: () => onPath('ghostty'), launch: (p, argv) => [p, ['-e', ...argv]] },
+    { name: 'alacritty', find: () => onPath('alacritty'), launch: (p, argv) => [p, ['-e', ...argv]] },
+    { name: 'xterm', find: () => onPath('xterm'), launch: (p, argv) => [p, ['-e', ...argv]] },
+  ],
+};
+
+/** The terminal a window opens in here: the one SUPERCODE_POPUP_TERMINAL names, else the best installed; or null. */
+export function popupTerminal(env = process.env, platform = process.platform) {
+  const adapters = ADAPTERS[platform] ?? [];
+  const wanted = env.SUPERCODE_POPUP_TERMINAL?.trim().toLowerCase();
+  if (wanted === 'none') return null;
+  // A display to show a window on: macOS and Windows always have one for a signed-in user; Linux needs X or Wayland.
+  if (platform === 'linux' && !env.DISPLAY && !env.WAYLAND_DISPLAY) return null;
+  for (const adapter of wanted ? adapters.filter((item) => item.name === wanted) : adapters) {
+    const program = adapter.find();
+    if (program) return { name: adapter.name, program, launch: (argv) => adapter.launch(program, argv) };
+  }
+  return null;
+}
+
+/** Opens a window running `argv` in `terminal` (from popupTerminal). Best effort: the pane runs whatever happens here. */
+export function openPopup(terminal, argv, env) {
+  try {
+    const [command, args] = terminal.launch(argv);
+    const child = spawn(command, args, { detached: true, stdio: 'ignore', env, windowsHide: false });
+    child.on('error', () => {});
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}