@duvoai/cli 0.0.1 → 0.1.0

package/dist/bin/create-program.js

@@ -1,10 +1,16 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 import { registerAgents } from "../commands/agents/index.js";
 import { registerApi } from "../commands/api.js";
 import { registerLogin } from "../commands/login.js";
 import { registerLogout } from "../commands/logout.js";
 import { registerProfiles } from "../commands/profiles/index.js";
+import { registerRuns } from "../commands/runs/index.js";
 import { registerWhoami } from "../commands/whoami.js";
+const packageJsonPath = join(dirname(fileURLToPath(import.meta.url)), "../../package.json");
+const { version } = JSON.parse(readFileSync(packageJsonPath, "utf8"));
 /**
  * Build a fresh `Command` tree for the CLI. Shared between the real
  * binary (`bin/duvo.ts`) and the test harness so tests can never
@@ -15,7 +21,7 @@ export function createProgram() {
     program
         .name("duvo")
         .description("Command-line interface for the Duvo public API")
-        .version("0.0.0")
+        .version(version)
         .option("--profile <name>", "use a specific profile for this invocation (overrides default profile)");
     registerLogin(program);
     registerLogout(program);
@@ -23,5 +29,6 @@ export function createProgram() {
     registerProfiles(program);
     registerApi(program);
     registerAgents(program);
+    registerRuns(program);
     return program;
 }

package/dist/commands/agents/create.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerAgentsCreate(agents: Command): void;

package/dist/commands/agents/create.js

@@ -0,0 +1,182 @@
+import { readFile } from "node:fs/promises";
+import { confirm, isCancel, text } from "@clack/prompts";
+import { AGENT_CONFIG_VERSION, DEFAULT_AGENT_CONFIG } from "@taskcrew/shared";
+import { buildConfigSchema, createAgentResponseSchema, DEFAULT_BUILD_CONFIG, DEFAULT_BUILD_NAME, DEFAULT_NEW_AGENT_NAME, } from "../../api/agent-schemas.js";
+import { httpRequest } from "../../client/client.js";
+import { CancelCliError, CliError } from "../../errors.js";
+import { green } from "../../output/green.js";
+import { printJson } from "../../output/json.js";
+import { renderKeyValue } from "../../output/text.js";
+import { requireAuthenticatedConfig } from "../shared/require-auth.js";
+export function registerAgentsCreate(agents) {
+    agents
+        .command("create")
+        .description("Create a new agent")
+        .option("--name <name>", "human-readable agent name")
+        .option("--input <text>", "initial agent instructions (merged into the default build config)")
+        .option("--config <path>", "path to a JSON file with the full build config (overrides --input)")
+        .option("--no-build", "create the agent without an initial build")
+        .option("--json", "output raw JSON from the API")
+        .action(async function createAction(options) {
+        const resolved = await requireAuthenticatedConfig(this);
+        const name = await resolveName(options.name);
+        const body = { name };
+        if (options.build !== false) {
+            const config = await resolveBuildConfig(options);
+            if (config) {
+                body.build = {
+                    name: DEFAULT_BUILD_NAME,
+                    config,
+                };
+            }
+        }
+        const raw = await httpRequest({
+            method: "POST",
+            path: "/v1/agents",
+            apiKey: resolved.apiKey,
+            apiBaseUrl: resolved.apiBaseUrl,
+            body,
+        });
+        if (options.json) {
+            printJson(raw);
+            return;
+        }
+        const parsed = createAgentResponseSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new CliError(`Unexpected response from the API: ${parsed.error.message}`);
+        }
+        const { agent, build } = parsed.data;
+        const entries = [
+            { label: "ID", value: agent.id },
+            { label: "Name", value: agent.name },
+            { label: "Created", value: agent.created_at ?? "" },
+        ];
+        if (build) {
+            entries.push({ label: "Build", value: `${build.id} (${build.name})` });
+        }
+        console.log(green("Agent created!"));
+        console.log();
+        console.log(renderKeyValue(entries));
+    });
+}
+function isInteractiveTerminal() {
+    return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+async function resolveName(flag) {
+    if (flag !== undefined) {
+        const trimmed = flag.trim();
+        if (trimmed.length === 0) {
+            throw new CliError("--name must not be empty");
+        }
+        return trimmed;
+    }
+    if (!isInteractiveTerminal()) {
+        return DEFAULT_NEW_AGENT_NAME;
+    }
+    const answer = await text({
+        message: "Agent name",
+        placeholder: DEFAULT_NEW_AGENT_NAME,
+        defaultValue: DEFAULT_NEW_AGENT_NAME,
+        validate: (value) => {
+            if (value && value.trim().length === 0) {
+                return "Agent name must not be blank.";
+            }
+            return undefined;
+        },
+    });
+    if (isCancel(answer)) {
+        throw new CancelCliError("Create cancelled.");
+    }
+    const trimmed = answer.trim();
+    return trimmed.length === 0 ? DEFAULT_NEW_AGENT_NAME : trimmed;
+}
+async function resolveBuildConfig(options) {
+    if (options.config !== undefined) {
+        const trimmed = options.config.trim();
+        if (trimmed.length === 0) {
+            throw new CliError("--config must be a non-empty file path");
+        }
+        return readConfigFromFile(trimmed);
+    }
+    if (options.input !== undefined) {
+        return buildConfigWithInput(options.input);
+    }
+    if (!isInteractiveTerminal()) {
+        return DEFAULT_BUILD_CONFIG;
+    }
+    const hasCustomConfig = await confirm({
+        message: "Do you have your own build config?",
+        initialValue: false,
+    });
+    if (isCancel(hasCustomConfig)) {
+        throw new CancelCliError("Create cancelled.");
+    }
+    if (hasCustomConfig) {
+        const path = await text({
+            message: "Path to build config JSON",
+            validate: (value) => {
+                if (!value || value.trim().length === 0) {
+                    return "A file path is required.";
+                }
+                return undefined;
+            },
+        });
+        if (isCancel(path)) {
+            throw new CancelCliError("Create cancelled.");
+        }
+        return readConfigFromFile(path.trim());
+    }
+    const input = await text({
+        message: "Initial instructions for the agent (leave empty for the default)",
+        defaultValue: "",
+    });
+    if (isCancel(input)) {
+        throw new CancelCliError("Create cancelled.");
+    }
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return DEFAULT_BUILD_CONFIG;
+    }
+    return buildConfigWithInput(trimmed);
+}
+function buildConfigWithInput(input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return DEFAULT_BUILD_CONFIG;
+    }
+    return {
+        version: AGENT_CONFIG_VERSION,
+        data: {
+            ...DEFAULT_AGENT_CONFIG,
+            input: [
+                {
+                    role: "system",
+                    content: [{ type: "input_text", text: trimmed }],
+                },
+            ],
+        },
+    };
+}
+async function readConfigFromFile(path) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError(`Could not read config file "${path}": ${message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError(`Config file "${path}" is not valid JSON: ${message}`);
+    }
+    const result = buildConfigSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new CliError(`Config file "${path}" does not match expected build config shape (version "${AGENT_CONFIG_VERSION}"): ${result.error.message}`);
+    }
+    return result.data;
+}

package/dist/commands/agents/get.js

@@ -1,27 +1,21 @@
 import { getAgentResponseSchema } from "../../api/agent-schemas.js";
 import { httpRequest } from "../../client/client.js";
-import { resolveConfig } from "../../config/resolve.js";
-import { AuthCliError, CliError } from "../../errors.js";
+import { CliError } from "../../errors.js";
 import { printJson } from "../../output/json.js";
 import { renderKeyValue } from "../../output/text.js";
-import { getProfileFlag } from "../shared/profile-flag.js";
+import { requireAuthenticatedConfig } from "../shared/require-auth.js";
 export function registerAgentsGet(agents) {
     agents
         .command("get <id>")
         .description("Get an agent by ID")
         .option("--json", "output raw JSON from the API")
         .action(async function getAction(id, options) {
-        const resolved = await resolveConfig({
-            profileFlag: getProfileFlag(this),
-        });
-        if (!resolved.apiKey) {
-            throw new AuthCliError("Not logged in. Run `duvo login` to save an API key.");
-        }
+        const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
         const raw = await httpRequest({
             method: "GET",
             path: `/v1/agents/${encodeURIComponent(id)}`,
-            apiKey: resolved.apiKey,
-            apiBaseUrl: resolved.apiBaseUrl,
+            apiKey,
+            apiBaseUrl,
         });
         if (options.json) {
             printJson(raw);

package/dist/commands/agents/index.js

@@ -1,3 +1,4 @@
+import { registerAgentsCreate } from "./create.js";
 import { registerAgentsGet } from "./get.js";
 import { registerAgentsList } from "./list.js";
 export function registerAgents(program) {
@@ -6,4 +7,5 @@ export function registerAgents(program) {
         .description("Manage agents in the Duvo public API");
     registerAgentsList(agents);
     registerAgentsGet(agents);
+    registerAgentsCreate(agents);
 }

package/dist/commands/agents/list.js

@@ -1,11 +1,10 @@
 import { listAgentsResponseSchema, } from "../../api/agent-schemas.js";
 import { httpRequest } from "../../client/client.js";
-import { resolveConfig } from "../../config/resolve.js";
-import { AuthCliError, CliError } from "../../errors.js";
+import { CliError } from "../../errors.js";
 import { printJson } from "../../output/json.js";
 import { renderTable } from "../../output/table.js";
 import { parseLimit, parseOffset } from "../shared/pagination.js";
-import { getProfileFlag } from "../shared/profile-flag.js";
+import { requireAuthenticatedConfig } from "../shared/require-auth.js";
 const DEFAULT_LIMIT = 20;
 const MIN_LIMIT = 1;
 const MAX_LIMIT = 100;
@@ -28,20 +27,15 @@ export function registerAgentsList(agents) {
             max: MAX_LIMIT,
         });
         const offset = parseOffset(options.offset);
-        const resolved = await resolveConfig({
-            profileFlag: getProfileFlag(this),
-        });
-        if (!resolved.apiKey) {
-            throw new AuthCliError("Not logged in. Run `duvo login` to save an API key.");
-        }
+        const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
         const searchParams = new URLSearchParams();
         searchParams.append("limit", String(limit));
         searchParams.append("offset", String(offset));
         const raw = await httpRequest({
             method: "GET",
             path: "/v1/agents",
-            apiKey: resolved.apiKey,
-            apiBaseUrl: resolved.apiBaseUrl,
+            apiKey,
+            apiBaseUrl,
             searchParams,
         });
         if (options.json) {

package/dist/commands/api.js

@@ -1,10 +1,9 @@
 import { buildFieldObject } from "../api/parse-fields.js";
 import { readInputJson } from "../api/read-input.js";
 import { httpRequest } from "../client/client.js";
-import { resolveConfig } from "../config/resolve.js";
-import { CliError, EXIT_CODE } from "../errors.js";
+import { CliError } from "../errors.js";
 import { renderApiResponse } from "./api-render.js";
-import { getProfileFlag } from "./shared/profile-flag.js";
+import { requireAuthenticatedConfig, } from "./shared/require-auth.js";
 const METHODS_WITH_BODY = new Set(["POST", "PUT", "PATCH", "DELETE"]);
 const VALID_METHODS = new Set([
     "GET",
@@ -23,18 +22,11 @@ export function registerApi(program) {
         .option("--input <path>", 'raw JSON body from a file, or "-" for stdin (mutually exclusive with -f / -F)')
         .option("--json", "output raw JSON instead of the formatted view")
         .action(async function apiAction(method, path, options) {
-        await runApi({
-            method,
-            path,
-            options,
-        }, { profileFlag: getProfileFlag(this) });
+        const resolved = await requireAuthenticatedConfig(this);
+        await runApi({ method, path, options }, resolved);
     });
 }
-async function runApi(args, resolveOptions) {
-    const resolved = await resolveConfig(resolveOptions);
-    if (!resolved.apiKey) {
-        throw new CliError("Not logged in. Run `duvo login` to save an API key.", EXIT_CODE.AUTH);
-    }
+async function runApi(args, resolved) {
     const method = args.method.toUpperCase();
     if (!VALID_METHODS.has(method)) {
         throw new CliError(`Invalid HTTP method "${args.method}". Expected one of: ${[...VALID_METHODS].join(", ")}.`);

package/dist/commands/runs/get.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerRunsGet(runs: Command): void;

package/dist/commands/runs/get.js

@@ -0,0 +1,59 @@
+import { getRunResponseSchema } from "../../api/run-schemas.js";
+import { httpRequest } from "../../client/client.js";
+import { CliError } from "../../errors.js";
+import { printJson } from "../../output/json.js";
+import { renderKeyValue } from "../../output/text.js";
+import { requireAuthenticatedConfig } from "../shared/require-auth.js";
+export function registerRunsGet(runs) {
+    runs
+        .command("get <id>")
+        .description("Get an agent run by ID")
+        .option("--json", "output raw JSON from the API")
+        .action(async function getAction(id, options) {
+        const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+        const raw = await httpRequest({
+            method: "GET",
+            path: `/v1/runs/${encodeURIComponent(id)}`,
+            apiKey,
+            apiBaseUrl,
+        });
+        if (options.json) {
+            printJson(raw);
+            return;
+        }
+        const parsed = getRunResponseSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new CliError(`Unexpected response from the API: ${parsed.error.message}`);
+        }
+        const { run, pending_human_request: pendingHumanRequest } = parsed.data;
+        if (!run) {
+            throw new CliError(`Run "${id}" not found.`);
+        }
+        console.log(renderKeyValue([
+            { label: "ID", value: run.id },
+            { label: "Agent", value: run.agent_id },
+            { label: "Build", value: run.build_id },
+            { label: "Status", value: run.status },
+            { label: "Source", value: run.source ?? "" },
+            { label: "Sandbox", value: run.sandbox_id ?? "" },
+            { label: "Started", value: run.started_at ?? "" },
+            { label: "Completed", value: run.completed_at ?? "" },
+            { label: "Created", value: run.created_at },
+            { label: "Updated", value: run.updated_at ?? "" },
+        ]));
+        if (pendingHumanRequest) {
+            console.log("");
+            console.log("Pending human request:");
+            console.log(renderKeyValue([
+                { label: "ID", value: pendingHumanRequest.id },
+                { label: "Type", value: pendingHumanRequest.type },
+                { label: "Title", value: pendingHumanRequest.title },
+                {
+                    label: "Description",
+                    value: pendingHumanRequest.description ?? "",
+                },
+                { label: "Created", value: pendingHumanRequest.created_at },
+            ]));
+        }
+    });
+}

package/dist/commands/runs/index.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerRuns(program: Command): void;

package/dist/commands/runs/index.js

@@ -0,0 +1,17 @@
+import { registerRunsGet } from "./get.js";
+import { registerRunsMessages } from "./messages.js";
+import { registerRunsRespond } from "./respond.js";
+import { registerRunsSendMessage } from "./send-message.js";
+import { registerRunsStart } from "./start.js";
+import { registerRunsStop } from "./stop.js";
+export function registerRuns(program) {
+    const runs = program
+        .command("runs")
+        .description("Manage agent runs in the Duvo public API");
+    registerRunsStart(runs);
+    registerRunsGet(runs);
+    registerRunsMessages(runs);
+    registerRunsSendMessage(runs);
+    registerRunsRespond(runs);
+    registerRunsStop(runs);
+}

package/dist/commands/runs/messages.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerRunsMessages(runs: Command): void;

package/dist/commands/runs/messages.js

@@ -0,0 +1,80 @@
+import { listRunMessagesResponseSchema, } from "../../api/run-schemas.js";
+import { httpRequest } from "../../client/client.js";
+import { CliError } from "../../errors.js";
+import { printJson } from "../../output/json.js";
+import { renderTable } from "../../output/table.js";
+import { parseLimit, parseOffset } from "../shared/pagination.js";
+import { requireAuthenticatedConfig } from "../shared/require-auth.js";
+const DEFAULT_LIMIT = 20;
+const MIN_LIMIT = 1;
+const MAX_LIMIT = 50;
+const TEXT_PREVIEW_WIDTH = 60;
+const TABLE_COLUMNS = [
+    { header: "ID", cell: (row) => row.id },
+    { header: "ROLE", cell: (row) => row.role },
+    { header: "TYPE", cell: (row) => row.type },
+    { header: "TIMESTAMP", cell: (row) => row.timestamp },
+    {
+        header: "PREVIEW",
+        cell: previewCell,
+        maxWidth: TEXT_PREVIEW_WIDTH,
+    },
+];
+function previewCell(row) {
+    if (row.text_content) {
+        return row.text_content.replace(/\s+/g, " ").trim();
+    }
+    if (row.tool_call) {
+        return `tool_call ${row.tool_call.name}`;
+    }
+    if (row.tool_result) {
+        return `tool_result ${row.tool_result.tool_call_id}`;
+    }
+    return "";
+}
+export function registerRunsMessages(runs) {
+    runs
+        .command("messages <id>")
+        .description("List messages for an agent run")
+        .option("--limit <n>", `page size (${MIN_LIMIT}-${MAX_LIMIT})`)
+        .option("--offset <n>", "number of messages to skip")
+        .option("--json", "output raw JSON from the API")
+        .action(async function messagesAction(id, options) {
+        const limit = parseLimit(options.limit, {
+            defaultValue: DEFAULT_LIMIT,
+            min: MIN_LIMIT,
+            max: MAX_LIMIT,
+        });
+        const offset = parseOffset(options.offset);
+        const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+        const searchParams = new URLSearchParams();
+        searchParams.append("limit", String(limit));
+        searchParams.append("offset", String(offset));
+        const raw = await httpRequest({
+            method: "GET",
+            path: `/v1/runs/${encodeURIComponent(id)}/messages`,
+            apiKey,
+            apiBaseUrl,
+            searchParams,
+        });
+        if (options.json) {
+            printJson(raw);
+            return;
+        }
+        const parsed = listRunMessagesResponseSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new CliError(`Unexpected response from the API: ${parsed.error.message}`);
+        }
+        const response = parsed.data;
+        if (response.messages.length === 0) {
+            console.log("No messages found.");
+            return;
+        }
+        console.log(renderTable(TABLE_COLUMNS, response.messages));
+        const resolvedOffset = response.offset ?? offset;
+        const summary = response.total === null || response.total === undefined
+            ? `Showing ${response.messages.length} · offset ${resolvedOffset}`
+            : `Showing ${response.messages.length} of ${response.total} · offset ${resolvedOffset}`;
+        console.log(summary);
+    });
+}

package/dist/commands/runs/respond.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerRunsRespond(runs: Command): void;

package/dist/commands/runs/respond.js

@@ -0,0 +1,105 @@
+import { getRunResponseSchema, respondHumanRequestResponseSchema, } from "../../api/run-schemas.js";
+import { httpRequest } from "../../client/client.js";
+import { CliError } from "../../errors.js";
+import { green } from "../../output/green.js";
+import { printJson } from "../../output/json.js";
+import { renderKeyValue } from "../../output/text.js";
+import { requireAuthenticatedConfig } from "../shared/require-auth.js";
+function collectAnswer(value, previous = []) {
+    return [...previous, value];
+}
+function parseAnswers(raw) {
+    const answers = Object.create(null);
+    for (const entry of raw) {
+        const eq = entry.indexOf("=");
+        if (eq === -1 || eq === 0) {
+            throw new CliError(`Invalid --answer "${entry}". Expected "question=answer".`);
+        }
+        const question = entry.slice(0, eq);
+        const answer = entry.slice(eq + 1);
+        if (Object.prototype.hasOwnProperty.call(answers, question)) {
+            throw new CliError(`Duplicate --answer for question "${question}". Each question may be answered once.`);
+        }
+        answers[question] = answer;
+    }
+    return answers;
+}
+function buildBody(options) {
+    const approveSet = options.approve === true;
+    const denySet = options.deny === true;
+    const answers = options.answer ?? [];
+    if (approveSet && denySet) {
+        throw new CliError("Pass either --approve or --deny, not both.");
+    }
+    if ((approveSet || denySet) && answers.length > 0) {
+        throw new CliError("Pass either --approve/--deny (for approval-type requests) or --answer (for question-type requests), not both.");
+    }
+    if (approveSet) {
+        return { approved: true };
+    }
+    if (denySet) {
+        return { approved: false };
+    }
+    if (answers.length > 0) {
+        return { answers: parseAnswers(answers) };
+    }
+    throw new CliError("Provide --approve, --deny, or at least one --answer question=answer.");
+}
+async function resolvePendingRequestId(runId, apiKey, apiBaseUrl) {
+    const raw = await httpRequest({
+        method: "GET",
+        path: `/v1/runs/${encodeURIComponent(runId)}`,
+        apiKey,
+        apiBaseUrl,
+    });
+    const parsed = getRunResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new CliError(`Unexpected response from the API: ${parsed.error.message}`);
+    }
+    const pending = parsed.data.pending_human_request;
+    if (!pending) {
+        throw new CliError(`Run ${runId} has no pending human request. Pass the request ID explicitly.`);
+    }
+    return pending.id;
+}
+export function registerRunsRespond(runs) {
+    runs
+        .command("respond <run-id> [request-id]")
+        .description("Respond to a human-in-the-loop request on a run (defaults to the run's pending request)")
+        .option("--approve", "approve an approval-type request")
+        .option("--deny", "deny an approval-type request")
+        .option("--answer <question=answer>", "answer a question-type request (repeatable)", collectAnswer, [])
+        .option("--json", "output raw JSON from the API")
+        .action(async function respondAction(runId, requestIdArg, options) {
+        const body = buildBody(options);
+        const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+        const requestId = requestIdArg ??
+            (await resolvePendingRequestId(runId, apiKey, apiBaseUrl));
+        const raw = await httpRequest({
+            method: "POST",
+            path: `/v1/runs/${encodeURIComponent(runId)}/human-requests/${encodeURIComponent(requestId)}/respond`,
+            apiKey,
+            apiBaseUrl,
+            body,
+        });
+        if (options.json) {
+            printJson(raw);
+            return;
+        }
+        const parsed = respondHumanRequestResponseSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new CliError(`Unexpected response from the API: ${parsed.error.message}`);
+        }
+        const { human_request: humanRequest } = parsed.data;
+        console.log(green("Response sent!"));
+        console.log(renderKeyValue([
+            { label: "ID", value: humanRequest.id },
+            { label: "Run", value: humanRequest.run_id },
+            { label: "Title", value: humanRequest.title },
+            { label: "Description", value: humanRequest.description ?? "" },
+            { label: "Response", value: humanRequest.response ?? "" },
+            { label: "Responded", value: humanRequest.responded_at ?? "" },
+            { label: "Created", value: humanRequest.created_at },
+        ]));
+    });
+}

package/dist/commands/runs/send-message.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerRunsSendMessage(runs: Command): void;

package/dist/commands/runs/send-message.js

@@ -0,0 +1,41 @@
+import { postRunMessageResponseSchema } from "../../api/run-schemas.js";
+import { httpRequest } from "../../client/client.js";
+import { CliError } from "../../errors.js";
+import { green } from "../../output/green.js";
+import { printJson } from "../../output/json.js";
+import { renderKeyValue } from "../../output/text.js";
+import { requireAuthenticatedConfig } from "../shared/require-auth.js";
+export function registerRunsSendMessage(runs) {
+    runs
+        .command("send-message <id>")
+        .description("Post a message to an agent run")
+        .requiredOption("--message <text>", "the message content to send")
+        .option("--json", "output raw JSON from the API")
+        .action(async function sendMessageAction(id, options) {
+        const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+        const raw = await httpRequest({
+            method: "POST",
+            path: `/v1/runs/${encodeURIComponent(id)}/messages`,
+            apiKey,
+            apiBaseUrl,
+            body: { message: options.message },
+        });
+        if (options.json) {
+            printJson(raw);
+            return;
+        }
+        const parsed = postRunMessageResponseSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new CliError(`Unexpected response from the API: ${parsed.error.message}`);
+        }
+        const { message } = parsed.data;
+        console.log(green("Message sent!"));
+        console.log(renderKeyValue([
+            { label: "ID", value: message.id },
+            { label: "Role", value: message.role },
+            { label: "Type", value: message.type },
+            { label: "Timestamp", value: message.timestamp },
+            { label: "Content", value: message.text_content },
+        ]));
+    });
+}

package/dist/commands/runs/start.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerRunsStart(runs: Command): void;