@volter/supercode-teams 0.2.35 → 0.2.36

package/machine.mjs

@@ -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,6 @@ 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;
 
@@ -676,23 +667,17 @@ 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.
+   * 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 wezterm = weztermProgram();
-    if (!wezterm) return;
+    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']
-      : ['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 */ }
+      : [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: '' });
   }
 
   /**

package/package.json

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