@volter/supercode-teams 0.2.34 → 0.2.35

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';
@@ -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.34",
+  "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",