@prohost/cli 0.6.0 → 0.7.0

package/dist/agent/runtime_status.js

@@ -91,6 +91,10 @@ const CLAUDE_WINDOWS = [
     ['five_hour', 'session'],
     ['seven_day', 'weekly'],
 ];
+/** One window, or nothing when the usage itself is unknown. */
+function quotaWindow(kind, used, resets) {
+    return used === undefined ? [] : [{ kind, used_percent: used, resets_at: resets ?? null }];
+}
 /**
  * Windows from a stream `rate_limit_event.rate_limit_info`.
  *
@@ -101,24 +105,57 @@ const CLAUDE_WINDOWS = [
 export function fromClaudeRateLimitInfo(info) {
     const windows = asObject(asObject(info)?.unifiedWindows) ?? {};
     return CLAUDE_WINDOWS.flatMap(([key, kind]) => {
-        const window = asObject(windows[key]);
-        const used = percent(window?.utilization, 1);
-        const at = isoTime(window?.resetsAt);
-        return used !== undefined && at ? [{ kind, used_percent: used, resets_at: at }] : [];
+        const entry = asObject(windows[key]);
+        const used = percent(entry?.utilization, 1);
+        const at = isoTime(entry?.resetsAt);
+        // The event's schema requires `resetsAt` on every window it sends (it
+        // omits a rolled-over window instead), so one without it is malformed.
+        return at ? quotaWindow(kind, used, at) : [];
     });
 }
-/** Windows from a `get_usage` control response (0–100, ISO strings). */
+/**
+ * Windows from a `get_usage` control response (0–100, ISO strings).
+ *
+ * A window with a usage but a `null` reset is kept, with `resets_at: null` —
+ * that is how an idle account's 5-hour window reads, and dropping it is what
+ * left paired agents showing a weekly window and nothing else (B3).
+ *
+ * Per-model weekly windows come from `rate_limits.limits[]` rows of kind
+ * `weekly_scoped` (classified on `kind`, as the schema asks, never on a
+ * label), falling back to `model_scoped[]`.
+ */
 export function fromClaudeGetUsage(usage) {
     const record = asObject(usage);
     if (record?.rate_limits_available !== true)
         return [];
     const limits = asObject(record.rate_limits) ?? {};
-    return CLAUDE_WINDOWS.flatMap(([key, kind]) => {
-        const window = asObject(limits[key]);
-        const used = percent(window?.utilization, 100);
-        const at = isoTime(window?.resets_at);
-        return used !== undefined && at ? [{ kind, used_percent: used, resets_at: at }] : [];
+    const windows = CLAUDE_WINDOWS.flatMap(([key, kind]) => {
+        const entry = asObject(limits[key]);
+        return quotaWindow(kind, percent(entry?.utilization, 100), isoTime(entry?.resets_at));
     });
+    const perModel = new Map();
+    const rows = Array.isArray(limits.limits) ? limits.limits : [];
+    for (const raw of rows) {
+        const row = asObject(raw);
+        if (row?.kind !== 'weekly_scoped')
+            continue;
+        const model = text(asObject(asObject(row.scope)?.model)?.display_name);
+        const used = percent(row.percent, 100);
+        if (!model || used === undefined || perModel.has(model))
+            continue;
+        perModel.set(model, { kind: 'weekly_model', used_percent: used, resets_at: isoTime(row.resets_at) ?? null, model_label: model });
+    }
+    if (perModel.size === 0 && Array.isArray(limits.model_scoped)) {
+        for (const raw of limits.model_scoped) {
+            const row = asObject(raw);
+            const model = text(row?.display_name);
+            const used = percent(row?.utilization, 100);
+            if (!model || used === undefined || perModel.has(model))
+                continue;
+            perModel.set(model, { kind: 'weekly_model', used_percent: used, resets_at: isoTime(row?.resets_at) ?? null, model_label: model });
+        }
+    }
+    return [...windows, ...perModel.values()];
 }
 const CLAUDE_PLANS = {
     pro: 'Claude Pro',
@@ -163,7 +200,7 @@ export function fromCodexRateLimits(rateLimits, lineTimestamp) {
             if (!Number.isNaN(base))
                 at = new Date(base + window.resets_in_seconds * 1000).toISOString();
         }
-        return kind && used !== undefined && at ? [{ kind, used_percent: used, resets_at: at }] : [];
+        return kind ? quotaWindow(kind, used, at) : [];
     });
 }
 /** `plan_type` / `planType` → `ChatGPT Pro`; `undefined` when there is no plan. */
@@ -290,7 +327,7 @@ export function readCodexObservation(threadId, env = process.env) {
  * Spawn ``command args``, write ``lines`` as JSONL, and resolve with the first
  * stdout line ``pick`` accepts. Kills the child on answer, error or timeout.
  */
-function exchangeJsonLines(spawnImpl, command, args, lines, pick, timeoutMs) {
+function exchangeJsonLines(spawnImpl, command, args, lines, pick, timeoutMs, env) {
     return new Promise((resolve) => {
         let settled = false;
         let buffer = '';
@@ -311,7 +348,12 @@ function exchangeJsonLines(spawnImpl, command, args, lines, pick, timeoutMs) {
         const timer = setTimeout(() => finish(undefined), timeoutMs);
         timer.unref?.();
         try {
-            child = spawnImpl(command, args, { stdio: ['pipe', 'pipe', 'ignore'] });
+            // `env` selects the account (CLAUDE_CONFIG_DIR / CODEX_HOME) — the
+            // probe must ask the login the agent actually runs on.
+            child = spawnImpl(command, args, {
+                stdio: ['pipe', 'pipe', 'ignore'],
+                ...(env ? { env: { ...process.env, ...env } } : {}),
+            });
         }
         catch {
             finish(undefined);
@@ -371,7 +413,7 @@ export function claudeQuotaProvider(options) {
                 plan_label: claudePlanLabel(usage.subscription_type),
                 ...(windows.length > 0 ? { quota_windows: windows } : {}),
             };
-        }, options.timeoutMs ?? PROVIDER_TIMEOUT_MS),
+        }, options.timeoutMs ?? PROVIDER_TIMEOUT_MS, options.env?.()),
     };
 }
 /** Codex's `account/rateLimits/read` over `codex app-server` stdio JSON-RPC. */
@@ -396,7 +438,7 @@ export function codexQuotaProvider(options) {
                 plan_label: codexPlanLabel(rateLimits.planType),
                 ...(windows.length > 0 ? { quota_windows: windows } : {}),
             };
-        }, options.timeoutMs ?? PROVIDER_TIMEOUT_MS),
+        }, options.timeoutMs ?? PROVIDER_TIMEOUT_MS, options.env?.()),
     };
 }
 // ── The reporter ───────────────────────────────────────────────────────────
@@ -405,6 +447,31 @@ function band(windows) {
     const top = Math.max(0, ...(windows ?? []).map((w) => w.used_percent));
     return top >= EXHAUSTED_PERCENT ? 2 : top >= LOW_PERCENT ? 1 : 0;
 }
+/**
+ * Fold new windows into the ones already known, one KIND at a time.
+ *
+ * Sources see different slices: a run's `rate_limit_event` carries only the
+ * 5-hour and weekly windows (and omits one whose reset has passed), while the
+ * idle `get_usage` probe also carries the per-model weekly ones. Replacing the
+ * whole list with whatever arrived last is how a stream event used to erase
+ * the windows it simply didn't mention. A kind the observation names replaces
+ * every window of that kind; a kind it doesn't name is kept.
+ */
+export function mergeWindows(known, observed) {
+    const kinds = new Set(observed.map((w) => w.kind));
+    return [...(known ?? []).filter((w) => !kinds.has(w.kind)), ...observed];
+}
+/**
+ * A window as of ``nowMs``: one whose reset has passed has rolled over, so it
+ * is reported as a fresh window — 0%, not started — rather than dropped. The
+ * agent CLI omits a rolled-over window from its own events, so this is the
+ * only place that knows it exists.
+ */
+function asOf(window, nowMs) {
+    if (window.resets_at === null || Date.parse(window.resets_at) > nowMs)
+        return window;
+    return { ...window, used_percent: 0, resets_at: null };
+}
 function defaultSchedule(fn, ms) {
     const timer = setTimeout(fn, ms);
     timer.unref?.();
@@ -430,6 +497,9 @@ export class RuntimeStatusReporter {
     cancelPending;
     cancelTick;
     refreshing;
+    accountGeneration = 0;
+    accounts;
+    accountsObservedAt;
     constructor(options) {
         this.options = options;
         this.now = options.now ?? Date.now;
@@ -448,7 +518,7 @@ export class RuntimeStatusReporter {
         if (observation.plan_label)
             next.plan_label = observation.plan_label;
         if (observation.quota_windows && observation.quota_windows.length > 0) {
-            next.quota_windows = observation.quota_windows;
+            next.quota_windows = mergeWindows(before.quota_windows, observation.quota_windows);
             this.quotaObservedAt = this.now();
         }
         this.state = next;
@@ -459,6 +529,41 @@ export class RuntimeStatusReporter {
         if (changed)
             this.sendSoon();
     }
+    /**
+     * Record the accounts snapshot. Moving to another account drops what was
+     * known about the previous one's capacity and plan — they describe a
+     * different subscription — and asks for fresh numbers straight away.
+     */
+    setAccounts(snapshot, options = {}) {
+        const before = this.accounts;
+        this.accounts = snapshot;
+        this.accountsObservedAt = this.now();
+        const switched = before?.current?.key !== snapshot?.current?.key;
+        if (switched) {
+            this.accountGeneration += 1;
+            // A probe belongs to the login it started with. Let the new login
+            // refresh immediately even while an older probe is still finishing.
+            this.refreshing = undefined;
+            const { quota_windows: _windows, plan_label: _plan, ...rest } = this.state;
+            this.state = rest;
+            this.quotaObservedAt = undefined;
+        }
+        if (!options.quiet && JSON.stringify(before) !== JSON.stringify(snapshot))
+            this.sendSoon();
+    }
+    /**
+     * The account choice changed (an operator picked one in ProhostAI): re-read
+     * accounts and capacity on the next tick rather than in fifteen minutes.
+     */
+    accountsChanged() {
+        this.accountsObservedAt = undefined;
+        this.quotaObservedAt = undefined;
+        if (!this.send)
+            return;
+        this.cancelTick?.();
+        this.cancelTick = undefined;
+        void this.tick();
+    }
     /** The model to report on a run's completion, when nothing more specific is known. */
     model() {
         return this.state.model;
@@ -481,8 +586,7 @@ export class RuntimeStatusReporter {
     /** The frame as it would be sent now. */
     frame() {
         const nowMs = this.now();
-        // A window whose reset has passed describes a period that is over.
-        const windows = (this.state.quota_windows ?? []).filter((w) => Date.parse(w.resets_at) > nowMs);
+        const windows = (this.state.quota_windows ?? []).map((w) => asOf(w, nowMs));
         return {
             type: 'runtime_status',
             runtime: this.options.runtime,
@@ -491,6 +595,9 @@ export class RuntimeStatusReporter {
             plan_label: this.state.plan_label ?? null,
             quota_windows: windows,
             observed_at: new Date(nowMs).toISOString(),
+            // Optional additions: an older server ignores keys it doesn't know.
+            ...(this.accounts?.current ? { account: this.accounts.current } : {}),
+            ...(this.accounts?.all ? { machine_accounts: this.accounts.all } : {}),
         };
     }
     /** Routine tick: refresh idle quota if it is stale, send, and re-arm. */
@@ -499,6 +606,19 @@ export class RuntimeStatusReporter {
             return;
         const stale = this.quotaObservedAt === undefined || this.now() - this.quotaObservedAt >= QUOTA_REFRESH_AFTER_MS;
         const sentBefore = this.lastSentAt;
+        const accountsStale = this.accountsObservedAt === undefined || this.now() - this.accountsObservedAt >= QUOTA_REFRESH_AFTER_MS;
+        if (accountsStale && this.options.accounts) {
+            // Before the quota probe: after a switch it must ask the new login.
+            try {
+                // Quiet: the tick sends one frame once the quota probe below is in.
+                this.setAccounts(await this.options.accounts(), { quiet: true });
+            }
+            catch {
+                /* fail soft — keep what we had */
+            }
+            if (!this.send)
+                return;
+        }
         if (stale && this.options.provider && !this.options.isBusy?.()) {
             await this.refresh();
         }
@@ -513,8 +633,11 @@ export class RuntimeStatusReporter {
     refresh() {
         if (!this.refreshing) {
             const provider = this.options.provider;
-            this.refreshing = (provider ? provider.refresh() : Promise.resolve(undefined))
+            const generation = this.accountGeneration;
+            const refreshing = (provider ? provider.refresh() : Promise.resolve(undefined))
                 .then((observed) => {
+                if (generation !== this.accountGeneration)
+                    return;
                 // `observe` would itself schedule a send on a change; the caller
                 // sends right after, which the spacing rule coalesces.
                 this.observe(observed);
@@ -523,8 +646,10 @@ export class RuntimeStatusReporter {
                 /* fail soft — keep what we had */
             })
                 .finally(() => {
-                this.refreshing = undefined;
+                if (this.refreshing === refreshing)
+                    this.refreshing = undefined;
             });
+            this.refreshing = refreshing;
         }
         return this.refreshing;
     }

package/dist/agent/workspace.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `prohost agent workspace init --developer` — make a paired agent's workspace
+ * one that opens pull requests the way the ProhostAI fleet does.
+ *
+ * Opt-in: the default workspace is left exactly as it is. With `--developer`
+ * and a path to a ProhostAI checkout (`--repo`), this writes two things into
+ * the workspace's `.claude/`:
+ *
+ * - a skill, `prohost-pr-protocol`, that points the agent at the repo's own
+ *   `prohost_agents/support/prompts/pr_protocol.md` — by absolute path, not a
+ *   copy, so the protocol has one source and cannot drift;
+ * - the fleet's `gh pr create` gate (`prohost_agents/platform/pr_create_gate.sh`)
+ *   as a `PreToolUse` hook in `.claude/settings.json`, registered the way
+ *   `prohost_agents/support/handler.py` registers it (matcher `.*`, the shim
+ *   filters cheaply itself).
+ *
+ * Claude Code loads a workspace's `.claude/` when it starts there, which is
+ * what `agent run` does. Re-running is idempotent; other settings are kept.
+ */
+export declare const PROTOCOL_RELATIVE_PATH: string;
+export declare const GATE_RELATIVE_PATH: string;
+export declare const SKILL_NAME = "prohost-pr-protocol";
+export declare class WorkspaceInitError extends Error {
+}
+export interface WorkspaceInitResult {
+    skillPath: string;
+    settingsPath: string;
+    /** Whether the hook was newly added (false when it was already there). */
+    hookAdded: boolean;
+}
+/**
+ * Write the developer skill and PR gate hook into ``workdir``.
+ *
+ * @throws WorkspaceInitError when ``repo`` is not a ProhostAI checkout, or the
+ *   existing settings file is not JSON (it is never overwritten blind).
+ */
+export declare function initDeveloperWorkspace(options: {
+    workdir: string;
+    repo: string;
+}): WorkspaceInitResult;

package/dist/agent/workspace.js

@@ -0,0 +1,97 @@
+/**
+ * `prohost agent workspace init --developer` — make a paired agent's workspace
+ * one that opens pull requests the way the ProhostAI fleet does.
+ *
+ * Opt-in: the default workspace is left exactly as it is. With `--developer`
+ * and a path to a ProhostAI checkout (`--repo`), this writes two things into
+ * the workspace's `.claude/`:
+ *
+ * - a skill, `prohost-pr-protocol`, that points the agent at the repo's own
+ *   `prohost_agents/support/prompts/pr_protocol.md` — by absolute path, not a
+ *   copy, so the protocol has one source and cannot drift;
+ * - the fleet's `gh pr create` gate (`prohost_agents/platform/pr_create_gate.sh`)
+ *   as a `PreToolUse` hook in `.claude/settings.json`, registered the way
+ *   `prohost_agents/support/handler.py` registers it (matcher `.*`, the shim
+ *   filters cheaply itself).
+ *
+ * Claude Code loads a workspace's `.claude/` when it starts there, which is
+ * what `agent run` does. Re-running is idempotent; other settings are kept.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { shellQuote } from './accounts.js';
+export const PROTOCOL_RELATIVE_PATH = path.join('prohost_agents', 'support', 'prompts', 'pr_protocol.md');
+export const GATE_RELATIVE_PATH = path.join('prohost_agents', 'platform', 'pr_create_gate.sh');
+export const SKILL_NAME = 'prohost-pr-protocol';
+export class WorkspaceInitError extends Error {
+}
+function skillBody(protocolPath, gatePath) {
+    return [
+        '---',
+        `name: ${SKILL_NAME}`,
+        'description: >-',
+        '  ProhostAI pull-request protocol. Use before creating a branch, committing, pushing,',
+        '  opening or updating a pull request, answering review comments, or reporting CI status',
+        '  in the ProhostAI repositories.',
+        '---',
+        '',
+        '# ProhostAI pull-request protocol',
+        '',
+        `Read \`${protocolPath}\` in full before you open or update a pull request, and follow it exactly.`,
+        'That file is the single source of truth; this skill only points at it, so never work from a',
+        'remembered or summarised copy — re-read it each time.',
+        '',
+        `A \`gh pr create\` gate (\`${gatePath}\`) runs before every shell command. If it refuses, fix`,
+        'what it names (usually the PR body headings, or a missing test) and try again. Never work',
+        'around it.',
+        '',
+    ].join('\n');
+}
+/**
+ * Write the developer skill and PR gate hook into ``workdir``.
+ *
+ * @throws WorkspaceInitError when ``repo`` is not a ProhostAI checkout, or the
+ *   existing settings file is not JSON (it is never overwritten blind).
+ */
+export function initDeveloperWorkspace(options) {
+    const repo = path.resolve(options.repo);
+    const protocolPath = path.join(repo, PROTOCOL_RELATIVE_PATH);
+    const gatePath = path.join(repo, GATE_RELATIVE_PATH);
+    for (const required of [protocolPath, gatePath]) {
+        if (!existsSync(required)) {
+            throw new WorkspaceInitError(`${required} does not exist — pass --repo <path to a ProhostAI backend-service checkout>.`);
+        }
+    }
+    const claudeDir = path.join(path.resolve(options.workdir), '.claude');
+    const skillDir = path.join(claudeDir, 'skills', SKILL_NAME);
+    mkdirSync(skillDir, { recursive: true, mode: 0o700 });
+    const skillPath = path.join(skillDir, 'SKILL.md');
+    writeFileSync(skillPath, skillBody(protocolPath, gatePath));
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            const parsed = JSON.parse(readFileSync(settingsPath, 'utf8'));
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                throw new Error('not an object');
+            settings = parsed;
+        }
+        catch {
+            throw new WorkspaceInitError(`${settingsPath} is not a JSON object; fix or remove it and run this again.`);
+        }
+    }
+    const hooks = settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks)
+        ? settings.hooks
+        : {};
+    const preToolUse = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+    // Claude runs a hook command through a shell, so a checkout path with a
+    // space or metacharacter must be quoted — unquoted, the gate would fail to
+    // run (or run as something else) and `gh pr create` would go ungated.
+    const gateCommand = shellQuote(gatePath);
+    const present = preToolUse.some((group) => (group.hooks ?? []).some((hook) => hook.command === gateCommand || hook.command === gatePath));
+    if (!present)
+        preToolUse.push({ matcher: '.*', hooks: [{ type: 'command', command: gateCommand }] });
+    settings.hooks = { ...hooks, PreToolUse: preToolUse };
+    writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    return { skillPath, settingsPath, hookAdded: !present };
+}

package/dist/index.d.ts

@@ -16,6 +16,8 @@ interface ParsedArgs {
     command: string | undefined;
     /** Second positional, e.g. the ``pair`` in ``prohost agent pair``. */
     subcommand: string | undefined;
+    /** Any further positionals, e.g. ``add work`` in ``prohost agent account add work``. */
+    args: string[];
     flags: Record<string, string | boolean>;
 }
 export declare function parseArgs(argv: readonly string[]): ParsedArgs;

package/dist/index.js

@@ -24,10 +24,14 @@ function printHelp() {
         '',
         'Usage:',
         '  prohost listen --forward-to <local-url> [--api-key <key>] [--url <ws-url>] [--machine <name>] [--subscription-id <id>]',
-        '  prohost agent pair --code <pairing-code> [--webhook-url <https-url>] [--base-url <url>]',
+        '  prohost agent pair --code <pairing-code> [--account <label>] [--webhook-url <https-url>] [--base-url <url>]',
         "  prohost agent run --exec '<command>' [--idle-timeout <seconds>] [--timeout <seconds>] [--dry-run] [--workdir <dir>]",
-        "  prohost agent install-daemon --exec '<command>' [--workdir <dir>]   Keep the agent running",
+        "  prohost agent install-daemon --exec '<command>' [--workdir <dir>] [--account <label>]   Keep the agent running",
         '  prohost agent uninstall-daemon',
+        '  prohost agent account add <label> --runtime claude|codex [--billing subscription|api_key]',
+        '  prohost agent account list | remove <label>',
+        '  prohost agent list                   Every paired agent on this machine, and its accounts',
+        '  prohost agent workspace init --developer --repo <checkout> [--workdir <dir>]',
         '',
         'listen flags:',
         '  --forward-to     Local URL to POST each webhook payload to (required)',
@@ -72,6 +76,20 @@ function printHelp() {
         '  will go. The name "prohost" is reserved; a malformed file is a warning and a run',
         '  without extras. Which servers loaded is printed to agent.log at start-up.',
         '',
+        'Accounts:',
+        '  An account is one Claude Code or Codex login on this machine, in its own config directory',
+        '  (~/.prohost-accounts, or $PROHOST_ACCOUNTS_ROOT). `account add` prints the sign-in command',
+        '  (CLAUDE_CONFIG_DIR=… claude auth login / CODEX_HOME=… codex login) and waits for it; the CLI',
+        '  never reads the login itself. An agent uses one account — `default` is ~/.claude or ~/.codex —',
+        '  set with --account or picked in ProhostAI, and applied from its next run. Accounts never switch',
+        '  on their own: an agent whose account is used up rests until the limit resets.',
+        '  --no-wait        `account add`: print the sign-in command and return.',
+        '  --wait-timeout   `account add`: seconds to wait for the sign-in (default 600).',
+        '',
+        'agent workspace init --developer:',
+        '  Adds the ProhostAI PR-protocol skill and the `gh pr create` gate hook from --repo (a',
+        '  backend-service checkout) to the agent workspace\'s .claude/. Opt-in; nothing else changes.',
+        '',
         'agent install-daemon flags:  (macOS: launchd; Linux: prints a systemd-user unit)',
         '  --exec           The same command you would pass to `agent run` (required).',
         '  --workdir, --idle-timeout, --timeout, --machine, --url, --allow-unverified, --safe-tools',
@@ -86,6 +104,7 @@ function printHelp() {
         '  PROHOST_WS_URL        Used when --url is not provided.',
         '  PROHOST_PAIRING_CODE  Used by `agent pair` when --code is not provided.',
         '  PROHOST_HOME          Credential, ledger, workspace and log directory. Defaults to ~/.prohost.',
+        '  PROHOST_ACCOUNTS_ROOT Machine-wide account registry shared by every agent. Defaults to ~/.prohost-accounts.',
     ];
     process.stdout.write(`${lines.join('\n')}\n`);
 }
@@ -93,6 +112,7 @@ export function parseArgs(argv) {
     const flags = {};
     let command;
     let subcommand;
+    const args = [];
     let i = 0;
     while (i < argv.length) {
         const token = argv[i];
@@ -101,6 +121,8 @@ export function parseArgs(argv) {
                 command = token;
             else if (!subcommand)
                 subcommand = token;
+            else
+                args.push(token);
             i += 1;
             continue;
         }
@@ -125,10 +147,10 @@ export function parseArgs(argv) {
             i += 2;
         }
     }
-    return { command, subcommand, flags };
+    return { command, subcommand, args, flags };
 }
 async function main(argv) {
-    const { command, subcommand, flags } = parseArgs(argv);
+    const { command, subcommand, args, flags } = parseArgs(argv);
     // Checked before the help/no-command branch: `prohost --version` carries no
     // command, which would otherwise print help and exit 1.
     if (flags.version) {
@@ -148,7 +170,7 @@ async function main(argv) {
         return 1;
     }
     if (command === 'agent') {
-        return runAgent(subcommand, flags, printHelp);
+        return runAgent(subcommand, flags, printHelp, args);
     }
     if (command !== 'listen') {
         process.stderr.write(`Unknown command: ${command}\n\n`);

package/dist/version.d.ts

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export declare const CLI_VERSION = "0.6.0";
+export declare const CLI_VERSION = "0.7.0";
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
-export declare const USER_AGENT = "prohost-cli/0.6.0";
+export declare const USER_AGENT = "prohost-cli/0.7.0";

package/dist/version.js

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export const CLI_VERSION = '0.6.0';
+export const CLI_VERSION = '0.7.0';
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
 export const USER_AGENT = `prohost-cli/${CLI_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prohost/cli",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Run your own AI agent as a ProhostAI teammate, and stream your account's webhooks to your laptop.",
   "type": "module",
   "license": "MIT",