@phnx-labs/agents-cli 1.20.40 → 1.20.42

package/dist/lib/shims.js

@@ -211,7 +211,7 @@ async function promptConflictStrategy(conflictInfos) {
 // v22 — export DISABLE_AUTOUPDATER=1 for claude shims so a pinned per-version
 //        install can't self-mutate: Claude Code's background auto-updater would
 //        otherwise rewrite the pinned binary in place. Explicit user value wins.
-export const SHIM_SCHEMA_VERSION = 23;
+export const SHIM_SCHEMA_VERSION = 24;
 /** Internal marker string used to embed the schema version in shim scripts. */
 const SHIM_VERSION_MARKER = 'agents-shim-version:';
 function shellQuote(value) {
@@ -346,16 +346,38 @@ find_project_version() {
   return 1
 }
 
-# Resolve version from agents.yaml (user default)
+# Parse the agents: default map of one agents.yaml for this AGENT's version.
+parse_agents_default() {
+  local meta="$1"
+  [ -f "$meta" ] || return 0
+  awk -v agent="$AGENT" '
+    /^agents:/ { in_agents=1; next }
+    in_agents && /^[^ ]/ { in_agents=0 }
+    in_agents && $0 ~ "^  " agent ":" { gsub(/.*:[[:space:]]*["'"'"']?|["'"'"']?[[:space:]]*$/, ""); print; exit }
+  ' "$meta"
+}
+
+# This machine's device id — mirrors machineId()/normalizeHost() in
+# src/lib/machine-id.ts: first hostname label, lowercased, non-[a-z0-9_-] -> '-'.
+# MUST stay in sync or the shim reads the wrong device folder.
+machine_id() {
+  local raw="\${AGENTS_SYNC_MACHINE_ID:-$(hostname 2>/dev/null)}"
+  # first label -> trim -> lowercase -> non-[a-z0-9_-] to '-' (matches normalizeHost order).
+  raw=$(printf '%s' "$raw" | cut -d. -f1 | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9_-]/-/g')
+  [ -n "$raw" ] && printf '%s' "$raw" || printf 'unknown'
+}
+
+# Resolve the default version. The agents: version pins are stored PER-DEVICE at
+# devices/<machine>/agents.yaml (moved there so multi-machine syncs never
+# conflict); read that first, then fall back to the central agents.yaml for
+# pre-split installs. Must match readMeta()'s central+device merge in state.ts --
+# reading only the central file (the old behavior) missed every device pin and
+# made the shim re-prompt "no default set" on every launch.
 resolve_default_version() {
-  local meta="$AGENTS_USER_DIR/agents.yaml"
-  if [ -f "$meta" ]; then
-    awk -v agent="$AGENT" '
-      /^agents:/ { in_agents=1; next }
-      in_agents && /^[^ ]/ { in_agents=0 }
-      in_agents && $0 ~ "^  " agent ":" { gsub(/.*:[[:space:]]*["'"'"']?|["'"'"']?[[:space:]]*$/, ""); print; exit }
-    ' "$meta"
-  fi
+  local v
+  v=$(parse_agents_default "$AGENTS_USER_DIR/devices/$(machine_id)/agents.yaml")
+  [ -n "$v" ] || v=$(parse_agents_default "$AGENTS_USER_DIR/agents.yaml")
+  printf '%s' "$v"
 }
 
 # Find the latest installed version by numeric component comparison.

package/dist/lib/ssh-tunnel.d.ts

@@ -47,7 +47,7 @@ export declare function startSSHTunnel(user: string, host: string, localPort: nu
 export declare const REMOTE_HELPER_PORT = 8765;
 /** Task Scheduler task name for the daemon. Stable so setup/stop pair up. */
 export declare const REMOTE_TASK_NAME = "AgentsComputerHelper";
-/** Basename of the cross-published exe under packages/computer-helper-win/dist. */
+/** Basename of the cross-published exe under native/computer-win/dist. */
 export declare const WIN_HELPER_EXE = "computer-helper-win.exe";
 /**
  * Locate the cross-published Windows daemon exe. Only the local build output is

package/dist/lib/ssh-tunnel.js

@@ -86,7 +86,7 @@ export function startSSHTunnel(user, host, localPort, remotePort, opts = {}) {
 export const REMOTE_HELPER_PORT = 8765;
 /** Task Scheduler task name for the daemon. Stable so setup/stop pair up. */
 export const REMOTE_TASK_NAME = 'AgentsComputerHelper';
-/** Basename of the cross-published exe under packages/computer-helper-win/dist. */
+/** Basename of the cross-published exe under native/computer-win/dist. */
 export const WIN_HELPER_EXE = 'computer-helper-win.exe';
 /**
  * Locate the cross-published Windows daemon exe. Only the local build output is
@@ -95,8 +95,8 @@ export const WIN_HELPER_EXE = 'computer-helper-win.exe';
 export function resolveWinHelperExe() {
     const here = path.dirname(fileURLToPath(import.meta.url));
     const candidates = [
-        // Running from the agents-cli checkout (src/lib -> repo root).
-        path.resolve(here, '..', '..', 'packages', 'computer-helper-win', 'dist', WIN_HELPER_EXE),
+        // Running from the agents-cli checkout. apps/cli/dist/lib -> repo root (4 up) -> native/computer-win.
+        path.resolve(here, '..', '..', '..', '..', 'native', 'computer-win', 'dist', WIN_HELPER_EXE),
         // Bundled with the npm package (dist/lib -> package root).
         path.resolve(here, '..', 'computer-helper-win', WIN_HELPER_EXE),
     ];

package/dist/lib/tmux/session.d.ts

@@ -22,6 +22,13 @@ export interface SessionMeta {
     source: 'cli' | 'extension' | 'teams' | 'external';
     /** Free-form labels callers can stamp (e.g. `{ agent: 'claude', vscodePid: 1234 }`). */
     labels?: Record<string, string>;
+    /**
+     * The first pane's id (`%N`) captured at creation. The exact send-keys /
+     * attach handle for the agent that runs in this session — recorded so
+     * `agents sessions --active` and the spawn-wrap path (src/lib/exec.ts) don't
+     * have to re-query it. Absent for pre-existing/`attach-existing` sessions.
+     */
+    pane?: string;
 }
 export interface CreateSessionOptions {
     name: string;
@@ -80,6 +87,45 @@ export declare function killAll(socket?: string): Promise<number>;
  * failure (tmux gone, foreign socket) so callers fall back to the raw pane id.
  */
 export declare function mapPanesToTargets(socket?: string): Promise<Map<string, string>>;
+/** One tmux client attached to the shared server. */
+export interface TmuxClient {
+    /** Controlling TTY of the terminal running `tmux attach` (e.g. '/dev/ttys004'). */
+    tty: string;
+    /** PID of the `tmux attach` client process — the leaf whose ancestry names the host app. */
+    pid: number;
+    /** The `session:window.pane` the client is currently displaying. */
+    target: string;
+}
+/**
+ * List every client attached to the shared server, with the terminal PID and
+ * the session/window/pane it's viewing. This is how "viewing in <app> tab N"
+ * resolves: a client's `pid` walks the process ancestry to name the host app,
+ * and its `target` says which session it's attached to. Best-effort — returns
+ * an empty list on any failure (no server, foreign socket) so the renderer
+ * degrades to "detached".
+ */
+export declare function listClients(socket?: string): Promise<TmuxClient[]>;
+/** A dead pane's exit status, read from tmux while the pane lingers under remain-on-exit. */
+export interface PaneExit {
+    /** True once the process that ran in the pane has exited (pane is dead). */
+    dead: boolean;
+    /** Exit status of the dead pane's process, when tmux reports it. */
+    status?: number;
+}
+/**
+ * Read whether a pane's process has exited and, if so, its exit status. Used by
+ * the spawn-wrap path to recover the wrapped agent's exit code after the attach
+ * client returns. Returns `{ dead: false }` when tmux can't answer (session gone,
+ * pane missing) so the caller treats an unreadable pane as "still alive / detach".
+ */
+export declare function paneExitStatus(pane: string, socket?: string): Promise<PaneExit>;
+/**
+ * Bind a per-session hook. Used by the spawn-wrap path to install a `pane-died`
+ * hook that detaches the attach client the instant the wrapped agent exits (the
+ * global `remain-on-exit on` otherwise leaves the client staring at a dead pane).
+ * Best-effort — a failed hook just means the user Ctrl-b d's out manually.
+ */
+export declare function setSessionHook(name: string, hook: string, command: string, socket?: string): Promise<void>;
 /**
  * List live sessions on the socket. Reconciles meta JSONs against tmux's view:
  *  - tmux session with no meta → returned without `meta` (external session)

package/dist/lib/tmux/session.js

@@ -76,7 +76,9 @@ export async function createSession(opts) {
     // exit the server, and the follow-up `set-option` would race with "no
     // server running". Server-wide (`-g`) is applied in the same tmux
     // invocation as new-session so they share one server lifetime.
-    const args = ['set-option', '-g', 'remain-on-exit', 'on', ';', 'new-session', '-d', '-s', opts.name];
+    // `-P -F '#{pane_id}'` prints the new session's first pane id on stdout so we
+    // can record the exact `%N` handle without a follow-up `list-panes`.
+    const args = ['set-option', '-g', 'remain-on-exit', 'on', ';', 'new-session', '-d', '-s', opts.name, '-P', '-F', '#{pane_id}'];
     if (opts.width)
         args.push('-x', String(opts.width));
     if (opts.height)
@@ -88,7 +90,9 @@ export async function createSession(opts) {
     if (opts.cmd) {
         args.push('--', 'sh', '-c', opts.cmd);
     }
-    await runTmux({ socket, args, env: opts.env });
+    const res = await runTmux({ socket, args, env: opts.env });
+    // Only the new-session command in the `;`-chained invocation emits output.
+    const pane = /^%\d+$/.test(res.stdout.trim()) ? res.stdout.trim() : undefined;
     const meta = {
         name: opts.name,
         socket,
@@ -97,6 +101,7 @@ export async function createSession(opts) {
         cwd: opts.cwd,
         source: opts.source ?? 'cli',
         labels: opts.labels,
+        pane,
     };
     writeSessionMeta(meta);
     return meta;
@@ -187,6 +192,83 @@ export async function mapPanesToTargets(socket) {
     }
     return out;
 }
+/**
+ * List every client attached to the shared server, with the terminal PID and
+ * the session/window/pane it's viewing. This is how "viewing in <app> tab N"
+ * resolves: a client's `pid` walks the process ancestry to name the host app,
+ * and its `target` says which session it's attached to. Best-effort — returns
+ * an empty list on any failure (no server, foreign socket) so the renderer
+ * degrades to "detached".
+ */
+export async function listClients(socket) {
+    let res;
+    try {
+        res = await runTmux({
+            socket,
+            args: ['list-clients', '-F', '#{client_tty} #{client_pid} #{session_name}:#{window_index}.#{pane_index}'],
+            throwOnError: false,
+        });
+    }
+    catch {
+        return [];
+    }
+    if (res.code !== 0)
+        return [];
+    const out = [];
+    for (const line of res.stdout.split('\n')) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        const sp1 = t.indexOf(' ');
+        if (sp1 < 0)
+            continue;
+        const sp2 = t.indexOf(' ', sp1 + 1);
+        if (sp2 < 0)
+            continue;
+        const tty = t.slice(0, sp1);
+        const pid = parseInt(t.slice(sp1 + 1, sp2), 10);
+        const target = t.slice(sp2 + 1).trim();
+        if (!Number.isFinite(pid) || !target)
+            continue;
+        out.push({ tty, pid, target });
+    }
+    return out;
+}
+/**
+ * Read whether a pane's process has exited and, if so, its exit status. Used by
+ * the spawn-wrap path to recover the wrapped agent's exit code after the attach
+ * client returns. Returns `{ dead: false }` when tmux can't answer (session gone,
+ * pane missing) so the caller treats an unreadable pane as "still alive / detach".
+ */
+export async function paneExitStatus(pane, socket) {
+    let res;
+    try {
+        res = await runTmux({
+            socket,
+            args: ['display-message', '-pt', pane, '-p', '#{pane_dead} #{pane_dead_status}'],
+            throwOnError: false,
+        });
+    }
+    catch {
+        return { dead: false };
+    }
+    if (res.code !== 0)
+        return { dead: false };
+    const [deadRaw, statusRaw] = res.stdout.trim().split(/\s+/);
+    const status = statusRaw !== undefined && statusRaw !== '' ? parseInt(statusRaw, 10) : undefined;
+    return { dead: deadRaw === '1', status: Number.isFinite(status) ? status : undefined };
+}
+/**
+ * Bind a per-session hook. Used by the spawn-wrap path to install a `pane-died`
+ * hook that detaches the attach client the instant the wrapped agent exits (the
+ * global `remain-on-exit on` otherwise leaves the client staring at a dead pane).
+ * Best-effort — a failed hook just means the user Ctrl-b d's out manually.
+ */
+export async function setSessionHook(name, hook, command, socket) {
+    assertValidSessionName(name);
+    const sock = socket ?? getDefaultSocketPath();
+    await runTmux({ socket: sock, args: ['set-hook', '-t', name, hook, command], throwOnError: false }).catch(() => { });
+}
 /**
  * List live sessions on the socket. Reconciles meta JSONs against tmux's view:
  *  - tmux session with no meta → returned without `meta` (external session)

package/dist/lib/types.d.ts

@@ -599,9 +599,9 @@ export interface Meta {
     run?: RunConfig;
     /** macOS secrets-agent config. `policy` is the default prompt policy for
      * bundles without an explicit per-bundle policy: `daily` (the default) asks
-     * once per ~24h, `always` asks every time. `auto` (default on) lets the first
-     * real keychain read of a `daily` bundle populate the broker so concurrent
-     * runs read silently — set it `false` to force a prompt on every read. */
+     * once per ~7 days, `always` asks every time. `auto` (default on) lets the
+     * first real keychain read of a `daily` bundle populate the broker so
+     * concurrent runs read silently — set it `false` to force a prompt on every read. */
     secrets?: {
         policy?: 'always' | 'daily';
         agent?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.40",
+  "version": "1.20.42",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",