@oh-hai/cli 0.1.0-beta.0

package/dist/cli.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+// The `oh-hai` entrypoint (docs/specs/cli.md §4). It stays thin: parse global flags →
+// handle --help / --version → dispatch. Every command now has a real body wired through the
+// command-handler registry (auth #106, messaging #107, agents #209, doctor #108); the honest
+// not-implemented stub (§7 exit 1, §8 `not_implemented` envelope) remains a defensive fallback
+// for any future registry entry added without a handler. A thrown CliError is translated once
+// here into the §7 exit code and, under --json, the §8 failure envelope.
+import { realpathSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { openStore } from "./auth/token-store.js";
+import { GLOBAL_OPTIONS, flagOn } from "./commands/flags.js";
+import { COMMAND_HANDLERS } from "./commands/handlers.js";
+import { findCommand } from "./commands/registry.js";
+import { notImplemented } from "./commands/stub.js";
+import { resolveConfig } from "./config.js";
+import { loadConfigFiles, nodeConfigFileIo } from "./config-file.js";
+import { CliError, buildErr, buildOk, serializeEnvelope } from "./envelope.js";
+import { ExitCode } from "./exit-codes.js";
+import { TOP_LEVEL_HELP } from "./help.js";
+import { MA2H_WIRE_VERSION, cliVersion } from "./version.js";
+export { flagOn } from "./commands/flags.js";
+// Node's console methods are bound to the console instance, so they can be used directly.
+const consoleIo = { log: console.log, err: console.error };
+/** Read all of stdin as a UTF-8 string (the production `login --token-stdin` reader). */
+async function readAllStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+/** Read a single line from stdin (the production interactive-prompt reader). Resolves on the first
+ *  newline (Enter) rather than waiting for EOF, so an interactive `agents revoke` confirm doesn't
+ *  hang; returns "" if stdin closes with no line. */
+async function readOneStdinLine() {
+    const rl = createInterface({ input: process.stdin });
+    try {
+        for await (const line of rl) {
+            return line;
+        }
+        return "";
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Production runtime dependencies — the real keychain-or-file store, stdin, and fetch. Tests
+ *  pass their own to `run()` so no command touches the real keychain, stdin, or network. */
+const productionRuntime = {
+    openStore,
+    readStdin: readAllStdin,
+    readLine: readOneStdinLine,
+    fetchImpl: (url, init) => fetch(url, init),
+    loadConfigFiles: () => loadConfigFiles(nodeConfigFileIo()),
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    // A write-callback barrier: a zero-length write whose callback fires only AFTER every
+    // previously-queued stdout write has been flushed (stream writes complete in order). `inbox watch`
+    // awaits this before acking, so a directive still sitting in Node's stdout buffer can't be consumed
+    // by the Hub before it reaches the consumer. `writableNeedDrain` alone is insufficient — it's false
+    // for a queued-but-below-high-water-mark write. On a write error (e.g. EPIPE — the consumer closed
+    // the pipe) the barrier rejects, so the loop exits WITHOUT acking an undelivered directive.
+    flushOutput: () => new Promise((resolve, reject) => process.stdout.write("", (err) => (err ? reject(err) : resolve()))),
+};
+/**
+ * True when `moduleUrl`'s file is the process entrypoint. Compares REAL paths (resolving
+ * symlinks) so a bin installed as a symlink by npm/Homebrew — where `process.argv[1]` is the
+ * symlink but `import.meta.url` is the resolved target — is still recognized as the entry.
+ */
+export function isMainModule(invokedPath, moduleUrl) {
+    if (invokedPath === undefined) {
+        return false;
+    }
+    try {
+        return realpathSync(invokedPath) === realpathSync(fileURLToPath(moduleUrl));
+    }
+    catch {
+        return false;
+    }
+}
+/** Map parsed global flags to the config resolver's `RawFlags` shape (§6). */
+function toRawFlags(values) {
+    const str = (v) => (typeof v === "string" ? v : undefined);
+    const timeoutRaw = str(values.timeout);
+    const timeoutMs = timeoutRaw !== undefined ? Number.parseInt(timeoutRaw, 10) : undefined;
+    return {
+        baseUrl: str(values["base-url"]),
+        account: str(values.account) ?? str(values.agent),
+        // Tristate: undefined when --json is absent (config `output` may then decide), true/false when
+        // explicitly set — so an explicit --json=false can override a configured `output = "json"`.
+        json: values.json === undefined ? undefined : flagOn(values.json),
+        noColor: flagOn(values["no-color"]),
+        timeoutMs: timeoutMs !== undefined && Number.isFinite(timeoutMs) && timeoutMs >= 0 ? timeoutMs : undefined,
+    };
+}
+/** Reject a malformed `--timeout` as a usage error (§7 exit 2) rather than letting a negative
+ *  value reach `AbortSignal.timeout(-1)`, which throws and would surface as a generic exit 1. */
+function validateTimeoutFlag(values) {
+    const raw = values.timeout;
+    if (typeof raw !== "string")
+        return;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new CliError("usage", `invalid --timeout '${raw}': must be a non-negative integer (milliseconds).`);
+    }
+}
+/** The `MA2H_*` subset of the environment the config resolver consumes (§6). */
+function toEnvVars(env) {
+    return {
+        MA2H_BASE_URL: env.MA2H_BASE_URL,
+        MA2H_AGENT_ID: env.MA2H_AGENT_ID,
+        MA2H_AGENT_TOKEN: env.MA2H_AGENT_TOKEN,
+        MA2H_TIMEOUT_MS: env.MA2H_TIMEOUT_MS,
+        NO_COLOR: env.NO_COLOR,
+    };
+}
+/**
+ * Run the CLI for the given argv (excluding node + script path) and return the process
+ * exit code. Never calls process.exit — the caller sets `process.exitCode`. `runtime` is
+ * injectable so command tests stay hermetic.
+ */
+export async function run(argv, io = consoleIo, runtime = productionRuntime) {
+    let json = false;
+    let commandLabel = "oh-hai";
+    try {
+        const { values, positionals } = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            strict: false,
+            options: GLOBAL_OPTIONS,
+        });
+        json = flagOn(values.json);
+        // Under --json, stdout is reserved for the envelope (§8), so help text goes to stderr.
+        const emitHelp = (text) => {
+            if (json) {
+                io.err(text);
+            }
+            else {
+                io.log(text);
+            }
+        };
+        // --version wins, before help or dispatch.
+        if (flagOn(values.version)) {
+            if (json) {
+                io.log(serializeEnvelope(buildOk("version", { version: cliVersion(), wire_version: MA2H_WIRE_VERSION })));
+            }
+            else {
+                io.log(cliVersion());
+            }
+            return ExitCode.SUCCESS;
+        }
+        const command = positionals[0];
+        // No command (bare invocation or top-level --help) → top-level help. Under
+        // noUncheckedIndexedAccess, `command === undefined` is exactly "no positionals".
+        if (command === undefined) {
+            emitHelp(TOP_LEVEL_HELP);
+            return ExitCode.SUCCESS;
+        }
+        commandLabel = command;
+        // Resolve config (§6) as soon as a command is NAMED — valid or not — so a config-selected output
+        // format applies uniformly to every command path: the unknown-command error, per-command --help,
+        // the not-implemented decline, and real handlers (matching --json, which already reaches them all).
+        // Pure meta flags (--version, bare / top-level --help) returned above, so they stay config-free —
+        // no config I/O or credential warnings on a bare `oh-hai` or `oh-hai --version`. `warnings` carries
+        // the credential-safety rejections (a per-project config that tried to set base_url / account) —
+        // surfaced on stderr so they never pollute the --json envelope on stdout.
+        const { userConfig, projectConfig } = runtime.loadConfigFiles();
+        const { config, warnings } = resolveConfig({
+            flags: toRawFlags(values),
+            env: toEnvVars(process.env),
+            userConfig,
+            projectConfig,
+        });
+        for (const warning of warnings) {
+            io.err(`oh-hai: ${warning}`);
+        }
+        // `output = "json"` implies the machine envelope even without --json. Set it before any error can
+        // throw so the catch-block error envelope (an unknown command, a bad --timeout, a stub decline)
+        // respects the configured format too. `config.output` already folds in the --json flag.
+        json = config.output === "json";
+        const spec = findCommand(command);
+        if (spec === undefined) {
+            throw new CliError("usage", `unknown command: ${command}. Run 'oh-hai --help'.`);
+        }
+        // Resolve the subcommand and set the §8 command label ("ask.submit" / "agents.list") for BOTH
+        // implemented handlers and the stub, so a command's success AND failure (`--json`) envelopes agree
+        // on `command`. strict:false pollutes positionals with the values of command-specific flags, so
+        // pick the first positional that IS a known subcommand rather than a bare positionals[1].
+        const sub = spec.subcommands.length > 0
+            ? positionals.slice(1).find((token) => spec.subcommands.includes(token))
+            : undefined;
+        commandLabel = sub !== undefined ? `${spec.name}.${sub}` : spec.name;
+        // Per-command help.
+        if (flagOn(values.help)) {
+            emitHelp(spec.help);
+            return ExitCode.SUCCESS;
+        }
+        // Implemented commands (login / logout / whoami, #106; notify / ask / task, #107; agents, #209;
+        // doctor, #108) dispatch to their handler with the resolved config + injected runtime. The handler
+        // parses its own command-specific flags (and, for subcommand commands, re-derives the subcommand
+        // from its argv). A handler normally resolves to `void` → exit 0; `doctor` instead RETURNS a
+        // numeric exit code so it can print its full checks report AND exit non-zero on a failed required
+        // check (a throw would replace the `--json` checks envelope with a `buildErr` one).
+        const handler = COMMAND_HANDLERS[spec.name];
+        if (handler !== undefined) {
+            validateTimeoutFlag(values);
+            const result = await handler({ io, json, config, runtime, argv });
+            return typeof result === "number" ? result : ExitCode.SUCCESS;
+        }
+        // Not-yet-implemented commands route to the stub.
+        const display = sub !== undefined ? `${spec.name} ${sub}` : spec.name;
+        notImplemented(display, spec.issue);
+    }
+    catch (error) {
+        const cliError = error instanceof CliError
+            ? error
+            : new CliError("error", error instanceof Error ? error.message : String(error));
+        if (json) {
+            io.log(serializeEnvelope(buildErr(commandLabel, cliError.code, cliError.message)));
+        }
+        else {
+            io.err(`oh-hai: ${cliError.message}`);
+        }
+        return cliError.exitCode;
+    }
+    // Unreachable: the dispatch path ends in notImplemented() (throws) or a handler return.
+    // Present so the function has a definite ending return under strict TS.
+    return ExitCode.SUCCESS;
+}
+async function main() {
+    process.exitCode = await run(process.argv.slice(2));
+}
+// Run only when executed as the binary (not when imported by tests).
+if (isMainModule(process.argv[1], import.meta.url)) {
+    void main();
+}
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/commands/agents.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "./context.js";
+export declare function agentsCommand(ctx: CommandContext): Promise<void>;

package/dist/commands/agents.js

@@ -0,0 +1,370 @@
+// `oh-hai agents` (docs/specs/cli.md §4.5). Account / identity management — the OPERATOR (human)
+// leg of the CLI, over the per-account agent-token API shipped in #96 (server/src/routes/agents.ts,
+// every route `requireHuman`):
+//   - `list`   — enumerate the account's agent identities (metadata only, never a token).
+//   - `create` — mint a new identity + its bearer, storing the bearer Hub-scoped exactly like
+//                `login`. The token is NEVER printed and `--token-stdout` is not offered (§5.4).
+//   - `revoke` — revoke an identity server-side and scrub its local credential like `logout`.
+//
+// The command sends the resolved OPERATOR bearer (resolveIdentity, as `whoami` does) and faithfully
+// surfaces the Hub's `403 human session required` when the presented credential is an agent token —
+// acquiring a human session is out of scope here (#209). This is the counterpart to the notify/ask/
+// task messaging leg (#107), which speaks the agent surface.
+//
+// HTTP is self-contained (a small authenticated fetch + `readJson` + a status→§7 exit-code mapping),
+// mirroring the private copies in commands/login.ts and the deliberate duplication in
+// commands/messaging/http.ts (#107) — kept local so this command merges independently of that PR.
+// Only the transport-error → exit-code mapping is shared (commands/http.ts). A future
+// shared CLI-core package could unify the duplicated readers (distinct from `@oh-hai/ma2h-core`,
+// the protocol crypto/lifecycle/validation core, which does not hold these HTTP readers).
+import { parseArgs } from "node:util";
+import { originOf, resolveIdentity } from "../auth/resolve-token.js";
+import { CliError, buildOk, serializeEnvelope } from "../envelope.js";
+import { sanitizeForTerminal } from "../terminal.js";
+import { GLOBAL_OPTIONS, flagOn } from "./flags.js";
+import { throwTransportError } from "./http.js";
+const SUBCOMMANDS = ["list", "create", "revoke"];
+/** The agents-specific flags layered on the globals: `--label` (create), `--target-agent` + `--yes`
+ *  (revoke). Declared here rather than in flags.ts so #209 doesn't collide with the sibling #107 PR
+ *  that owns flags.ts changes. */
+const AGENTS_OPTIONS = {
+    label: { type: "string" },
+    "target-agent": { type: "string" },
+    yes: { type: "boolean" },
+};
+/** Default per-request bound when no `--timeout`/`MA2H_TIMEOUT_MS` is set — matches the other
+ *  network commands so an unresponsive Hub can't hang a command indefinitely (§9). */
+const DEFAULT_TIMEOUT_MS = 10_000;
+const NOT_AUTHENTICATED = "not authenticated — no stored token (run `oh-hai login`, or set MA2H_AGENT_TOKEN).";
+export async function agentsCommand(ctx) {
+    const { subcommand, values } = parseAgentsArgs(ctx.argv);
+    // Each branch validates its own flags FIRST (a bad invocation is a usage error, exit 2, before we
+    // touch credentials or the Hub), then resolves the operator bearer, then does its network work.
+    switch (subcommand) {
+        case "list": {
+            const { token } = await resolveOperator(ctx);
+            return listAgents(ctx, token);
+        }
+        case "create": {
+            const label = requireFlag(values.label, "agents create requires --label <label>.");
+            const { token, store } = await resolveOperator(ctx);
+            return createAgent(ctx, token, store, label);
+        }
+        case "revoke": {
+            // --target-agent is distinct from the global operator --account/--agent, so an operator can
+            // revoke a DIFFERENT agent unambiguously (§4.5).
+            const targetId = requireFlag(values["target-agent"], "agents revoke requires --target-agent <id>.");
+            const yes = flagOn(values.yes);
+            if (ctx.json && !yes) {
+                throw new CliError("usage", "refusing to revoke without --yes under --json (interactive confirmation is unavailable in machine mode).");
+            }
+            const { token, store } = await resolveOperator(ctx);
+            if (!yes && !(await promptConfirm(ctx, targetId))) {
+                ctx.io.err("Aborted — no changes made.");
+                return;
+            }
+            return revokeAgent(ctx, token, store, targetId);
+        }
+    }
+}
+/** Resolve the OPERATOR bearer the way `whoami` does (env token wins; else an explicit --account,
+ *  else zero-config sole-identity discovery). The store is opened only when the CI env token is
+ *  absent (skip probing the OS keychain otherwise); it rides along so create/revoke can write/delete
+ *  the local credential without re-opening. A missing token is an auth error (exit 3). */
+async function resolveOperator(ctx) {
+    const store = ctx.config.tokenSource === "env" ? undefined : await ctx.runtime.openStore();
+    const { token } = await resolveIdentity(ctx.config, store);
+    if (token === undefined) {
+        throw new CliError("auth", NOT_AUTHENTICATED);
+    }
+    return { token, store };
+}
+/** The store to write/delete a local credential in: reuse the operator-resolution store, or open one
+ *  on demand — `list` (and the env-token path) skips opening it, but create/revoke must write/delete
+ *  locally regardless. */
+async function ensureStore(ctx, store) {
+    return store ?? (await ctx.runtime.openStore());
+}
+// --- argument parsing -------------------------------------------------------
+/** Parse argv for the agents command: global flags + the agents-specific flags, then extract the
+ *  required subcommand operand. Mirrors `parseCommandArgs`'s unknown-flag rejection (a typo is a
+ *  usage error, not a silently-ignored flag). Kept self-contained; a follow-up can dedupe onto
+ *  #107's `parseSubcommandArgs` once both PRs land. */
+function parseAgentsArgs(argv) {
+    const options = { ...GLOBAL_OPTIONS, ...AGENTS_OPTIONS };
+    const parsed = parseArgs({ args: argv, allowPositionals: true, strict: false, options });
+    const allowed = new Set(Object.keys(options));
+    for (const key of Object.keys(parsed.values)) {
+        if (!allowed.has(key)) {
+            throw new CliError("usage", `unknown flag: --${key}. Run 'oh-hai agents --help'.`);
+        }
+    }
+    // positionals[0] is the command token ("agents"); positionals[1] MUST be a known subcommand.
+    // With correct option types no flag value leaks into positionals, so exactly [agents, sub] is
+    // expected — a missing subcommand, an unknown one, or an extra operand is a usage error (exit 2).
+    const subcommand = parsed.positionals[1];
+    if (subcommand === undefined) {
+        throw new CliError("usage", `missing subcommand: expected one of ${SUBCOMMANDS.join(" | ")}.`);
+    }
+    if (!isSubcommand(subcommand)) {
+        throw new CliError("usage", `unknown subcommand: ${subcommand} (expected ${SUBCOMMANDS.join(" | ")}).`);
+    }
+    if (parsed.positionals.length > 2) {
+        throw new CliError("usage", `unexpected argument: ${parsed.positionals[2]}.`);
+    }
+    return { subcommand, values: parsed.values };
+}
+function isSubcommand(value) {
+    return SUBCOMMANDS.includes(value);
+}
+/** Extract a required non-empty flag value (trimmed), or throw a usage error (exit 2) with `message`
+ *  — validated locally, before any Hub call. Used for create's `--label` and revoke's
+ *  `--target-agent`. A repeated flag is an array (last wins); a non-string/absent value is the empty
+ *  string, which trips the usage error. */
+function requireFlag(raw, message) {
+    const raw1 = Array.isArray(raw) ? raw[raw.length - 1] : raw;
+    const value = typeof raw1 === "string" ? raw1.trim() : "";
+    // Empty → the flag is missing. A `--`-prefixed value means the flag's argument was omitted and the
+    // NEXT long-option token was swallowed as its value under `strict:false` — whether a real flag
+    // (`--label --json`) or a typo (`--label --jsoon`) — so reject it rather than mint/revoke against
+    // "--jsoon". A single-dash value (`-prod`, or `--label=-prod`) is a legitimate label and is allowed.
+    if (value === "" || value.startsWith("--")) {
+        throw new CliError("usage", message);
+    }
+    return value;
+}
+/** Interactive revoke confirmation (only reached in human mode without `--yes`; the `--json`+no-`--yes`
+ *  case is rejected up-front). Prompt on stderr and read a SINGLE line via `readLine` — a TTY prompt
+ *  must resolve on Enter, not block until EOF the way `readStdin` (built for `login --token-stdin`)
+ *  would. Falls back to `readStdin` for harnesses that don't inject `readLine`. */
+async function promptConfirm(ctx, targetId) {
+    ctx.io.err(`About to revoke agent ${sanitizeForTerminal(targetId)} — this cannot be undone.`);
+    ctx.io.err('Type "y" to confirm: ');
+    const readOne = ctx.runtime.readLine ?? ctx.runtime.readStdin;
+    const answer = (await readOne()).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+}
+async function listAgents(ctx, token) {
+    const res = await authFetch(ctx, "GET", "/v1/agents", token);
+    if (res.status !== 200) {
+        throw hubStatusToCliError(res.status, await readErrorMessage(res));
+    }
+    const body = await readJson(res);
+    // Distinguish a genuinely EMPTY account (`agents: []`) from a MALFORMED response (missing / non-array
+    // `agents`, which `readJson` also collapses toward `{}`): silently showing "No agents." for the
+    // latter would hide a Hub/proxy regression from the operator. Treat non-array as a server error.
+    if (!Array.isArray(body.agents)) {
+        throw new CliError("server", "the Hub returned a malformed agent list (missing `agents` array).");
+    }
+    const agents = body.agents.map(toAgentView);
+    if (ctx.json) {
+        // The §4.5 contract is exactly { id, label, created_at, last_used_at, revoked } — toAgentView
+        // already projected the Hub's extra `account_id` out. Ids/labels are emitted raw; JSON.stringify
+        // escapes any control character so nothing reaches the terminal unescaped (§5.4).
+        ctx.io.log(serializeEnvelope(buildOk("agents.list", { agents })));
+        return;
+    }
+    if (agents.length === 0) {
+        ctx.io.log("No agents.");
+        return;
+    }
+    // Human table: fields are already terminal-safe (toAgentView sanitized every server string); widths
+    // from the data. Absent timestamps render as an em dash.
+    const rows = agents.map((a) => ({
+        id: a.id,
+        label: a.label,
+        status: a.revoked ? "revoked" : "active",
+        created: a.created_at ?? "—",
+        lastUsed: a.last_used_at ?? "—",
+    }));
+    const display = [{ id: "ID", label: "LABEL", status: "STATUS", created: "CREATED", lastUsed: "LAST-USED" }, ...rows];
+    const idW = Math.max(...display.map((r) => r.id.length));
+    const labelW = Math.max(...display.map((r) => r.label.length));
+    const statusW = Math.max(...display.map((r) => r.status.length));
+    const createdW = Math.max(...display.map((r) => r.created.length));
+    for (const r of display) {
+        ctx.io.log(`${r.id.padEnd(idW)}  ${r.label.padEnd(labelW)}  ${r.status.padEnd(statusW)}  ${r.created.padEnd(createdW)}  ${r.lastUsed}`);
+    }
+}
+async function createAgent(ctx, token, store, label) {
+    // 1) Mint the identity.
+    const createRes = await authFetch(ctx, "POST", "/v1/agents", token, { label });
+    if (createRes.status !== 201) {
+        throw hubStatusToCliError(createRes.status, await readErrorMessage(createRes));
+    }
+    const createBody = await readJson(createRes);
+    const agent = createBody.agent !== null && typeof createBody.agent === "object"
+        ? createBody.agent
+        : {};
+    const rawId = str(agent.id);
+    if (rawId === undefined) {
+        throw new CliError("server", "the Hub created the agent but returned no id (unexpected response).");
+    }
+    // Sanitize the server-supplied id ONCE here, so the store key, token-mint URL, the `--json`
+    // envelope, and the human line all use the same terminal-safe value — `JSON.stringify` doesn't
+    // escape C1 controls, so an unsanitized id would inject into `agents create --json` too (§5.4).
+    const agentId = sanitizeForTerminal(rawId);
+    // From here the identity EXISTS server-side. Minting its bearer (returned exactly once) or storing
+    // it locally can still fail, leaving a tokenless/orphaned identity the operator can neither use nor
+    // easily notice. On ANY such failure, tell them which agent to clean up — never the token (§5.4) —
+    // then surface the original error.
+    try {
+        // 2) Mint its bearer (the raw secret is returned exactly once).
+        const tokenRes = await authFetch(ctx, "POST", `/v1/agents/${encodeURIComponent(agentId)}/tokens`, token, { label });
+        if (tokenRes.status !== 201) {
+            throw hubStatusToCliError(tokenRes.status, await readErrorMessage(tokenRes));
+        }
+        const tokenBody = await readJson(tokenRes);
+        const minted = str(tokenBody.token);
+        if (minted === undefined) {
+            throw new CliError("server", "the Hub minted the token but returned no secret (unexpected response).");
+        }
+        // Guard against a malformed mint binding the token to a DIFFERENT agent than we created: storing
+        // it under our agentId would later authenticate as someone else and fail the Hub's agent-id check
+        // on ingest. A conformant response echoes `agent_id`; require it to match before writing.
+        if (str(tokenBody.agent_id) !== agentId) {
+            throw new CliError("server", "the Hub minted the token for a different agent than was created (unexpected response).");
+        }
+        // 3) Store the bearer Hub-scoped, exactly like `login` — never printed (§5.4).
+        const writeStore = await ensureStore(ctx, store);
+        await writeStore.set(originOf(ctx.config.baseUrl), agentId, minted);
+        if (ctx.json) {
+            ctx.io.log(serializeEnvelope(buildOk("agents.create", { agent_id: agentId, label, storage: writeStore.backendName })));
+        }
+        else {
+            ctx.io.log(`Created agent "${sanitizeForTerminal(label)}" (${agentId}) — token stored in ${writeStore.backendName}.`);
+        }
+    }
+    catch (error) {
+        ctx.io.err(`oh-hai: agent ${sanitizeForTerminal(agentId)} was created but its token could not be minted or stored — ` +
+            `revoke it with \`oh-hai agents revoke --target-agent ${sanitizeForTerminal(agentId)}\`.`);
+        throw error;
+    }
+}
+async function revokeAgent(ctx, token, store, targetId) {
+    const res = await authFetch(ctx, "DELETE", `/v1/agents/${encodeURIComponent(targetId)}`, token);
+    if (res.status !== 204) {
+        // 404 → not_found (exit 4) via the uniform mapping, using the Hub's "unknown agent" message.
+        throw hubStatusToCliError(res.status, await readErrorMessage(res));
+    }
+    // The Hub 204 is authoritative; scrub the local credential like `logout` (including when the
+    // target is the resolved operator account). Best-effort — a local-delete failure must not fail the
+    // command, since the token is already dead server-side.
+    const delStore = await ensureStore(ctx, store);
+    let localRemoved = false;
+    try {
+        localRemoved = await delStore.delete(originOf(ctx.config.baseUrl), targetId);
+    }
+    catch (error) {
+        ctx.io.err(`oh-hai: revoked on the Hub, but failed to remove the local token: ${error instanceof Error ? sanitizeForTerminal(error.message) : "unknown error"}.`);
+    }
+    if (ctx.json) {
+        ctx.io.log(serializeEnvelope(buildOk("agents.revoke", { agent_id: targetId, revoked: true })));
+    }
+    else {
+        ctx.io.log(`Revoked agent ${sanitizeForTerminal(targetId)}.${localRemoved ? " Local token removed." : ""}`);
+    }
+}
+// --- self-contained Hub HTTP (see file header) ------------------------------
+/** An authenticated request to the Hub over the injected `fetchImpl`. Attaches the operator bearer,
+ *  sets `Content-Type` only when there's a body, bounds the request with the configured timeout, and
+ *  maps a transport failure (before any HTTP response) to the right §7 exit code. */
+async function authFetch(ctx, method, path, token, body) {
+    const headers = { Authorization: `Bearer ${token}` };
+    if (body !== undefined) {
+        headers["Content-Type"] = "application/json";
+    }
+    const init = {
+        method,
+        headers,
+        ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        signal: AbortSignal.timeout(ctx.config.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+    };
+    try {
+        return await ctx.runtime.fetchImpl(`${ctx.config.baseUrl}${path}`, init);
+    }
+    catch (error) {
+        // A per-request timeout is exit 7 (§7); a DNS/connection failure is exit 5 (§9).
+        throwTransportError(error, ctx.config.baseUrl);
+    }
+}
+/** Project the Hub's agent row to the §4.5 CLI contract (dropping the extra `account_id`). Every
+ *  server-supplied string is sanitized HERE, at the projection boundary — the `--json` envelope is
+ *  printed to the terminal too and `JSON.stringify` does NOT escape C1 controls (U+0080–U+009F), so a
+ *  hostile Hub could otherwise inject escape sequences via any field in `agents list --json` (§5.4).
+ *  Defensive about field types so a malformed Hub row can't crash the render. */
+function toAgentView(raw) {
+    const r = raw !== null && typeof raw === "object" ? raw : {};
+    const clean = (value) => {
+        const s = str(value);
+        return s === undefined ? null : sanitizeForTerminal(s);
+    };
+    // `id` is required — a blank/defaulted id can't be used for a follow-up revoke and would let a
+    // malformed Hub/proxy row masquerade as a real agent. Reject the row rather than default it.
+    const id = clean(r.id);
+    if (id === null) {
+        throw new CliError("server", "the Hub returned a malformed agent row (missing id).");
+    }
+    return {
+        id,
+        label: clean(r.label) ?? "",
+        created_at: clean(r.created_at),
+        last_used_at: clean(r.last_used_at),
+        revoked: r.revoked === true,
+    };
+}
+/** Parse a response body as a JSON object, defensively — a fake without `json()`, a non-JSON body,
+ *  or a non-object (array / string / null) all collapse to `{}`, so callers read fields off a plain
+ *  record without unchecked casts. */
+async function readJson(res) {
+    if (typeof res.json !== "function")
+        return {};
+    try {
+        const parsed = await res.json();
+        return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Read the A2H error envelope `{ error: { message } }` from a non-success response, else undefined. */
+async function readErrorMessage(res) {
+    const body = await readJson(res);
+    const error = body.error;
+    const record = error !== null && typeof error === "object" ? error : {};
+    return str(record.message);
+}
+/** Map a Hub HTTP status to the right §7 exit code (via its stable `error.code` string, §8),
+ *  preferring the server's message. The message is stripped of terminal control characters — the
+ *  top-level catch prints a CliError's message to the terminal, so a hostile Hub could otherwise
+ *  inject escape sequences (§5.4). */
+function hubStatusToCliError(status, message) {
+    const detail = message !== undefined ? sanitizeForTerminal(message) : `Hub returned ${status}.`;
+    if (status === 401 || status === 403)
+        return new CliError("auth", detail);
+    if (status === 404)
+        return new CliError("not_found", detail);
+    if (status === 409)
+        return new CliError("conflict", detail);
+    if (status === 413)
+        return new CliError("payload_too_large", detail);
+    if (status === 422)
+        return new CliError("validation_error", detail);
+    if (status === 400)
+        return new CliError("bad_request", detail);
+    if (status >= 500)
+        return new CliError("server", detail);
+    return new CliError("error", detail);
+}
+/** A trimmed non-empty string from an unknown field, else undefined — validates a server-supplied
+ *  field's type and drops empties/whitespace so a padded value never rides into a key or the output.
+ *  Matches login.ts:str (the two files' HTTP readers are deliberate duplicates; see file header). */
+function str(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed === "" ? undefined : trimmed;
+}
+//# sourceMappingURL=agents.js.map