@phnx-labs/agents-cli 1.22.103 → 1.22.104

package/dist/lib/sha256-asset.js

@@ -2,7 +2,8 @@
  * sha256 helpers for verifying downloaded release assets.
  *
  * These live in their own LEAF module — importing only `node:crypto` and
- * `node:fs` — on purpose. They used to sit in `computer/ssh-tunnel.ts`, whose
+ * `node:fs` — on purpose. They used to sit in the computer subsystem's ssh-tunnel
+ * module (since extracted, PHNX-4075), whose
  * own import graph reached `browser/drivers/ssh.ts` -> `browser/chrome.ts` ->
  * the in-repo secrets engine's own keychain-helper downloader, which imported
  * back into `helper-download.ts` while it was still evaluating — before

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

@@ -0,0 +1,61 @@
+/**
+ * ssh-tunnel.ts — the generic `ssh -L localPort:127.0.0.1:remotePort -N`
+ * port-forward, plus the fleet-device resolution that names its far end.
+ *
+ * WHY IT LIVES HERE. These primitives used to sit in `lib/computer/ssh-tunnel.ts`
+ * alongside the Windows computer-helper provisioning, because `agents computer
+ * --device` was their second caller after the browser CDP driver. The computer
+ * engine has since moved to the standalone `computer` CLI (PHNX-4075), so a
+ * generic tunnel parked in a deleted subsystem's directory would have gone with
+ * it and taken `agents browser`'s remote path down. It is fleet plumbing — the
+ * devices registry, the hardened ssh baseline, a local loopback port — and
+ * belongs in the fleet layer, not under a feature.
+ *
+ * Its callers are thin: `browser/drivers/ssh.ts` holds a tunnel for one CDP
+ * session, and `lib/computer/context.ts` uses `resolveRemoteDevice` alone —
+ * `agents computer --device` resolves the fleet name here and forwards the
+ * answer to the standalone engine, which opens and owns its own tunnel (it
+ * holds the helper token that tunnel's transport needs).
+ */
+import { type ChildProcess } from 'child_process';
+import { type DeviceProfile } from './devices/registry.js';
+export interface StartTunnelOptions {
+    extraSshArgs?: string[];
+}
+/** Build the ssh argv (after the `ssh` program name) for an `-L` tunnel. Pure.
+ *
+ * Composes the shared hardened baseline (`SSH_OPTS`) rather than re-listing it,
+ * so the tunnel inherits the same options — crucially the keepalive, which lets
+ * a dropped `-N` tunnel exit instead of lingering as a zombie on the laptop. */
+export declare function buildTunnelArgs(user: string, host: string, localPort: number, remotePort: number, extraSshArgs?: string[]): string[];
+/**
+ * Spawn `ssh -L localPort:127.0.0.1:remotePort -N user@host`.
+ *
+ * stderr is captured so a tunnel that dies inside 500ms rejects with the ssh
+ * error — the browser driver's original contract. The tunnel is held by this
+ * process for the lifetime of the session that opened it.
+ */
+export declare function startSSHTunnel(user: string, host: string, localPort: number, remotePort: number, opts?: StartTunnelOptions): Promise<ChildProcess>;
+/** One registered device, resolved to everything an ssh invocation needs. */
+export interface ResolvedRemoteDevice {
+    device: DeviceProfile;
+    target: string;
+    user: string;
+    host: string;
+    /** Per-device identity flags (`-i <key> -o IdentitiesOnly=yes`), possibly empty. */
+    identityArgs: string[];
+}
+/**
+ * Resolve a registered device to its ssh pieces, or throw a clear error.
+ *
+ * `expectPlatform` is how a caller keeps a platform requirement it used to
+ * hard-code: `agents computer --device` drives the Windows helper daemon, so it
+ * passes `'windows'` and gets the same refusal as before. Callers with no
+ * platform requirement (the browser driver) omit it. The gate is a parameter
+ * rather than a baked-in check so this module stays fleet-generic — a
+ * hard-coded `windows` here would be a feature rule in shared plumbing.
+ */
+export declare function resolveRemoteDevice(name: string, opts?: {
+    expectPlatform?: DeviceProfile['platform'];
+    forWhat?: string;
+}): Promise<ResolvedRemoteDevice>;

package/dist/lib/ssh-tunnel.js

@@ -0,0 +1,105 @@
+/**
+ * ssh-tunnel.ts — the generic `ssh -L localPort:127.0.0.1:remotePort -N`
+ * port-forward, plus the fleet-device resolution that names its far end.
+ *
+ * WHY IT LIVES HERE. These primitives used to sit in `lib/computer/ssh-tunnel.ts`
+ * alongside the Windows computer-helper provisioning, because `agents computer
+ * --device` was their second caller after the browser CDP driver. The computer
+ * engine has since moved to the standalone `computer` CLI (PHNX-4075), so a
+ * generic tunnel parked in a deleted subsystem's directory would have gone with
+ * it and taken `agents browser`'s remote path down. It is fleet plumbing — the
+ * devices registry, the hardened ssh baseline, a local loopback port — and
+ * belongs in the fleet layer, not under a feature.
+ *
+ * Its callers are thin: `browser/drivers/ssh.ts` holds a tunnel for one CDP
+ * session, and `lib/computer/context.ts` uses `resolveRemoteDevice` alone —
+ * `agents computer --device` resolves the fleet name here and forwards the
+ * answer to the standalone engine, which opens and owns its own tunnel (it
+ * holds the helper token that tunnel's transport needs).
+ */
+import { spawn } from 'child_process';
+import { SSH_OPTS, assertValidSshTarget } from './ssh-exec.js';
+import { getDevice } from './devices/registry.js';
+import { deviceIdentityArgs, sshTargetFor } from './devices/connect.js';
+import { hostNameFor } from './devices/ssh-config.js';
+/** Build the ssh argv (after the `ssh` program name) for an `-L` tunnel. Pure.
+ *
+ * Composes the shared hardened baseline (`SSH_OPTS`) rather than re-listing it,
+ * so the tunnel inherits the same options — crucially the keepalive, which lets
+ * a dropped `-N` tunnel exit instead of lingering as a zombie on the laptop. */
+export function buildTunnelArgs(user, host, localPort, remotePort, extraSshArgs = []) {
+    return [
+        '-L',
+        `${localPort}:127.0.0.1:${remotePort}`,
+        `${user}@${host}`,
+        '-N',
+        ...extraSshArgs,
+        ...SSH_OPTS,
+    ];
+}
+/**
+ * Spawn `ssh -L localPort:127.0.0.1:remotePort -N user@host`.
+ *
+ * stderr is captured so a tunnel that dies inside 500ms rejects with the ssh
+ * error — the browser driver's original contract. The tunnel is held by this
+ * process for the lifetime of the session that opened it.
+ */
+export function startSSHTunnel(user, host, localPort, remotePort, opts = {}) {
+    return new Promise((resolve, reject) => {
+        // `user`/`host` can originate from a browser ssh:// profile or a device
+        // record. buildTunnelArgs places `${user}@${host}` before `-N`/SSH_OPTS, so
+        // a `-`-leading user would be parsed as an ssh option flag (option
+        // injection). Validate at the spawn sink so every caller is covered; reject
+        // (rather than throw synchronously) to keep the Promise contract.
+        try {
+            assertValidSshTarget(`${user}@${host}`);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
+        const args = buildTunnelArgs(user, host, localPort, remotePort, opts.extraSshArgs);
+        const tunnel = spawn('ssh', args, {
+            stdio: ['ignore', 'ignore', 'pipe'],
+            detached: false,
+            windowsHide: true,
+        });
+        let stderr = '';
+        tunnel.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        tunnel.on('error', (err) => {
+            reject(new Error(`SSH tunnel failed: ${err.message}`));
+        });
+        setTimeout(() => {
+            if (tunnel.killed)
+                reject(new Error(`SSH tunnel died: ${stderr}`));
+            else
+                resolve(tunnel);
+        }, 500);
+    });
+}
+/**
+ * Resolve a registered device to its ssh pieces, or throw a clear error.
+ *
+ * `expectPlatform` is how a caller keeps a platform requirement it used to
+ * hard-code: `agents computer --device` drives the Windows helper daemon, so it
+ * passes `'windows'` and gets the same refusal as before. Callers with no
+ * platform requirement (the browser driver) omit it. The gate is a parameter
+ * rather than a baked-in check so this module stays fleet-generic — a
+ * hard-coded `windows` here would be a feature rule in shared plumbing.
+ */
+export async function resolveRemoteDevice(name, opts = {}) {
+    const device = await getDevice(name);
+    if (!device) {
+        throw new Error(`Unknown device '${name}'. Register it with \`agents devices add\` / \`agents devices sync\`, then retry.`);
+    }
+    if (opts.expectPlatform && device.platform !== opts.expectPlatform) {
+        const what = opts.forWhat ?? `this command`;
+        throw new Error(`Device '${name}' is ${device.platform}, not ${opts.expectPlatform}. ${what} needs a ${opts.expectPlatform} device.`);
+    }
+    const target = sshTargetFor(device); // validates address + injection guard
+    const host = hostNameFor(device); // sshTargetFor already threw if absent
+    const user = device.user || process.env.USER || 'Administrator';
+    return { device, target, user, host, identityArgs: deviceIdentityArgs(device) };
+}

package/dist/lib/summarizer/summarize.d.ts

@@ -3,8 +3,8 @@
  *
  * A pure boundary: given the session's first user turn (the goal source) and its
  * live progress (todos / plan / phase off the state engine), it asks a local
- * Anthropic-wire endpoint (Ollama / vLLM / LiteLLM — the same configurable base
- * URL `computer/model.ts` speaks) for a strict JSON `{goal, checkpoints, checklist}`
+ * Anthropic-wire endpoint (Ollama / vLLM / LiteLLM) for a strict JSON
+ * `{goal, checkpoints, checklist}`
  * and validates the shape. On ANY failure — network, non-2xx, non-JSON, wrong
  * shape — it returns `undefined`, and the caller records `summaryState: 'skipped'`.
  *

package/dist/lib/summarizer/summarize.js

@@ -3,15 +3,22 @@
  *
  * A pure boundary: given the session's first user turn (the goal source) and its
  * live progress (todos / plan / phase off the state engine), it asks a local
- * Anthropic-wire endpoint (Ollama / vLLM / LiteLLM — the same configurable base
- * URL `computer/model.ts` speaks) for a strict JSON `{goal, checkpoints, checklist}`
+ * Anthropic-wire endpoint (Ollama / vLLM / LiteLLM) for a strict JSON
+ * `{goal, checkpoints, checklist}`
  * and validates the shape. On ANY failure — network, non-2xx, non-JSON, wrong
  * shape — it returns `undefined`, and the caller records `summaryState: 'skipped'`.
  *
  * NEVER called on the request path: only the background SessionSummarizerService
  * invokes it, debounced and reader-gated.
  */
-import { ANTHROPIC_VERSION } from '../computer/model.js';
+/**
+ * The `anthropic-version` header this request sends. Declared here because this
+ * is now its only caller: it used to be imported from the computer subsystem's
+ * model client, which left with the standalone `computer` engine (PHNX-4075).
+ * A shared constants module for one string used in one request would be more
+ * indirection than the string.
+ */
+const ANTHROPIC_VERSION = '2023-06-01';
 const SYSTEM_PROMPT = [
     'You summarize a coding-agent session for an operator dashboard.',
     'Reply with ONLY a single JSON object, no prose and no code fences, of exactly this shape:',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.103",
+  "version": "1.22.104",
   "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",
@@ -17,8 +17,7 @@
   "bin": {
     "agents": "dist/index.js",
     "ag": "dist/index.js",
-    "browser": "dist/browser.js",
-    "computer": "dist/computer.js"
+    "browser": "dist/browser.js"
   },
   "files": [
     "dist/**/*.js",

package/dist/commands/computer-actions.d.ts

@@ -1,55 +0,0 @@
-import { Command } from 'commander';
-import { type ComputerClient, type RPCResponse } from '../lib/computer/computer-rpc.js';
-export { emitComputerAction, pickTarget, resolveTargetPidDecision, type AppInfo } from '../lib/computer/actions.js';
-export declare function parseXY(s: string, flag: string): {
-    x: number;
-    y: number;
-};
-export declare function buildElementOrCoords(opts: {
-    id?: string;
-    x?: number;
-    y?: number;
-}): {
-    ok: true;
-    params: Record<string, unknown>;
-} | {
-    ok: false;
-    error: string;
-};
-export declare function buildRaiseParams(opts: {
-    windowId?: number;
-    title?: string;
-}): Record<string, unknown>;
-export declare const CHAR_DELAY_MIN_MS = 1;
-export declare const CHAR_DELAY_MAX_MS = 250;
-export declare function clampCharDelay(ms: number | undefined): number | undefined;
-export declare function buildWaitParams(opts: {
-    duration?: number;
-    id?: string;
-    until?: string;
-    role?: string;
-    label?: string;
-    identifier?: string;
-    timeout?: number;
-}): {
-    ok: true;
-    params: Record<string, unknown>;
-} | {
-    ok: false;
-    error: string;
-};
-export declare function withClient<T>(fn: (client: ComputerClient) => Promise<T>): Promise<T>;
-export declare function unwrap(r: RPCResponse): Record<string, unknown>;
-export declare function focusStealNotes(opts: {
-    id?: string;
-    x?: number;
-    y?: number;
-    raise?: boolean;
-}): string[];
-export declare function shouldRaise(opts: {
-    id?: string;
-    raise?: boolean;
-}): boolean;
-export declare function appPathIsElectron(appPath: string | null, exists?: (p: string) => boolean): boolean;
-export declare function electronWebviewTip(appLabel: string): string;
-export declare function registerActionCommands(program: Command): void;