@phnx-labs/agents-cli 1.22.39 → 1.22.40

package/dist/commands/cloud.js

@@ -5,8 +5,8 @@ import { insertTask, updateTaskStatus, getTaskById, listTasks as listStoredTasks
 import { renderStream } from '../lib/cloud/stream.js';
 import { MAX_IMAGES_PER_DISPATCH } from '../lib/cloud/types.js';
 import { resolveCloudPrompt, executeCloudDispatch } from '../lib/cloud/dispatch.js';
-import { normalizeTriggerEvent, validateTrigger, writeJob, setJobEnabled, jobExists, GITHUB_TRIGGER_EVENTS } from '../lib/routines.js';
-import { emit } from '../lib/events.js';
+import { normalizeTriggerEvent, validateTrigger, writeJob, setJobEnabled, jobExists, GITHUB_TRIGGER_EVENTS } from '../lib/scheduling/routines.js';
+import { emit } from '../lib/feed/events.js';
 /** Return a chalk color function appropriate for the given task status. */
 export function statusColor(status) {
     switch (status) {
@@ -95,9 +95,9 @@ Examples:
         .option('--model <model>', 'Model override')
         .option('--env <id>', 'Codex Cloud environment ID')
         .option('--computer <name>', 'Factory/Droid computer target')
-        .option('--host <name>', 'One of your machines as the target (a registered host, device, capability tag, or user@host). Implies --provider host.')
-        .option('--remote-cwd <dir>', 'Working directory on the host (--provider host only)')
-        .option('--any', 'With --host <cap> (a capability tag), pick any matching host instead of erroring when several match')
+        .option('--device <name>', 'One of your machines as the target (a registered device, capability tag, or user@host). Implies --provider host.')
+        .option('--remote-cwd <dir>', 'Working directory on the device (--provider host only)')
+        .option('--any', 'With --device <cap> (a capability tag), pick any matching device instead of erroring when several match')
         .option('--autonomy <level>', 'Factory/Droid autonomy: low, medium, high (default high)')
         .option('--mode <mode>', 'Execution mode (e.g., plan, edit, full)')
         .option('--image <path>', `Attach an image (.png/.jpg/.webp) for vision dispatch. Repeatable, up to ${MAX_IMAGES_PER_DISPATCH} (Rush Cloud only).`, (value, previous) => {
@@ -112,7 +112,6 @@ Examples:
     })
         .option('-b, --balanced', 'Shortcut for --strategy balanced. Route the factory run across all healthy accounts.')
         .option('--strategy <strategy>', 'Account selection strategy for the factory: balanced. Sends all healthy accounts so the factory pod rotates between them on rate-limit.')
-        .option('--upload-account-tokens', 'Upload Claude OAuth credentials to Rush Cloud on first dispatch (consent recorded for future runs).')
         .option('--json', 'Structured JSON output')
         .option('--no-follow', 'Dispatch and exit without streaming output')
         .addHelpText('after', `
@@ -127,9 +126,9 @@ Examples:
   # Codex Cloud
   agents cloud run "add auth tests" --provider codex --env env_abc123
 
-  # One of your own machines (agents devices), over SSH
-  agents cloud run "run the nightly benchmark" --host gpu-box --agent claude
-  agents cloud run "rebuild the index" --host gpu --any --remote-cwd ~/proj
+  # One of your own machines (agents hosts / agents devices), over SSH
+  agents cloud run "run the nightly benchmark" --device gpu-box --agent claude
+  agents cloud run "rebuild the index" --device gpu --any --remote-cwd ~/proj
 
   # Default provider (set in ~/.agents/agents.yaml)
   agents cloud run "refactor auth module" --repo user/repo
@@ -143,13 +142,13 @@ Examples:
             json,
             hint: 'agents cloud run "<task>" --repo <owner/repo>',
         });
-        // --host names one of YOUR machines as the target — that only means
+        // --device names one of YOUR machines as the target — that only means
         // something to the host provider, so it implies --provider host rather
         // than silently riding along to a cloud backend that would ignore it.
-        if (options.host && options.provider && options.provider !== 'host') {
-            die(`--host targets your own machines (--provider host), not ${options.provider}. Drop --host, or use --provider host.`, 1, { json });
+        if (options.device && options.provider && options.provider !== 'host') {
+            die(`--device targets your own machines (--provider host), not ${options.provider}. Drop --device, or use --provider host.`, 1, { json });
         }
-        const explicitProvider = options.provider ?? (options.host ? 'host' : undefined);
+        const explicitProvider = options.provider ?? (options.device ? 'host' : undefined);
         // Agent-aware: with no --provider, the agent routes to its native cloud
         // (claude→rush, codex→codex, droid→factory, antigravity→antigravity).
         const provider = resolveProvider(explicitProvider, options.agent);
@@ -176,8 +175,8 @@ Examples:
             dispatchOptions.providerOptions.env = options.env;
         if (options.computer)
             dispatchOptions.providerOptions.computer = options.computer;
-        if (options.host)
-            dispatchOptions.providerOptions.host = options.host;
+        if (options.device)
+            dispatchOptions.providerOptions.host = options.device;
         if (options.remoteCwd)
             dispatchOptions.providerOptions.remoteCwd = options.remoteCwd;
         if (options.any)
@@ -189,8 +188,6 @@ Examples:
         if (options.balanced || options.strategy === 'balanced') {
             dispatchOptions.providerOptions.strategy = 'balanced';
         }
-        if (options.uploadAccountTokens)
-            dispatchOptions.providerOptions.uploadAccountTokens = true;
         // --on <event>: register this run as an event trigger instead of
         // dispatching now. We parse + validate the event, attach it to
         // dispatchOptions.trigger, and persist a trigger-bound routine so the
@@ -231,10 +228,10 @@ Examples:
             };
             if (repoValues[0])
                 routine.repo = repoValues[0];
-            // --host controls where the enabled local receiver dispatches the run.
+            // --device controls where the enabled local receiver dispatches the run.
             // Device activation remains in this receiver's device manifest.
-            if (options.host) {
-                routine.host = options.host;
+            if (options.device) {
+                routine.host = options.device;
                 if (options.remoteCwd)
                     routine.remoteCwd = options.remoteCwd;
             }

package/dist/commands/commands.js

@@ -10,7 +10,7 @@ import { cloneRepo } from '../lib/git.js';
 import { discoverCommands, resolveCommandSource, installCommandCentrally, listCentralCommands, listInstalledCommandsWithScope, getCommandInfo, diffVersionCommands, iterCommandsCapableVersions, removeCommandFromVersion, } from '../lib/commands.js';
 import { getCommandsDir } from '../lib/state.js';
 import { showResourceList, buildTargetsSection, } from './resource-view.js';
-import { listInstalledVersions, getGlobalDefault, syncResourcesToVersion, promptAgentVersionSelection, getVersionHomePath, resolveInstalledAgentTargets, } from '../lib/versions.js';
+import { listInstalledVersions, getGlobalDefault, syncResourcesToVersion, promptAgentVersionSelection, getVersionHomePath, resolveInstalledAgentTargets, } from '../lib/installations/versions.js';
 import { recordVersionResources } from '../lib/state.js';
 import { isPromptCancelled, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, promptRemovalTargets, resolveAgentTargetsAutoInstalling, resolveListFilterOrExit, } from './utils.js';
 /** Register the `agents commands` command tree (list, add, remove, sync, prune, view). */

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

@@ -1,21 +1,6 @@
 import { Command } from 'commander';
 import { type ComputerClient, type RPCResponse } from '../lib/computer-rpc.js';
-export interface AppInfo {
-    pid: number;
-    name: string;
-    bundle_id: string;
-    active: boolean;
-}
-export declare function pickTarget(list: AppInfo[], opts: {
-    pid?: number;
-    bundle?: string;
-}): {
-    ok: true;
-    app: AppInfo;
-} | {
-    ok: false;
-    error: string;
-};
+export { emitComputerAction, pickTarget, resolveTargetPidDecision, type AppInfo } from '../lib/computer/actions.js';
 export declare function parseXY(s: string, flag: string): {
     x: number;
     y: number;
@@ -55,21 +40,6 @@ export declare function buildWaitParams(opts: {
 };
 export declare function withClient<T>(fn: (client: ComputerClient) => Promise<T>): Promise<T>;
 export declare function unwrap(r: RPCResponse): Record<string, unknown>;
-export declare function resolveTargetPidDecision(client: ComputerClient, opts: {
-    pid?: number;
-    bundle?: string;
-}, gate?: {
-    verb?: string;
-    env?: NodeJS.ProcessEnv;
-    nowMs?: number;
-}): Promise<{
-    ok: true;
-    pid: number;
-    source: 'pid' | 'list_apps' | 'session_admission';
-} | {
-    ok: false;
-    error: string;
-}>;
 export declare function focusStealNotes(opts: {
     id?: string;
     x?: number;
@@ -82,8 +52,4 @@ export declare function shouldRaise(opts: {
 }): boolean;
 export declare function appPathIsElectron(appPath: string | null, exists?: (p: string) => boolean): boolean;
 export declare function electronWebviewTip(appLabel: string): string;
-export declare function emitComputerAction(verb: string, targetPid: number | undefined, opts: {
-    bundle?: string;
-    host?: string;
-}, extra?: Record<string, unknown>): void;
 export declare function registerActionCommands(program: Command): void;

package/dist/commands/computer-actions.js

@@ -9,121 +9,13 @@
 import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
-import { randomUUID } from 'node:crypto';
-import { openComputerClient, describeTransport, resolvePolicyPath, } from '../lib/computer-rpc.js';
-import { COMPUTER_INPUT_GATED_VERBS, formatComputerPermissionGrantHint, } from '../lib/permissions.js';
-import { emit as emitEvent } from '../lib/events.js';
-import { recordComputerSession } from '../lib/session/db.js';
-import { resolveActor } from '../lib/actor.js';
-function isComputerInputVerb(verb) {
-    return typeof verb === 'string' && COMPUTER_INPUT_GATED_VERBS.includes(verb);
-}
-function computerSessionId(env = process.env) {
-    return env.CODEX_THREAD_ID
-        || env.CLAUDE_CODE_SESSION_ID
-        || env.CLAUDE_SESSION_ID
-        || env.AGENTS_SESSION_ID
-        || env.AGENTS_RUN_ID
-        || null;
-}
-function admissionCachePath(env = process.env) {
-    if (env.AGENTS_COMPUTER_ADMISSION_CACHE)
-        return env.AGENTS_COMPUTER_ADMISSION_CACHE;
-    return path.join(path.dirname(resolvePolicyPath()), 'computer-target-admissions.json');
-}
-function targetSelector(opts) {
-    return opts.bundle ? `bundle:${opts.bundle}` : 'frontmost';
-}
-function readAdmissionCache(filePath) {
-    try {
-        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-        return Array.isArray(parsed.admissions) ? parsed.admissions.filter(isAdmission) : [];
-    }
-    catch {
-        return [];
-    }
-}
-function isAdmission(v) {
-    if (!v || typeof v !== 'object')
-        return false;
-    const r = v;
-    return r.sessionId !== undefined
-        && typeof r.sessionId === 'string'
-        && typeof r.selector === 'string'
-        && r.gateClass === 'input'
-        && typeof r.pid === 'number'
-        && typeof r.bundle_id === 'string'
-        && typeof r.name === 'string'
-        && typeof r.admittedAtMs === 'number'
-        && isComputerInputVerb(r.admittedByVerb);
-}
-function rememberAdmission(app, opts) {
-    const sessionId = computerSessionId(opts.env);
-    if (!sessionId)
-        return;
-    const filePath = admissionCachePath(opts.env);
-    const admissions = readAdmissionCache(filePath);
-    const next = {
-        sessionId,
-        selector: opts.selector,
-        gateClass: 'input',
-        pid: app.pid,
-        bundle_id: app.bundle_id,
-        name: app.name,
-        admittedAtMs: opts.nowMs ?? Date.now(),
-        admittedByVerb: opts.verb,
-    };
-    const filtered = admissions.filter((a) => !(a.sessionId === sessionId && a.selector === opts.selector && a.gateClass === 'input'));
-    filtered.push(next);
-    try {
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, JSON.stringify({ admissions: filtered }, null, 2), { mode: 0o600 });
-    }
-    catch {
-        // Cache persistence is best-effort; the daemon remains the final gate.
-    }
-}
-function findAdmission(opts) {
-    const sessionId = computerSessionId(opts.env);
-    if (!sessionId)
-        return null;
-    const admissions = readAdmissionCache(admissionCachePath(opts.env));
-    const matches = admissions
-        .filter((a) => a.sessionId === sessionId && a.selector === opts.selector && a.gateClass === 'input')
-        .sort((a, b) => b.admittedAtMs - a.admittedAtMs);
-    return matches[0] ?? null;
-}
+import { openComputerClient, describeTransport, } from '../lib/computer-rpc.js';
+import { emitComputerAction, resolveTargetPidDecision } from '../lib/computer/actions.js';
+export { emitComputerAction, pickTarget, resolveTargetPidDecision } from '../lib/computer/actions.js';
 // Pure target picker — exercised by unit tests. Precedence: explicit --pid,
 // then --bundle, then the frontmost active allow-listed app (the same default
 // `screenshot` uses). Kept side-effect-free so the resolution rules are
 // testable without a live daemon.
-export function pickTarget(list, opts) {
-    if (opts.pid != null) {
-        const app = list.find((a) => a.pid === opts.pid);
-        // A --pid the daemon doesn't list (not allow-listed / not running) is
-        // still passed through: the daemon is the authority and will return a
-        // precise permission_denied / app_not_found. We don't second-guess it.
-        return { ok: true, app: app ?? { pid: opts.pid, name: '', bundle_id: '', active: false } };
-    }
-    if (opts.bundle) {
-        const app = list.find((a) => a.bundle_id === opts.bundle);
-        if (!app) {
-            return {
-                ok: false,
-                error: `bundle not in allow list (or not running): ${opts.bundle}\n${formatComputerPermissionGrantHint(opts.bundle)}`,
-            };
-        }
-        return { ok: true, app };
-    }
-    const active = list.find((a) => a.active);
-    if (!active) {
-        return {
-            ok: false,
-            error: `no active app found in allow list\n${formatComputerPermissionGrantHint()}`,
-        };
-    }
-    return { ok: true, app: active };
-}
 // Parse an "x,y" coordinate pair. Pure + tested.
 export function parseXY(s, flag) {
     const parts = s.split(',').map((v) => v.trim());
@@ -227,28 +119,6 @@ export function unwrap(r) {
     }
     return r.result ?? {};
 }
-export async function resolveTargetPidDecision(client, opts, gate) {
-    // A directly-supplied pid skips the list_apps roundtrip — the daemon gates.
-    if (opts.pid != null)
-        return { ok: true, pid: opts.pid, source: 'pid' };
-    const apps = unwrap(await client.call('list_apps'));
-    const list = apps.apps || [];
-    const picked = pickTarget(list, opts);
-    const verb = gate?.verb;
-    const selector = targetSelector(opts);
-    if (picked.ok && isComputerInputVerb(verb)) {
-        rememberAdmission(picked.app, { selector, verb, env: gate?.env, nowMs: gate?.nowMs });
-    }
-    if (!picked.ok) {
-        if (isComputerInputVerb(verb)) {
-            const admitted = findAdmission({ selector, env: gate?.env });
-            if (admitted)
-                return { ok: true, pid: admitted.pid, source: 'session_admission' };
-        }
-        return { ok: false, error: picked.error };
-    }
-    return { ok: true, pid: picked.app.pid, source: 'list_apps' };
-}
 // Resolve the target pid via list_apps + pickTarget, printing a precise error
 // and exiting when no target matches.
 async function resolveTargetPid(client, opts, gate) {
@@ -339,9 +209,9 @@ export function electronWebviewTip(appLabel) {
 }
 // Print the CDP steer when the target is a known Electron app. Keyed off --bundle
 // (the recommended way to target); a frontmost-resolved target without --bundle is
-// left alone to avoid a second RPC on the hot path. Skipped for remote --host.
+// left alone to avoid a second RPC on the hot path. Skipped for remote --device.
 function warnIfElectronWebview(opts) {
-    if (opts.host)
+    if (opts.device)
         return;
     if (opts.bundle && isElectronApp(opts.bundle))
         console.error(electronWebviewTip(opts.bundle));
@@ -357,58 +227,20 @@ function emit(result, json, human) {
 // Record one `computer.action` per verb invocation, one call site per command
 // below. Session/agent/machine identity is stamped for free by emitEvent's
 // provenance floor (events.ts resolveProvenance) — this only carries the
-// action-specific facts: which verb, against which target pid/bundle/host.
+// action-specific facts: which verb, against which target pid/bundle/device.
 // NOTE: the field is `targetPid`, never `pid` — `pid` is a reserved envelope
 // key (the emitting process's OWN pid, events.ts RESERVED_META_KEYS) that
 // sanitizePayload() silently strips from the payload before it can collide.
-const COMPUTER_INVOCATION_ID = randomUUID();
-export function emitComputerAction(verb, targetPid, opts, extra = {}) {
-    emitEvent('computer.action', {
-        command: verb,
-        invocationId: COMPUTER_INVOCATION_ID,
-        targetPid,
-        bundle: opts.bundle,
-        host: opts.host,
-        ...extra,
-    });
-    // Mirror the invocation's IDENTITY into the durable store (RUSH-2549). The
-    // event above stays the audit record, but the event ledger is bounded and
-    // prunes at 7 days / 50 MiB (events.ts), so a run's history used to vanish on
-    // day 8. This row is metadata only -- no screenshots, no typed text -- and
-    // `action_count` accumulates across the many calls one invocation makes.
-    //
-    // Identity is read from this process's own env, exactly as stampProvenance()
-    // does for the event: `agents computer` runs IN the caller's process, so there
-    // is no shared daemon to mis-attribute it to (the browser problem).
-    //
-    // Guarded for the same reason `emit` above guards itself ("logging should
-    // never break the CLI", events.ts): this is a RECORD of the action, not the
-    // action. An unwritable or locked session DB must not stop `agents computer
-    // click` from clicking. The action still happened and its event still landed;
-    // only this row is missed, and the next call re-records the identity.
-    try {
-        recordComputerSession({
-            invocationId: COMPUTER_INVOCATION_ID,
-            sessionId: process.env.AGENT_SESSION_ID || process.env.AGENTS_SESSION_ID,
-            launchId: process.env.AGENT_LAUNCH_ID,
-            actor: resolveActor().id,
-            actionCount: 1,
-            taskPreview: typeof extra.task === 'string' ? extra.task : undefined,
-        });
-    }
-    catch {
-        // Recording is best-effort; the action and its event are already done.
-    }
-}
-// Add the shared --pid/--bundle/--host target options to a verb. `--host` routes
-// the verb at a remote Windows device: the `computer` preAction hook hydrates
-// COMPUTER_HELPER_TCP from the tunnel `start --host` recorded, so withClient's
-// openComputerClient() transparently selects the TCP transport.
+// emitComputerAction lives in lib/computer/actions.ts (re-exported above).
+// Add the shared --pid/--bundle/--device target options to a verb. `--device`
+// routes the verb at a remote Windows device: the `computer` preAction hook
+// hydrates COMPUTER_HELPER_TCP from the tunnel `start --device` recorded, so
+// withClient's openComputerClient() transparently selects the TCP transport.
 function addTargetOpts(cmd) {
     return cmd
         .option('--bundle <id>', 'Bundle id of the target app (default: frontmost allow-listed app)')
         .option('--pid <n>', 'Target pid directly (overrides --bundle)', (v) => parseInt(v, 10))
-        .option('--host <device>', 'Drive a remote Windows device (requires `agents computer start --host <device>` first)');
+        .option('--device <name>', 'Drive a remote Windows device (requires `agents computer start --device <name>` first)');
 }
 // Add the shared --id/--x/--y element-or-coords options to a verb.
 function addElementOrCoordOpts(cmd) {
@@ -739,7 +571,7 @@ export function registerActionCommands(program) {
         .option('--bundle <id>', 'Bundle id (e.g. com.apple.TextEdit)')
         .option('--path <p>', 'Path to the .app bundle')
         .option('--name <s>', 'App name (resolved via /Applications and LaunchServices)')
-        .option('--host <device>', 'Drive a remote Windows device (requires `agents computer start --host <device>` first)')
+        .option('--device <name>', 'Drive a remote Windows device (requires `agents computer start --device <name>` first)')
         .option('--json', 'Emit JSON')
         .action(async (opts) => {
         if (!opts.bundle && !opts.path && !opts.name) {

package/dist/commands/computer.d.ts

@@ -4,13 +4,13 @@ import { resolveHelperExec, resolveSocketPath } from '../lib/computer-rpc.js';
  * Pure platform gate. The computer subsystem is macOS-only for LOCAL driving
  * (Accessibility / launchctl). It is NOT blocked off macOS when a remote daemon
  * is reachable — either a configured TCP endpoint (COMPUTER_HELPER_TCP, e.g. a
- * Windows daemon over a tunnel) or a `--host <device>` remote invocation. Kept
+ * Windows daemon over a tunnel) or a `--device <name>` remote invocation. Kept
  * pure so the gating rule is unit-testable without a live command tree.
  */
 export declare function shouldBlockOffPlatform(opts: {
     platform: NodeJS.Platform;
     tcpConfigured: boolean;
-    host?: string;
+    device?: string;
 }): boolean;
 /**
  * Sniff the image format from the leading magic bytes: PNG starts with the
@@ -52,8 +52,16 @@ export declare function buildRestartTaskScript(taskName: string, exeName: string
 export declare function emitComputerRunTaskMarker(opts: {
     task: string;
     bundle?: string;
-    host?: string;
+    device?: string;
 }): void;
+/**
+ * launchd Label for this process's helper — the production identifier for a real
+ * invocation, namespaced under a redirected HOME (RUSH-2639). launchd routes
+ * bootout/bootstrap/kickstart/print by identifier alone, never by the plist's
+ * path, so without this a process running under a sandbox HOME tears down the
+ * operator's live helper.
+ */
+export declare function helperLabel(): string;
 /**
  * Install the macOS helper locally: resolve (or download + verify) the signed,
  * notarized .app, copy it to /Applications, verify the destination signature,
@@ -80,5 +88,22 @@ export declare function activateComputerHelperMacLocal(): Promise<{
  * Returns false (never throws) if the socket is down or the RPC errors — used to
  * poll while the user grants permissions in System Settings. */
 export declare function probeComputerTrust(): Promise<boolean>;
+/**
+ * The helper's launchd plist.
+ *
+ * The `EnvironmentVariables` dict carries HOME (RUSH-2639, see
+ * `lib/service-manifest.ts`): launchd applies this dict on top of the LOGIN
+ * SESSION's environment, never the environment of whoever called `launchctl
+ * bootstrap`, so a manifest that omits HOME hands the helper the account home no
+ * matter which home the caller resolved. That is a silent escape from any
+ * redirected HOME — the hermetic test harness's, and an agent's isolated version
+ * home alike.
+ */
+export declare function renderLaunchAgentPlist(opts: {
+    label: string;
+    exec: string;
+    socketPath: string;
+    logPath: string;
+}): string;
 export { resolveHelperExec as resolveHelperPath };
 export { resolveSocketPath };