agentrun-cli 0.1.0

package/README.md

@@ -0,0 +1,66 @@
+# agentrun CLI
+
+Push, run, and talk to [Agentrun](https://agentrun.dev) agents from the terminal, and expose them to Claude Code, Cursor, Codex, or any MCP client.
+
+```
+npm install -g agentrun-cli
+agentrun login            # paste a workspace API key from Settings, API keys
+agentrun init             # writes agentrun.yaml in the current directory
+agentrun push             # creates or updates the agent from it
+agentrun run my-agent "Summarize the open incidents" --wait
+```
+
+## The manifest
+
+`agentrun.yaml` at the root of a repo is the whole agent:
+
+```yaml
+name: incident-triage
+model: openrouter/qwen/qwen3-coder
+timeout_minutes: 15
+connectors: [pagerduty, github, slack]   # accounts it acts through, connected once per workspace
+instructions: |
+  You are the on-call triage agent. When given an alert, read the incident,
+  find the related deploys and errors, and post a short summary to the channel.
+```
+
+`instructions_file: AGENTS.md` works instead of inline instructions. If the directory is a git checkout with a GitHub origin, `push` records that repo and every run clones it, so skills, scripts, and files next to the manifest travel with the agent. Set `repo:` explicitly to override.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `agentrun login [--key ar_…] [--url …]` | Stores the key in `~/.config/agentrun/config.json` (mode 600). `AGENTRUN_API_KEY` and `AGENTRUN_URL` override it. |
+| `agentrun whoami` | Workspace, user, role, plan behind the key. |
+| `agentrun init [--name n] [--model provider/model]` | Writes a starter manifest. |
+| `agentrun push [dir]` | Create-or-update the agent named in the manifest. Idempotent. |
+| `agentrun agents` | List agents with model and connectors. |
+| `agentrun run <agent> <task…> [--wait] [--json]` | Start a run. `--wait` streams events and prints the result; exit code 1 on failure. |
+| `agentrun logs <run-id> [--follow]` | Events of a run. |
+| `agentrun send <run-id> <text…>` | Message a running or waiting run; a finished run continues as a new run with the earlier context. |
+| `agentrun cancel <run-id>` | Cancel. |
+| `agentrun mcp` | MCP server over stdio. |
+
+## MCP
+
+Add to Claude Code:
+
+```
+claude mcp add agentrun -- agentrun mcp
+```
+
+Cursor, Codex, and others take the same command in their MCP config:
+
+```json
+{ "mcpServers": { "agentrun": { "command": "agentrun", "args": ["mcp"] } } }
+```
+
+Tools: `list_agents`, `run_agent` (with `wait` to block for the result), `get_run`, `list_runs`, `send_message`, `cancel_run`, `wait_for_run`. A coding agent can hand a task to one of your Agentrun agents and read the answer back in the same session.
+
+## Development
+
+```
+npm install
+npm run build          # tsc -> dist/
+node dist/cli.js help
+```

package/dist/cli.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+import { ApiError, Client, TERMINAL, follow } from "./client.js";
+import { DEFAULT_URL, readConfig, requireConfig, writeConfig } from "./config.js";
+import { loadManifest, writeManifest } from "./manifest.js";
+const HELP = `agentrun — run agents from the terminal
+
+  agentrun login [--key ar_…] [--url https://app.agentrun.dev]   store a workspace API key
+  agentrun whoami                                                 show the workspace this key belongs to
+  agentrun init [--name n] [--model provider/model]               write an agentrun.yaml here
+  agentrun push [dir]                                             create or update the agent from agentrun.yaml
+  agentrun agents                                                 list agents
+  agentrun run <agent> <task…> [--wait] [--json]                  start a run (and follow it with --wait)
+  agentrun logs <run-id> [--follow]                               print a run's events
+  agentrun send <run-id> <text…>                                  message a running, waiting, or finished run
+  agentrun cancel <run-id>
+  agentrun mcp                                                    serve the MCP server over stdio
+
+Environment: AGENTRUN_API_KEY, AGENTRUN_URL override the stored config.`;
+function parse(argv) {
+    const [cmd = "help", ...rest] = argv;
+    const args = [];
+    const flags = {};
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a.startsWith("--")) {
+            const [k, v] = a.slice(2).split("=", 2);
+            if (v !== undefined)
+                flags[k] = v;
+            else if (rest[i + 1] && !rest[i + 1].startsWith("--") && ["key", "url", "name", "model"].includes(k))
+                flags[k] = rest[++i];
+            else
+                flags[k] = true;
+        }
+        else
+            args.push(a);
+    }
+    return { cmd, args, flags };
+}
+const ts = (ms) => new Date(ms).toISOString().slice(11, 19);
+const money = (n) => `$${(n ?? 0).toFixed(3)}`;
+function printEvents(events) {
+    for (const e of events) {
+        const tag = e.kind.padEnd(6);
+        const body = e.kind === "text" ? e.text : e.text.replace(/\n/g, "\n              ");
+        process.stdout.write(`${ts(e.ts)} ${tag} ${body}\n`);
+    }
+}
+async function main() {
+    const { cmd, args, flags } = parse(process.argv.slice(2));
+    switch (cmd) {
+        case "help":
+        case "--help":
+        case "-h":
+            console.log(HELP);
+            return;
+        case "login": {
+            const url = String(flags.url ?? readConfig().url ?? DEFAULT_URL).replace(/\/$/, "");
+            let key = typeof flags.key === "string" ? flags.key : "";
+            if (!key) {
+                const { createInterface } = await import("node:readline/promises");
+                const rl = createInterface({ input: process.stdin, output: process.stderr });
+                key = (await rl.question(`API key for ${url} (Settings, API keys): `)).trim();
+                rl.close();
+            }
+            if (!key.startsWith("ar_"))
+                throw new Error("That does not look like an Agentrun API key (they start with ar_).");
+            const me = await new Client({ url, key }).me();
+            const file = writeConfig({ url, key });
+            console.log(`Logged in to ${me.org.name} as ${me.user.email} (${me.role}). Saved to ${file}.`);
+            return;
+        }
+        case "whoami": {
+            const me = await new Client(requireConfig()).me();
+            console.log(`${me.org.name} (${me.org.id}) · ${me.user.email} · ${me.role} · plan ${me.org.plan}`);
+            return;
+        }
+        case "init": {
+            const name = String(flags.name ?? process.cwd().split("/").pop()?.toLowerCase().replace(/[^a-z0-9-]+/g, "-") ?? "my-agent");
+            const path = writeManifest(process.cwd(), { name, model: String(flags.model ?? "openrouter/qwen/qwen3-coder") });
+            console.log(`Wrote ${path}. Edit it, then \`agentrun push\`.`);
+            return;
+        }
+        case "push": {
+            const client = new Client(requireConfig());
+            const { path, manifest } = loadManifest(args[0] ?? process.cwd());
+            const res = await client.upsertAgent(manifest.name, { model: manifest.model, instructions: manifest.instructions, repo: manifest.repo, timeout_minutes: manifest.timeout_minutes, connectors: manifest.connectors });
+            console.log(`${res.created ? "Created" : "Updated"} ${manifest.name} from ${path}`);
+            console.log(`  model       ${manifest.model}`);
+            console.log(`  repo        ${manifest.repo ?? "none (runs start in an empty workspace)"}`);
+            console.log(`  connectors  ${manifest.connectors.join(", ") || "none"}`);
+            console.log(`  ${res.url}`);
+            if (manifest.repo)
+                console.log("Runs clone the repo's default branch: commit and push agentrun.yaml so the agent and its files match.");
+            return;
+        }
+        case "agents": {
+            const agents = await new Client(requireConfig()).listAgents();
+            if (agents.length === 0)
+                return console.log("No agents. `agentrun init` then `agentrun push`.");
+            for (const a of agents) {
+                const cs = Array.isArray(a.connectors) ? a.connectors : JSON.parse(a.connectors || "[]");
+                console.log(`${a.name.padEnd(24)} ${a.model.padEnd(36)} ${cs.join(",") || "-"}`);
+            }
+            return;
+        }
+        case "run": {
+            const [agent, ...rest] = args;
+            const input = rest.join(" ").trim();
+            if (!agent || !input)
+                throw new Error("usage: agentrun run <agent> <task…> [--wait]");
+            const client = new Client(requireConfig());
+            const started = await client.startRun(agent, input);
+            if (flags.json && !flags.wait)
+                return console.log(JSON.stringify(started));
+            console.error(`run ${started.id} ${started.status}${started.deduplicated ? " (deduplicated)" : ""} · ${started.url}`);
+            if (!flags.wait)
+                return;
+            let final = null;
+            for await (const { run, events } of follow(client, started.id, { stopAtWaiting: true })) {
+                printEvents(events);
+                final = run;
+            }
+            if (final) {
+                console.error(`\n${final.status}${final.failure_category ? ` (${final.failure_category})` : ""} · ${final.turns} turn${final.turns === 1 ? "" : "s"} · ${final.active_seconds ?? 0}s active · ${money(final.price_usd)}`);
+                if (final.status === "waiting")
+                    console.error(`waiting for a reply: agentrun send ${final.id} "<text>"`);
+                if (flags.json)
+                    console.log(JSON.stringify(final));
+                else if (final.result)
+                    console.log(final.result);
+                if (!TERMINAL.has(final.status) && final.status !== "waiting")
+                    process.exitCode = 1;
+                if (["failed", "timeout", "error"].includes(final.status))
+                    process.exitCode = 1;
+            }
+            return;
+        }
+        case "logs": {
+            const id = args[0];
+            if (!id)
+                throw new Error("usage: agentrun logs <run-id> [--follow]");
+            const client = new Client(requireConfig());
+            if (!flags.follow) {
+                const run = await client.getRun(id);
+                printEvents(run.events ?? []);
+                console.error(`${run.status} · ${run.turns} turns · ${money(run.price_usd)}`);
+                return;
+            }
+            for await (const { run, events } of follow(client, id)) {
+                printEvents(events);
+                if (TERMINAL.has(run.status))
+                    console.error(`${run.status} · ${money(run.price_usd)}`);
+            }
+            return;
+        }
+        case "send": {
+            const [id, ...rest] = args;
+            const text = rest.join(" ").trim();
+            if (!id || !text)
+                throw new Error("usage: agentrun send <run-id> <text…>");
+            const r = await new Client(requireConfig()).sendMessage(id, text);
+            console.log(r.continued ? `That run had ended; continued as ${r.run_id}. ${r.url}` : `Delivered to ${r.run_id}.`);
+            return;
+        }
+        case "cancel": {
+            if (!args[0])
+                throw new Error("usage: agentrun cancel <run-id>");
+            await new Client(requireConfig()).cancelRun(args[0]);
+            console.log(`cancelled ${args[0]}`);
+            return;
+        }
+        case "mcp": {
+            const { serveMcp } = await import("./mcp.js");
+            await serveMcp();
+            return;
+        }
+        default:
+            console.error(`unknown command: ${cmd}\n`);
+            console.log(HELP);
+            process.exitCode = 2;
+    }
+}
+main().catch((e) => {
+    if (e instanceof ApiError && e.status === 401)
+        console.error("Unauthorized: the API key was rejected. Run `agentrun login` again.");
+    else
+        console.error(e instanceof Error ? e.message : String(e));
+    process.exitCode = 1;
+});

package/dist/client.js

@@ -0,0 +1,77 @@
+export class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export class Client {
+    cfg;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    async call(method, path, body, headers = {}) {
+        const res = await fetch(`${this.cfg.url}${path}`, {
+            method,
+            headers: { authorization: `Bearer ${this.cfg.key}`, "user-agent": "agentrun-cli", ...(body !== undefined ? { "content-type": "application/json" } : {}), ...headers },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        const text = await res.text();
+        let data = text;
+        try {
+            data = JSON.parse(text);
+        }
+        catch { }
+        if (!res.ok) {
+            const msg = data?.error ?? (typeof data === "string" ? data.slice(0, 200) : res.statusText);
+            throw new ApiError(res.status, `${res.status} ${msg}`);
+        }
+        return data;
+    }
+    me() {
+        return this.call("GET", "/api/me");
+    }
+    listAgents() {
+        return this.call("GET", "/api/agents");
+    }
+    getAgent(name) {
+        return this.call("GET", `/api/agents/${encodeURIComponent(name)}`);
+    }
+    upsertAgent(name, fields) {
+        return this.call("PUT", `/api/agents/${encodeURIComponent(name)}`, fields);
+    }
+    startRun(agent, input, idempotencyKey) {
+        return this.call("POST", "/api/runs", { agent, input }, idempotencyKey ? { "idempotency-key": idempotencyKey } : {});
+    }
+    listRuns(params = {}) {
+        const q = new URLSearchParams(Object.entries(params).filter(([, v]) => v));
+        return this.call("GET", `/api/runs${q.size ? `?${q}` : ""}`);
+    }
+    getRun(id, afterSeq = -1) {
+        return this.call("GET", `/api/runs/${encodeURIComponent(id)}?after=${afterSeq}`);
+    }
+    sendMessage(id, text) {
+        return this.call("POST", `/api/runs/${encodeURIComponent(id)}/messages`, { text });
+    }
+    cancelRun(id) {
+        return this.call("POST", `/api/runs/${encodeURIComponent(id)}/cancel`);
+    }
+}
+export const TERMINAL = new Set(["succeeded", "failed", "timeout", "error"]);
+/** Polls a run until it reaches a terminal state (or `waiting`, when `stopAtWaiting`), yielding new events as they appear. */
+export async function* follow(client, id, opts = {}) {
+    let after = -1;
+    const interval = opts.intervalMs ?? 2000;
+    for (;;) {
+        const run = await client.getRun(id, after);
+        const events = run.events ?? [];
+        if (events.length)
+            after = events[events.length - 1].seq;
+        yield { run, events };
+        if (TERMINAL.has(run.status))
+            return;
+        if (opts.stopAtWaiting && run.status === "waiting")
+            return;
+        await new Promise((r) => setTimeout(r, interval));
+    }
+}

package/dist/config.js

@@ -0,0 +1,28 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const DIR = process.env.AGENTRUN_CONFIG_DIR ?? join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "agentrun");
+const FILE = join(DIR, "config.json");
+export const DEFAULT_URL = "https://app.agentrun.dev";
+export function readConfig() {
+    let file = {};
+    try {
+        if (existsSync(FILE))
+            file = JSON.parse(readFileSync(FILE, "utf8"));
+    }
+    catch { }
+    return { url: process.env.AGENTRUN_URL ?? file.url ?? DEFAULT_URL, key: process.env.AGENTRUN_API_KEY ?? file.key };
+}
+export function requireConfig() {
+    const c = readConfig();
+    if (!c.key) {
+        console.error("Not logged in. Run `agentrun login` with a workspace API key from Settings, API keys, or set AGENTRUN_API_KEY.");
+        process.exit(2);
+    }
+    return { url: (c.url ?? DEFAULT_URL).replace(/\/$/, ""), key: c.key };
+}
+export function writeConfig(c) {
+    mkdirSync(DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(FILE, JSON.stringify(c, null, 2) + "\n", { mode: 0o600 });
+    return FILE;
+}

package/dist/manifest.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { parse, stringify } from "yaml";
+export const MANIFEST_FILE = "agentrun.yaml";
+/** Reads agentrun.yaml from `dir`, resolving instructions_file relative to it. */
+export function loadManifest(dir) {
+    const path = resolve(dir, MANIFEST_FILE);
+    if (!existsSync(path))
+        throw new Error(`No ${MANIFEST_FILE} in ${resolve(dir)}. Run \`agentrun init\` to create one.`);
+    const doc = parse(readFileSync(path, "utf8"));
+    if (!doc || typeof doc !== "object")
+        throw new Error(`${MANIFEST_FILE} must be a mapping.`);
+    const name = String(doc.name ?? "").trim();
+    const model = String(doc.model ?? "").trim();
+    if (!/^[a-z0-9-]+$/.test(name))
+        throw new Error("name must be lowercase letters, digits, and dashes.");
+    if (!model.includes("/"))
+        throw new Error("model must be in provider/model form, e.g. openrouter/qwen/qwen3-coder.");
+    let instructions = typeof doc.instructions === "string" ? doc.instructions.trim() : "";
+    if (!instructions && typeof doc.instructions_file === "string") {
+        const f = resolve(dir, doc.instructions_file);
+        if (!existsSync(f))
+            throw new Error(`instructions_file ${doc.instructions_file} not found.`);
+        instructions = readFileSync(f, "utf8").trim();
+    }
+    if (!instructions)
+        throw new Error("instructions (or instructions_file) is required.");
+    const rawConnectors = Array.isArray(doc.connectors) ? doc.connectors : typeof doc.connectors === "string" ? doc.connectors.split(",") : [];
+    const connectors = [...new Set(rawConnectors.map((c) => String(c).trim().toLowerCase()).filter(Boolean))];
+    const timeout_minutes = Math.min(120, Math.max(1, Number.parseInt(String(doc.timeout_minutes ?? "30"), 10) || 30));
+    const repo = typeof doc.repo === "string" && doc.repo.trim() ? doc.repo.trim() : detectRepo(dir);
+    return { path, manifest: { name, model, instructions, timeout_minutes, connectors, repo } };
+}
+/** The GitHub URL of the origin remote, if the directory is a git checkout. Runs clone this. */
+export function detectRepo(dir) {
+    try {
+        const cfg = readFileSync(join(gitDir(dir), "config"), "utf8");
+        const m = /\[remote "origin"\][^[]*?url\s*=\s*(\S+)/.exec(cfg);
+        if (!m)
+            return null;
+        const url = m[1];
+        const gh = /^(?:git@github\.com:|https:\/\/github\.com\/)([^/]+)\/([^/]+?)(?:\.git)?$/.exec(url);
+        return gh ? `https://github.com/${gh[1]}/${gh[2]}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+function gitDir(dir) {
+    let d = resolve(dir);
+    for (let i = 0; i < 20; i++) {
+        const g = join(d, ".git");
+        if (existsSync(g)) {
+            const st = readFileSync(g, "utf8").trim();
+            return st.startsWith("gitdir:") ? resolve(d, st.slice(7).trim()) : g;
+        }
+        const up = resolve(d, "..");
+        if (up === d)
+            break;
+        d = up;
+    }
+    throw new Error("not a git repo");
+}
+export function writeManifest(dir, m) {
+    const path = resolve(dir, MANIFEST_FILE);
+    if (existsSync(path))
+        throw new Error(`${MANIFEST_FILE} already exists here.`);
+    const doc = { name: m.name, model: m.model, timeout_minutes: m.timeout_minutes ?? 30 };
+    if (m.connectors?.length)
+        doc.connectors = m.connectors;
+    doc.instructions = m.instructions ?? "You are a helpful agent. Do exactly what the task says, using your tools. Finish with a short summary of what you did.";
+    writeFileSync(path, `# Agentrun agent. \`agentrun push\` creates or updates it; runs clone this repo and read this file.\n${stringify(doc, { lineWidth: 0 })}`);
+    return path;
+}

package/dist/mcp.js

@@ -0,0 +1,78 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { Client, TERMINAL, follow } from "./client.js";
+import { requireConfig } from "./config.js";
+/**
+ * `agentrun mcp`: a stdio MCP server so Claude Code, Cursor, Codex, or another agent can start Agentrun agents,
+ * watch them, and talk to them. Uses the same workspace key as the CLI.
+ */
+function summarize(run) {
+    const lines = [
+        `run ${run.id}: ${run.status}${run.failure_category ? ` (${run.failure_category})` : ""}`,
+        `agent ${run.agent_id} · trigger ${run.trigger} · turns ${run.turns}`,
+        run.active_seconds != null ? `active ${run.active_seconds}s · price $${(run.price_usd ?? 0).toFixed(3)} · model cost $${(run.model_cost_usd ?? 0).toFixed(4)}` : null,
+        run.result ? `\nresult:\n${run.result}` : null,
+        run.error ? `\nerror: ${run.error}` : null,
+    ];
+    return lines.filter(Boolean).join("\n");
+}
+export async function serveMcp() {
+    const cfg = requireConfig();
+    const client = new Client(cfg);
+    const server = new McpServer({ name: "agentrun", version: "0.1.0" });
+    const text = (t) => ({ content: [{ type: "text", text: t }] });
+    server.registerTool("list_agents", { description: "List the agents in the Agentrun workspace: name, model, connectors, repo.", inputSchema: {} }, async () => {
+        const agents = await client.listAgents();
+        if (agents.length === 0)
+            return text("No agents yet. Create one with `agentrun push` or in the Agentrun UI.");
+        return text(agents.map((a) => `${a.name} · ${a.model} · connectors: ${(Array.isArray(a.connectors) ? a.connectors : JSON.parse(a.connectors || "[]")).join(", ") || "none"}${a.repo ? ` · repo ${a.repo}` : ""}`).join("\n"));
+    });
+    server.registerTool("run_agent", {
+        description: "Start an Agentrun agent with a task. Returns the run id and URL immediately; set wait=true to block until it finishes (up to wait_seconds) and get the result.",
+        inputSchema: { agent: z.string().describe("Agent name"), input: z.string().describe("The task"), wait: z.boolean().optional().describe("Block until the run ends"), wait_seconds: z.number().int().positive().max(1800).optional().describe("Max seconds to wait, default 600") },
+    }, async ({ agent, input, wait, wait_seconds }) => {
+        const started = await client.startRun(agent, input);
+        if (!wait)
+            return text(`started run ${started.id} (${started.status}). ${started.url}`);
+        const deadline = Date.now() + (wait_seconds ?? 600) * 1000;
+        let last = null;
+        for await (const { run } of follow(client, started.id, { stopAtWaiting: true })) {
+            last = run;
+            if (Date.now() > deadline)
+                break;
+        }
+        return text(last ? summarize(last) + (last.status === "waiting" ? "\n\nThe agent is waiting for a reply; use send_message to continue." : "") : `started run ${started.id}`);
+    });
+    server.registerTool("get_run", { description: "Get a run's status, result, cost, and recent events.", inputSchema: { run_id: z.string(), events: z.number().int().min(0).max(200).optional().describe("How many trailing events to include, default 30") } }, async ({ run_id, events }) => {
+        const run = await client.getRun(run_id);
+        const tail = (run.events ?? []).slice(-(events ?? 30)).map((e) => `[${e.kind}] ${e.text}`).join("\n");
+        return text(summarize(run) + (tail ? `\n\nevents:\n${tail}` : ""));
+    });
+    server.registerTool("list_runs", { description: "Recent runs, optionally filtered by agent name and status.", inputSchema: { agent: z.string().optional(), status: z.string().optional().describe("queued|running|waiting|succeeded|failed|timeout|error") } }, async ({ agent, status }) => {
+        let agentId;
+        if (agent)
+            agentId = (await client.getAgent(agent)).id;
+        const runs = await client.listRuns({ agent: agentId, status });
+        return text(runs.length ? runs.slice(0, 50).map((r) => `${r.id} · ${r.status} · ${new Date(r.created_at).toISOString()} · ${r.input.slice(0, 80)}`).join("\n") : "No runs.");
+    });
+    server.registerTool("send_message", { description: "Send a message to a running or waiting run (or continue a finished one in a new run with the earlier context).", inputSchema: { run_id: z.string(), text: z.string() } }, async ({ run_id, text: msg }) => {
+        const r = await client.sendMessage(run_id, msg);
+        return text(r.continued ? `The run had ended; continued as run ${r.run_id}. ${r.url}` : `Delivered to run ${r.run_id}.`);
+    });
+    server.registerTool("cancel_run", { description: "Cancel a run.", inputSchema: { run_id: z.string() } }, async ({ run_id }) => {
+        await client.cancelRun(run_id);
+        return text(`cancelled ${run_id}`);
+    });
+    server.registerTool("wait_for_run", { description: "Block until a run reaches a terminal state or starts waiting for a reply.", inputSchema: { run_id: z.string(), wait_seconds: z.number().int().positive().max(1800).optional() } }, async ({ run_id, wait_seconds }) => {
+        const deadline = Date.now() + (wait_seconds ?? 600) * 1000;
+        let last = null;
+        for await (const { run } of follow(client, run_id, { stopAtWaiting: true })) {
+            last = run;
+            if (Date.now() > deadline)
+                break;
+        }
+        return text(last ? summarize(last) + (last && !TERMINAL.has(last.status) ? "\n\n(still going)" : "") : "no such run");
+    });
+    await server.connect(new StdioServerTransport());
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "agentrun-cli",
+  "version": "0.1.0",
+  "description": "Push, run, and talk to Agentrun agents from the terminal, plus an MCP server for Claude Code, Cursor, and friends.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "agentrun": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p .",
+    "dev": "node --experimental-strip-types src/cli.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.20.0",
+    "yaml": "^2.9.1",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stirredo/agentrun.git",
+    "directory": "cli"
+  },
+  "homepage": "https://agentrun.dev",
+  "keywords": [
+    "agents",
+    "ai",
+    "cli",
+    "mcp",
+    "opencode",
+    "automation"
+  ]
+}