@prohost/cli 0.6.0 → 0.7.0

package/dist/agent/accounts.js

@@ -0,0 +1,413 @@
+/**
+ * Brain accounts — which Claude Code or Codex login a paired agent runs on.
+ *
+ * A machine can hold several logins ("work", "personal"), each in its own
+ * config directory: `CLAUDE_CONFIG_DIR` for Claude Code, `CODEX_HOME` for
+ * Codex. Every agent home on the machine uses exactly one of them, named in its
+ * `agent.json` as `account`, and several agents may share one (and so share its
+ * quota). The implicit `default` account is today's `~/.claude` / `~/.codex`,
+ * so an agent paired before accounts existed keeps running exactly as it did.
+ *
+ * **This module never reads a credential.** Signing in is done by the operator
+ * running the agent CLI's own login command with the account's directory; we
+ * only ever ask the unmodified CLI whether it is signed in (`claude auth status`
+ * → `loggedIn`, `codex login status` → its exit code) and keep nothing else
+ * from the answer — not the email, org or account id either one prints.
+ *
+ * **Accounts never switch on their own.** An exhausted subscription makes the
+ * agent rest until its window resets; only an operator (here, or through the
+ * picker in ProhostAI, which arrives as `agent.config_updated`) moves an agent
+ * to another account.
+ *
+ * The registry lives in a machine-wide root shared by every agent home —
+ * `~/.prohost-accounts`, or `$PROHOST_ACCOUNTS_ROOT` — so `account add` once
+ * serves every agent on the machine.
+ */
+import { execFile } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { loadCredentials, saveCredentials } from './credentials.js';
+/** Server → CLI: an operator picked another account for this agent in ProhostAI. */
+export const EVENT_AGENT_CONFIG_UPDATED = 'agent.config_updated';
+/** Label of the implicit account that is the agent CLI's own default config dir. */
+export const DEFAULT_ACCOUNT_LABEL = 'default';
+/** Most accounts reported to the server in one frame (the server caps it too). */
+export const MAX_REPORTED_ACCOUNTS = 16;
+/** How long one `auth status` / `login status` probe may take. */
+const AUTH_PROBE_TIMEOUT_MS = 10_000;
+/** Labels are filenames and UI text: short, and nothing a shell or a path could misread. */
+const LABEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/;
+export class AccountError extends Error {
+}
+export function isValidLabel(label) {
+    return LABEL_PATTERN.test(label);
+}
+/** `claude` → `claude_code`; anything else that is not `codex` is `undefined`. */
+export function parseAccountRuntime(value) {
+    if (value === 'claude' || value === 'claude_code' || value === 'claude-code')
+        return 'claude_code';
+    if (value === 'codex')
+        return 'codex';
+    return undefined;
+}
+/** Machine-wide root shared by every agent home. */
+export function accountsRoot(env = process.env) {
+    return env.PROHOST_ACCOUNTS_ROOT || path.join(env.HOME || os.homedir(), '.prohost-accounts');
+}
+function registryPath(env) {
+    return path.join(accountsRoot(env), 'accounts.json');
+}
+/** Every account on this machine. An unreadable registry is an empty one. */
+export function loadAccounts(env = process.env) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(registryPath(env), 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    const list = parsed?.accounts;
+    if (!Array.isArray(list))
+        return [];
+    return list.filter((a) => !!a &&
+        typeof a.key === 'string' &&
+        typeof a.label === 'string' &&
+        (a.runtime === 'claude_code' || a.runtime === 'codex') &&
+        (a.billing === 'subscription' || a.billing === 'api_key') &&
+        (a.dir === null || typeof a.dir === 'string'));
+}
+/**
+ * Run ``fn`` holding the registry lock, so two processes adding accounts (or
+ * two agents creating their implicit default at once) can't each write an
+ * array missing the other's entry. A lock older than {@link REGISTRY_LOCK_STALE_MS}
+ * was left by a crash and is broken.
+ */
+function withRegistryLock(env, fn) {
+    const root = accountsRoot(env);
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const lock = path.join(root, 'accounts.lock');
+    const deadline = Date.now() + REGISTRY_LOCK_WAIT_MS;
+    for (;;) {
+        try {
+            closeSync(openSync(lock, 'wx', 0o600));
+            break;
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+            let age = 0;
+            try {
+                age = Date.now() - statSync(lock).mtimeMs;
+            }
+            catch {
+                continue; // released between our open and stat
+            }
+            if (age > REGISTRY_LOCK_STALE_MS) {
+                rmSync(lock, { force: true });
+                continue;
+            }
+            if (Date.now() > deadline)
+                throw new AccountError(`The account registry is locked (${lock}); try again.`);
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        rmSync(lock, { force: true });
+    }
+}
+const REGISTRY_LOCK_WAIT_MS = 5_000;
+const REGISTRY_LOCK_STALE_MS = 30_000;
+function saveAccounts(accounts, env) {
+    const root = accountsRoot(env);
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    chmodSync(root, 0o700);
+    const file = registryPath(env);
+    // Write-then-rename: two agents creating the implicit default at once must
+    // not leave a half-written registry for the next reader.
+    const temp = `${file}.${process.pid}.tmp`;
+    writeFileSync(temp, `${JSON.stringify({ version: 1, accounts }, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    renameSync(temp, file);
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function readMachineId(env) {
+    try {
+        const id = JSON.parse(readFileSync(path.join(accountsRoot(env), 'machine.json'), 'utf8')).id;
+        return typeof id === 'string' && UUID_RE.test(id) ? id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * This computer's id: a random UUID made once and kept in the machine-wide
+ * accounts root, so every agent home on the machine sends the same one. It is
+ * what ProhostAI keys a machine's accounts by — the label (hostname by
+ * default) is display only, since two computers can share one. Nothing about
+ * the computer goes into it. `undefined` when it can't be stored, in which
+ * case the agent reports no accounts rather than risk another machine's.
+ */
+export function machineId(env = process.env) {
+    const existing = readMachineId(env);
+    if (existing)
+        return existing;
+    try {
+        return withRegistryLock(env, () => {
+            const raced = readMachineId(env);
+            if (raced)
+                return raced;
+            const id = randomUUID();
+            const file = path.join(accountsRoot(env), 'machine.json');
+            const temp = `${file}.${process.pid}.tmp`;
+            writeFileSync(temp, `${JSON.stringify({ id }, null, 2)}\n`, { mode: 0o600 });
+            renameSync(temp, file);
+            return id;
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function findAccount(label, runtime, env = process.env) {
+    return loadAccounts(env).find((a) => a.label === label && a.runtime === runtime);
+}
+/**
+ * The implicit default account for a runtime, created on first use so it has
+ * a stable key the server can recognise across restarts.
+ */
+export function ensureDefaultAccount(runtime, env = process.env) {
+    const existing = findAccount(DEFAULT_ACCOUNT_LABEL, runtime, env);
+    if (existing)
+        return existing;
+    return withRegistryLock(env, () => {
+        // Re-read under the lock: another agent may have just created it.
+        const again = findAccount(DEFAULT_ACCOUNT_LABEL, runtime, env);
+        if (again)
+            return again;
+        const record = {
+            key: randomUUID(),
+            label: DEFAULT_ACCOUNT_LABEL,
+            runtime,
+            billing: 'subscription',
+            dir: null,
+            created_at: new Date().toISOString(),
+        };
+        saveAccounts([...loadAccounts(env), record], env);
+        return record;
+    });
+}
+/** Create an account and its config directory. Signing in is the operator's next step. */
+export function addAccount(options, env = process.env) {
+    const { label, runtime } = options;
+    if (!isValidLabel(label)) {
+        throw new AccountError(`"${label}" is not a usable label — up to 32 letters, digits, "-" or "_", starting with a letter or digit.`);
+    }
+    if (label === DEFAULT_ACCOUNT_LABEL) {
+        throw new AccountError(`"${DEFAULT_ACCOUNT_LABEL}" is the agent CLI's own login (~/.claude or ~/.codex) and always exists.`);
+    }
+    return withRegistryLock(env, () => addAccountLocked(label, runtime, options.billing, env));
+}
+function addAccountLocked(label, runtime, billing, env) {
+    if (findAccount(label, runtime, env)) {
+        throw new AccountError(`A ${runtimeName(runtime)} account named "${label}" already exists on this machine.`);
+    }
+    // The server keeps exactly the accounts a machine reports, and a frame
+    // carries at most MAX_REPORTED_ACCOUNTS (room left for both defaults).
+    if (loadAccounts(env).filter((a) => a.label !== DEFAULT_ACCOUNT_LABEL).length >= MAX_REPORTED_ACCOUNTS - 2) {
+        throw new AccountError(`This machine already has ${MAX_REPORTED_ACCOUNTS - 2} accounts, the most ProhostAI can show. Remove one first.`);
+    }
+    const dir = path.join(accountsRoot(env), 'accounts', runtime, label);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(dir, 0o700);
+    const record = {
+        key: randomUUID(),
+        label,
+        runtime,
+        billing: billing ?? 'subscription',
+        dir,
+        created_at: new Date().toISOString(),
+    };
+    saveAccounts([...loadAccounts(env), record], env);
+    return record;
+}
+/**
+ * Forget an account and delete its config directory (the login inside it goes
+ * with it). The implicit default can't be removed — it is the CLI's own login.
+ */
+export function removeAccount(label, runtime, env = process.env) {
+    if (label === DEFAULT_ACCOUNT_LABEL) {
+        throw new AccountError(`"${DEFAULT_ACCOUNT_LABEL}" is the agent CLI's own login and can't be removed here.`);
+    }
+    const record = withRegistryLock(env, () => {
+        const accounts = loadAccounts(env);
+        const found = accounts.find((a) => a.label === label && a.runtime === runtime);
+        if (!found)
+            throw new AccountError(`No ${runtimeName(runtime)} account named "${label}" on this machine.`);
+        saveAccounts(accounts.filter((a) => a !== found), env);
+        return found;
+    });
+    // Only ever a directory this module created under the root.
+    if (record.dir && record.dir.startsWith(path.join(accountsRoot(env), 'accounts') + path.sep)) {
+        rmSync(record.dir, { recursive: true, force: true });
+    }
+    return record;
+}
+export function runtimeName(runtime) {
+    return runtime === 'claude_code' ? 'Claude Code' : 'Codex';
+}
+/** Environment a spawn needs to run as this account. Empty for the default. */
+export function accountEnv(record) {
+    if (!record?.dir)
+        return {};
+    return record.runtime === 'claude_code' ? { CLAUDE_CONFIG_DIR: record.dir } : { CODEX_HOME: record.dir };
+}
+/** POSIX single-quote a path for a shell command (pasted, or run as a hook). */
+export function shellQuote(value) {
+    return /^[A-Za-z0-9_./~-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/** The exact command that signs this account in, for the operator to run. */
+export function signInCommand(record) {
+    if (record.runtime === 'claude_code') {
+        return record.dir ? `CLAUDE_CONFIG_DIR=${shellQuote(record.dir)} claude auth login` : 'claude auth login';
+    }
+    return record.dir ? `CODEX_HOME=${shellQuote(record.dir)} codex login` : 'codex login';
+}
+export const defaultCommandRunner = (command, args, env) => new Promise((resolve) => {
+    try {
+        execFile(command, args, { env: { ...process.env, ...env }, timeout: AUTH_PROBE_TIMEOUT_MS, encoding: 'utf8' }, (error, stdout) => {
+            const code = error === null ? 0 : typeof error.code === 'number' ? error.code : null;
+            resolve({ code, stdout: typeof stdout === 'string' ? stdout : '' });
+        });
+    }
+    catch {
+        resolve({ code: null, stdout: '' });
+    }
+});
+/**
+ * Ask the agent CLI whether this account is signed in.
+ *
+ * Claude Code: `claude auth status --json` — only `loggedIn` and `authMethod`
+ * are read (the same JSON carries the email and org, which are dropped here).
+ * Codex: `codex login status` — exit 0 means signed in; its one line says
+ * whether that is ChatGPT or an API key. A CLI that can't be run, or answers
+ * something we don't recognise, is `unknown` — never `expired` on a guess.
+ */
+export async function checkAuth(record, options = {}) {
+    const run = options.run ?? defaultCommandRunner;
+    const env = accountEnv(record);
+    if (record.runtime === 'claude_code') {
+        const { stdout } = await run(options.binary ?? 'claude', ['auth', 'status', '--json'], env);
+        let parsed;
+        try {
+            const json = JSON.parse(stdout.trim());
+            parsed = { loggedIn: json.loggedIn, authMethod: json.authMethod };
+        }
+        catch {
+            return { state: 'unknown' };
+        }
+        if (parsed.loggedIn === false)
+            return { state: 'expired' };
+        if (parsed.loggedIn !== true)
+            return { state: 'unknown' };
+        const method = typeof parsed.authMethod === 'string' ? parsed.authMethod : '';
+        return {
+            state: 'ok',
+            billing: method === 'claude.ai' ? 'subscription' : method ? 'api_key' : undefined,
+        };
+    }
+    const { code, stdout } = await run(options.binary ?? 'codex', ['login', 'status'], env);
+    if (code === 0)
+        return { state: 'ok', billing: /api key/i.test(stdout) ? 'api_key' : 'subscription' };
+    // Only Codex saying so is a sign-out; any other failure (network, a
+    // provider error, a broken install) is unknown, not a guessed expiry.
+    if (/not logged in/i.test(stdout))
+        return { state: 'expired' };
+    return { state: 'unknown' };
+}
+/**
+ * Poll until the operator has finished signing in, or until the deadline.
+ * Resolves the last check either way.
+ */
+export async function waitForSignIn(record, options) {
+    const check = options.check ?? ((r) => checkAuth(r));
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const now = options.now ?? Date.now;
+    const deadline = now() + options.timeoutMs;
+    let last = await check(record);
+    while (last.state !== 'ok' && now() < deadline) {
+        await sleep(options.intervalMs ?? 2_000);
+        last = await check(record);
+    }
+    return last;
+}
+/**
+ * Wire block for one account. `billing` is what the login itself reported
+ * when it said; the value given at `account add` is only the fallback.
+ */
+export function accountBlock(record, state, billing) {
+    return {
+        key: record.key,
+        label: record.label,
+        runtime: record.runtime,
+        billing: billing ?? record.billing,
+        auth_state: state,
+    };
+}
+/**
+ * The account an agent home runs on: `agent.json`'s `account`, or the default.
+ *
+ * `undefined` when the home names an account that is not on this machine —
+ * the caller refuses to run rather than quietly using another subscription.
+ */
+export function resolveAgentAccount(label, runtime, env = process.env) {
+    if (!label || label === DEFAULT_ACCOUNT_LABEL)
+        return ensureDefaultAccount(runtime, env);
+    return findAccount(label, runtime, env);
+}
+/**
+ * Apply an account picked in ProhostAI (`agent.config_updated` or
+ * `auth_ok.agent_config`): find it on this machine and persist it to the agent
+ * home's `agent.json`, so it is used from the next run and survives a restart.
+ *
+ * An unknown key, or one belonging to another runtime, changes nothing.
+ */
+export function applyAccountKey(key, runtime, env = process.env) {
+    if (typeof key !== 'string' || !key)
+        return { applied: false, reason: 'no account_key in the update' };
+    const record = loadAccounts(env).find((a) => a.key === key);
+    if (!record)
+        return { applied: false, reason: `account ${key.slice(0, 8)}… is not on this machine` };
+    if (record.runtime !== runtime) {
+        return {
+            applied: false,
+            reason: `account "${record.label}" is a ${runtimeName(record.runtime)} login; this agent runs ${runtimeName(runtime)}`,
+        };
+    }
+    const credentials = loadCredentials(env);
+    const current = credentials.account ?? DEFAULT_ACCOUNT_LABEL;
+    if (current === record.label)
+        return { applied: true, record, changed: false };
+    saveCredentials({ ...credentials, account: record.label }, env);
+    return { applied: true, record, changed: true };
+}
+/** Persist an account choice made on this machine (`--account`). Validates it exists. */
+export function setAgentAccount(label, runtime, env = process.env) {
+    if (label !== DEFAULT_ACCOUNT_LABEL) {
+        const matches = loadAccounts(env).filter((a) => a.label === label && (!runtime || a.runtime === runtime));
+        if (matches.length === 0) {
+            throw new AccountError(`No account named "${label}" on this machine. Add it first: prohost agent account add ${label} --runtime claude|codex`);
+        }
+    }
+    const credentials = loadCredentials(env);
+    saveCredentials({ ...credentials, account: label }, env);
+}
+/** Whether the registry file exists at all (for `agent list`'s empty state). */
+export function hasRegistry(env = process.env) {
+    return existsSync(registryPath(env));
+}

package/dist/agent/agent_commands.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `prohost agent account …`, `prohost agent list` and
+ * `prohost agent workspace init` — flag plumbing only; the work lives in
+ * `accounts.ts`, `list.ts` and `workspace.ts`.
+ */
+import type { AccountRecord, AuthCheck } from './accounts.js';
+type Flags = Record<string, string | boolean>;
+export interface CommandIO {
+    out: (line: string) => void;
+    err: (line: string) => void;
+    env?: NodeJS.ProcessEnv;
+    /** Sign-in check seam for tests. */
+    check?: (record: AccountRecord) => Promise<AuthCheck>;
+    sleep?: (ms: number) => Promise<void>;
+}
+/** `prohost agent account add|list|remove`. Returns the exit code. */
+export declare function accountCommand(args: string[], flags: Flags, io?: CommandIO): Promise<number>;
+/** `prohost agent list`. */
+export declare function listCommand(io?: CommandIO): Promise<number>;
+/** `prohost agent workspace init --developer --repo <checkout> [--workdir <dir>]`. */
+export declare function workspaceCommand(args: string[], flags: Flags, io?: CommandIO): number;
+export {};

package/dist/agent/agent_commands.js

@@ -0,0 +1,170 @@
+/**
+ * `prohost agent account …`, `prohost agent list` and
+ * `prohost agent workspace init` — flag plumbing only; the work lives in
+ * `accounts.ts`, `list.ts` and `workspace.ts`.
+ */
+import process from 'node:process';
+import { AccountError, addAccount, checkAuth, loadAccounts, parseAccountRuntime, removeAccount, runtimeName, signInCommand, waitForSignIn, } from './accounts.js';
+import { ensureWorkspace } from './credentials.js';
+import { findAgentHomes, renderAgentList } from './list.js';
+import { WorkspaceInitError, initDeveloperWorkspace } from './workspace.js';
+/** How long `account add` waits for the sign-in to land, by default. */
+const DEFAULT_SIGN_IN_WAIT_SECONDS = 600;
+function flagString(flags, name) {
+    const value = flags[name];
+    return typeof value === 'string' ? value : undefined;
+}
+const defaultIO = {
+    out: (line) => process.stdout.write(`${line}\n`),
+    err: (line) => process.stderr.write(`${line}\n`),
+};
+function parseBilling(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === 'subscription' || value === 'api_key' || value === 'api-key') {
+        return value === 'subscription' ? 'subscription' : 'api_key';
+    }
+    return null;
+}
+/** `prohost agent account add|list|remove`. Returns the exit code. */
+export async function accountCommand(args, flags, io = defaultIO) {
+    const [action, label] = args;
+    const env = io.env ?? process.env;
+    const runtimeFlag = flagString(flags, 'runtime');
+    const runtime = parseAccountRuntime(runtimeFlag);
+    if (runtimeFlag !== undefined && !runtime) {
+        io.err('--runtime must be claude or codex.');
+        return 1;
+    }
+    if (action === 'list') {
+        const accounts = loadAccounts(env).filter((a) => !runtime || a.runtime === runtime);
+        if (accounts.length === 0) {
+            io.out('No accounts beyond the default logins. Add one: prohost agent account add <label> --runtime claude|codex');
+            return 0;
+        }
+        const checks = await Promise.all(accounts.map((a) => (io.check ?? ((r) => checkAuth(r)))(a)));
+        accounts.forEach((a, i) => {
+            const state = checks[i].state === 'ok' ? 'signed in' : checks[i].state === 'expired' ? 'signed out' : 'unknown';
+            io.out(`${a.label}  ·  ${runtimeName(a.runtime)}  ·  ${a.billing}  ·  ${state}${a.dir ? `  ·  ${a.dir}` : ''}`);
+        });
+        return 0;
+    }
+    if (action === 'add') {
+        if (!label) {
+            io.err('Usage: prohost agent account add <label> --runtime claude|codex [--billing subscription|api_key]');
+            return 1;
+        }
+        if (!runtime) {
+            io.err('Missing --runtime claude|codex — an account is one Claude Code or one Codex login.');
+            return 1;
+        }
+        const billing = parseBilling(flags.billing);
+        if (billing === null) {
+            io.err('--billing must be subscription or api_key.');
+            return 1;
+        }
+        let record;
+        try {
+            record = addAccount({ label, runtime, billing }, env);
+        }
+        catch (err) {
+            if (err instanceof AccountError) {
+                io.err(`✗ ${err.message}`);
+                return 1;
+            }
+            throw err;
+        }
+        io.out(`✓ Added ${runtimeName(runtime)} account "${label}" (${record.billing}).`);
+        io.out('');
+        io.out('Sign it in — run this in another terminal and finish the login in your browser:');
+        io.out(`  ${signInCommand(record)}`);
+        io.out('');
+        io.out('ProhostAI never sees or stores this login; the agent CLI keeps it in that directory.');
+        if (flags['no-wait'] === true)
+            return 0;
+        const waitSeconds = Number(flagString(flags, 'wait-timeout') ?? DEFAULT_SIGN_IN_WAIT_SECONDS);
+        if (!Number.isFinite(waitSeconds) || waitSeconds < 0) {
+            io.err('--wait-timeout must be a number of seconds.');
+            return 1;
+        }
+        io.out(`Waiting for the sign-in (up to ${Math.round(waitSeconds / 60)} min; Ctrl-C to stop waiting)…`);
+        const result = await waitForSignIn(record, {
+            timeoutMs: waitSeconds * 1000,
+            check: io.check,
+            sleep: io.sleep,
+        });
+        if (result.state === 'ok') {
+            io.out(`✓ "${label}" is signed in.`);
+            io.out(`Use it: prohost agent install-daemon --exec '…' --account ${label}   (or pick it in ProhostAI)`);
+            return 0;
+        }
+        io.err(`! "${label}" is not signed in yet. Run the command above; the account is saved either way.`);
+        return 1;
+    }
+    if (action === 'remove') {
+        if (!label) {
+            io.err('Usage: prohost agent account remove <label> [--runtime claude|codex]');
+            return 1;
+        }
+        const matches = loadAccounts(env).filter((a) => a.label === label && (!runtime || a.runtime === runtime));
+        if (matches.length > 1) {
+            io.err(`Both a Claude Code and a Codex account are named "${label}" — pass --runtime claude|codex.`);
+            return 1;
+        }
+        const target = matches[0];
+        const users = findAgentHomes({ env }).filter((a) => a.account === label);
+        if (target && users.length > 0 && flags.force !== true) {
+            io.err(`✗ "${label}" is used by ${users.map((u) => u.name ?? u.home).join(', ')}. ` +
+                'Move them to another account first, or pass --force.');
+            return 1;
+        }
+        try {
+            removeAccount(label, target?.runtime ?? runtime ?? 'claude_code', env);
+        }
+        catch (err) {
+            if (err instanceof AccountError) {
+                io.err(`✗ ${err.message}`);
+                return 1;
+            }
+            throw err;
+        }
+        io.out(`✓ Removed "${label}" and its login directory.`);
+        return 0;
+    }
+    io.err('Expected: prohost agent account add|list|remove');
+    return 1;
+}
+/** `prohost agent list`. */
+export async function listCommand(io = defaultIO) {
+    for (const line of await renderAgentList({ env: io.env }))
+        io.out(line);
+    return 0;
+}
+/** `prohost agent workspace init --developer --repo <checkout> [--workdir <dir>]`. */
+export function workspaceCommand(args, flags, io = defaultIO) {
+    if (args[0] !== 'init' || flags.developer !== true) {
+        io.err('Usage: prohost agent workspace init --developer --repo <backend-service checkout> [--workdir <dir>]');
+        return 1;
+    }
+    const repo = flagString(flags, 'repo');
+    if (!repo) {
+        io.err('Missing --repo <path to a ProhostAI backend-service checkout>.');
+        return 1;
+    }
+    const workdir = flagString(flags, 'workdir') ?? ensureWorkspace(io.env);
+    try {
+        const result = initDeveloperWorkspace({ workdir, repo });
+        io.out(`✓ Developer workspace ready in ${workdir}`);
+        io.out(`  skill  ${result.skillPath}`);
+        io.out(`  hook   ${result.settingsPath}${result.hookAdded ? '' : ' (already registered)'}`);
+        io.out('The agent reads both when `agent run` starts it in this directory.');
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof WorkspaceInitError) {
+            io.err(`✗ ${err.message}`);
+            return 1;
+        }
+        throw err;
+    }
+}

package/dist/agent/api.d.ts

@@ -9,6 +9,7 @@
  * The paths come from the run event itself (`reply_instructions.path` /
  * `completion.path`), which is why these take a path rather than building one.
  */
+import type { ToolEvent } from './contract.js';
 export interface ApiOptions {
     baseUrl: string;
     apiKey: string;
@@ -139,3 +140,13 @@ export declare function completeRun(options: ApiOptions, path: string, outcome:
     ok: false;
     error: string;
 }, model?: string): Promise<ApiResult>;
+/**
+ * Report a batch of tool events for a run in flight.
+ *
+ * No idempotency key: the server keys rows on `tool_id` and never moves one
+ * backwards, so a repeated batch is harmless by construction. Cheap-call
+ * deadline — a batch is a few small rows, and the run is not waiting on the
+ * answer. The batch is capped here as well as server-side so a caller that
+ * over-fills one gets it clipped rather than rejected whole.
+ */
+export declare function postToolEvents(options: ApiOptions, path: string, events: ToolEvent[]): Promise<ApiResult>;

package/dist/agent/api.js

@@ -10,7 +10,7 @@
  * `completion.path`), which is why these take a path rather than building one.
  */
 import { USER_AGENT } from '../version.js';
-import { MAX_ERROR_CHARS, MAX_MODEL_CHARS, MAX_PROGRESS_CHARS, RUN_STATUS_FAILED, RUN_STATUS_SUCCEEDED, } from './contract.js';
+import { MAX_ERROR_CHARS, MAX_MODEL_CHARS, MAX_PROGRESS_CHARS, MAX_TOOL_EVENTS_PER_BATCH, RUN_STATUS_FAILED, RUN_STATUS_SUCCEEDED, } from './contract.js';
 /** Deadline for the cheap calls — a heartbeat answers in milliseconds. */
 export const DEFAULT_TIMEOUT_MS = 30_000;
 /**
@@ -185,3 +185,15 @@ export async function completeRun(options, path, outcome, model) {
         return { ...result, ok: true };
     return result;
 }
+/**
+ * Report a batch of tool events for a run in flight.
+ *
+ * No idempotency key: the server keys rows on `tool_id` and never moves one
+ * backwards, so a repeated batch is harmless by construction. Cheap-call
+ * deadline — a batch is a few small rows, and the run is not waiting on the
+ * answer. The batch is capped here as well as server-side so a caller that
+ * over-fills one gets it clipped rather than rejected whole.
+ */
+export async function postToolEvents(options, path, events) {
+    return post(options, path, { events: events.slice(0, MAX_TOOL_EVENTS_PER_BATCH) });
+}