@volter/supercode-teams 0.2.35 → 0.2.37

package/connector/index.mjs

@@ -151,7 +151,13 @@ export class TeamsConnector {
       if (running || this.abort.signal.aborted) return null;
       running = true;
       const run = (async () => { this.localRoots = await roots(); await pass(); })();
-      void run.catch(error => { this.lastError = error; }).finally(() => { running = false; });
+      // A pass that fails is said in the connector's log (once per distinct failure): nothing syncs until it passes.
+      void run.catch(error => {
+        this.lastError = error;
+        const said = `${error?.code ?? ''} ${error?.message ?? error}`;
+        if (said !== this.lastPassFailure) process.stderr.write(`supercode teams: a sync pass failed: ${error?.message ?? error}\n`);
+        this.lastPassFailure = said;
+      }).then(() => { if (run && !this.lastError) this.lastPassFailure = null; }).finally(() => { running = false; });
       return run;
     };
     /** The first sync pass, for a caller that waits on it; the connector keeps running if it fails. */

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,14 +68,29 @@ 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;
+/**
+ * Claude asks whether to trust a folder it has not opened before, whatever its permission mode, and has no flag that
+ * skips the question; its default answer exits, taking the pane with it. A Claude this machine launches without
+ * prompts has its folder recorded as trusted in this machine's Claude config (`projects[<folder>]` in .claude.json,
+ * keyed as Claude keys it: the real path, with forward slashes on Windows), as a Codex launch has its trust passed on
+ * its command line. A whole new file is renamed over the old one, since Claude rewrites it while it runs.
+ */
+function trustClaudeFolder(cwd) {
+  try {
+    const config = join(process.env.CLAUDE_CONFIG_DIR || homedir(), '.claude.json');
+    const real = realpathSync(cwd);
+    const folder = process.platform === 'win32' ? real.replace(/^\\\\\?\\/, '').replaceAll('\\', '/') : real;
+    let root = {};
+    try { root = JSON.parse(readFileSync(config, 'utf8')); } catch (error) { if (error.code !== 'ENOENT') return; }
+    if (!root || typeof root !== 'object' || Array.isArray(root)) return;
+    const projects = root.projects ??= {};
+    const project = projects[folder] ??= {};
+    if (project.hasTrustDialogAccepted === true) return;
+    project.hasTrustDialogAccepted = true;
+    const staged = `${config}.supercode-${process.pid}`;
+    writeFileSync(staged, JSON.stringify(root, null, 2));
+    renameSync(staged, config);
+  } catch { /* Claude asks as it always did */ }
 }
 
 /** How long a launch watches its new pane before answering, so a program that ends at once is reported. */
@@ -362,9 +378,10 @@ export class TeamsMachine extends MachineCore {
     // receiver named rather than addressed needs `mail:*`.
     const { admitted, principal } = entry;
     const request = stream.params?.request;
+    if (request?.op === 'turn') return this.#serveTurn(entry, request, stream, accept, refuse);
     const to = typeof request?.to === 'string' ? request.to : '*';
     const target = to.startsWith('sc:') ? `mail:${to}` : 'mail:*';
-    if (!request || !['send', 'file', 'list'].includes(request.op)) return refuse('mail needs a send, file or list request');
+    if (!request || !['send', 'file', 'list'].includes(request.op)) return refuse('mail needs a send, file, list or turn request');
     if (!holds(admitted, 'mail', target)) {
       this.log.append({ principal, cap: 'mail', target, outcome: 'refused' });
       return refuse(`no mail grant for ${target}`);
@@ -386,6 +403,37 @@ export class TeamsMachine extends MachineCore {
     child.stdin.end(JSON.stringify({ ...request, via_principal: principal ?? null }));
   }
 
+  #serveTurn(entry, request, stream, accept, refuse) {
+    // A person's line typed into one session here as that session's own user turn (a Room member in a Conversation
+    // bound to the session): `interact` on `session:<harness>/<id>`. Who typed it comes from the caller's claim
+    // (the name its workplace signed), never from the request.
+    const { admitted, principal } = entry;
+    // A caller the server admitted for one session (a Room member's token) names nothing: its grant names the session.
+    const granted = admitted?.class === 'operator' ? [] : (admitted?.grants ?? []).filter((grant) => grant.caps.includes('interact')).flatMap((grant) => grant.targets).filter((target) => target.startsWith('session:') && target !== 'session:*');
+    const named = typeof request.harness === 'string' && typeof request.session === 'string' ? `${request.harness}/${request.session}` : (granted.length === 1 ? granted[0].slice('session:'.length) : '');
+    const [harness, session] = named.includes('/') ? [named.slice(0, named.indexOf('/')), named.slice(named.indexOf('/') + 1)] : ['', ''];
+    const target = `session:${harness}/${session}`;
+    if (!harness || !session || typeof request.text !== 'string' || !request.text.trim()) return refuse('a turn needs harness, session and text');
+    if (!holds(admitted, 'interact', target)) {
+      this.log.append({ principal, cap: 'interact', target, outcome: 'refused' });
+      return refuse(`no interact grant for ${target}`);
+    }
+    accept();
+    const child = spawn(this.supercodeBin, ['message', 'remote-deliver'], { stdio: ['pipe', 'pipe', 'pipe'], env: this.env });
+    let out = '';
+    let err = '';
+    child.stdout.on('data', (chunk) => { out += chunk; });
+    child.stderr.on('data', (chunk) => { err += chunk; });
+    child.on('error', (error) => { err += error.message; });
+    child.on('close', (code) => {
+      this.log.append({ principal, cap: 'interact', target, outcome: code === 0 ? 'turn' : 'failed', detail: err.trim().slice(0, 200) || undefined });
+      if (stream.closed) return;
+      stream.write(out.trim() || JSON.stringify({ code: 1, text: err.trim() || `remote-deliver exited ${code}` }));
+      stream.close('delivered');
+    });
+    child.stdin.end(JSON.stringify({ op: 'turn', harness, session, text: request.text, from_name: entry.name ?? principal ?? 'a Room member', via: 'room' }));
+  }
+
   // ---- terminal ------------------------------------------------------------
 
   async #attachTerminal(entry, stream, accept, refuse) {
@@ -676,23 +724,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: '' });
   }
 
   /**
@@ -1004,6 +1046,7 @@ export class TeamsMachine extends MachineCore {
         }
         const contextKey = params.pane ?? `p_${randomBytes(9).toString('base64url')}`;
         this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, status: 'issued' });
+        if (params.kind === 'claude-code' && params.cwd && (params.arguments ?? []).includes('--dangerously-skip-permissions')) trustClaudeFolder(params.cwd);
         let session;
         try {
           session = await this.host.createSession({

package/package.json

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