@duvoai/cli 0.0.1

package/dist/api/agent-schemas.d.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+declare const publicAgentSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    created_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    updated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    created_at?: string | null | undefined;
+    updated_at?: string | null | undefined;
+}, {
+    id: string;
+    name: string;
+    created_at?: string | null | undefined;
+    updated_at?: string | null | undefined;
+}>;
+export type PublicAgent = z.infer<typeof publicAgentSchema>;
+export declare const listAgentsResponseSchema: z.ZodObject<{
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        created_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        created_at?: string | null | undefined;
+        updated_at?: string | null | undefined;
+    }, {
+        id: string;
+        name: string;
+        created_at?: string | null | undefined;
+        updated_at?: string | null | undefined;
+    }>, "many">;
+    total: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    agents: {
+        id: string;
+        name: string;
+        created_at?: string | null | undefined;
+        updated_at?: string | null | undefined;
+    }[];
+    total?: number | null | undefined;
+    limit?: number | null | undefined;
+    offset?: number | null | undefined;
+}, {
+    agents: {
+        id: string;
+        name: string;
+        created_at?: string | null | undefined;
+        updated_at?: string | null | undefined;
+    }[];
+    total?: number | null | undefined;
+    limit?: number | null | undefined;
+    offset?: number | null | undefined;
+}>;
+export type ListAgentsResponse = z.infer<typeof listAgentsResponseSchema>;
+export declare const getAgentResponseSchema: z.ZodObject<{
+    agent: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        created_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        created_at?: string | null | undefined;
+        updated_at?: string | null | undefined;
+    }, {
+        id: string;
+        name: string;
+        created_at?: string | null | undefined;
+        updated_at?: string | null | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    agent: {
+        id: string;
+        name: string;
+        created_at?: string | null | undefined;
+        updated_at?: string | null | undefined;
+    };
+}, {
+    agent: {
+        id: string;
+        name: string;
+        created_at?: string | null | undefined;
+        updated_at?: string | null | undefined;
+    };
+}>;
+export type GetAgentResponse = z.infer<typeof getAgentResponseSchema>;
+export {};

package/dist/api/agent-schemas.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+const publicAgentSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    created_at: z.string().nullish(),
+    updated_at: z.string().nullish(),
+});
+export const listAgentsResponseSchema = z.object({
+    agents: z.array(publicAgentSchema),
+    total: z.number().nullish(),
+    limit: z.number().nullish(),
+    offset: z.number().nullish(),
+});
+export const getAgentResponseSchema = z.object({
+    agent: publicAgentSchema,
+});

package/dist/api/parse-fields.d.ts

@@ -0,0 +1,25 @@
+type Field = {
+    key: string;
+    value: unknown;
+};
+/**
+ * Parses a `-f key=value` pair. The value is always kept as a string,
+ * matching the `gh api` convention.
+ */
+export declare function parseStringField(input: string): Field;
+/**
+ * Parses a `-F key=value` pair. The value is coerced to a typed value
+ * when it matches one of: `null`, `true`, `false`, a number, or
+ * `@path/to/file.json` (inlines the file's parsed JSON). Anything else
+ * falls through as a string.
+ */
+export declare function parseTypedField(input: string): Field;
+/**
+ * Combines repeated `-f` and `-F` flag values into a single object.
+ * String fields (`-f`) are applied first, then typed fields (`-F`), so
+ * typed fields win on key collision regardless of CLI argument order.
+ * Commander collects the two flags into separate arrays, so the original
+ * interleaved order is lost by the time we get here.
+ */
+export declare function buildFieldObject(stringFields?: readonly string[], typedFields?: readonly string[]): Record<string, unknown>;
+export {};

package/dist/api/parse-fields.js

@@ -0,0 +1,86 @@
+import { readFileSync } from "node:fs";
+const INTEGER_OR_DECIMAL = /^-?\d+(\.\d+)?$/;
+/**
+ * Parses a `-f key=value` pair. The value is always kept as a string,
+ * matching the `gh api` convention.
+ */
+export function parseStringField(input) {
+    const eq = input.indexOf("=");
+    if (eq === -1) {
+        throw new Error(`Invalid field "${input}". Expected "key=value" (e.g. -f name="Bot").`);
+    }
+    const key = input.slice(0, eq);
+    if (key.length === 0) {
+        throw new Error(`Invalid field "${input}". Key cannot be empty (e.g. -f name="Bot").`);
+    }
+    return { key, value: input.slice(eq + 1) };
+}
+/**
+ * Parses a `-F key=value` pair. The value is coerced to a typed value
+ * when it matches one of: `null`, `true`, `false`, a number, or
+ * `@path/to/file.json` (inlines the file's parsed JSON). Anything else
+ * falls through as a string.
+ */
+export function parseTypedField(input) {
+    const eq = input.indexOf("=");
+    if (eq === -1) {
+        throw new Error(`Invalid field "${input}". Expected "key=value" (e.g. -F count=42).`);
+    }
+    const key = input.slice(0, eq);
+    if (key.length === 0) {
+        throw new Error(`Invalid field "${input}". Key cannot be empty (e.g. -F count=42).`);
+    }
+    const raw = input.slice(eq + 1);
+    if (raw.startsWith("@")) {
+        const path = raw.slice(1);
+        return { key, value: readJsonFile(path) };
+    }
+    if (raw === "null") {
+        return { key, value: null };
+    }
+    if (raw === "true") {
+        return { key, value: true };
+    }
+    if (raw === "false") {
+        return { key, value: false };
+    }
+    if (INTEGER_OR_DECIMAL.test(raw)) {
+        return { key, value: Number(raw) };
+    }
+    return { key, value: raw };
+}
+/**
+ * Combines repeated `-f` and `-F` flag values into a single object.
+ * String fields (`-f`) are applied first, then typed fields (`-F`), so
+ * typed fields win on key collision regardless of CLI argument order.
+ * Commander collects the two flags into separate arrays, so the original
+ * interleaved order is lost by the time we get here.
+ */
+export function buildFieldObject(stringFields = [], typedFields = []) {
+    const result = {};
+    for (const input of stringFields) {
+        const { key, value } = parseStringField(input);
+        result[key] = value;
+    }
+    for (const input of typedFields) {
+        const { key, value } = parseTypedField(input);
+        result[key] = value;
+    }
+    return result;
+}
+function readJsonFile(path) {
+    let contents;
+    try {
+        contents = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Cannot read "${path}": ${message}`);
+    }
+    try {
+        return JSON.parse(contents);
+    }
+    catch {
+        throw new Error(`File "${path}" is not valid JSON.`);
+    }
+}

package/dist/api/read-input.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reads a raw JSON body from a file path or from stdin (when path is
+ * `"-"`). Returns the parsed JSON value. Throws if the input is not
+ * valid JSON or the file cannot be read.
+ */
+export declare function readInputJson(path: string): unknown;

package/dist/api/read-input.js

@@ -0,0 +1,28 @@
+import { readFileSync } from "node:fs";
+/**
+ * Reads a raw JSON body from a file path or from stdin (when path is
+ * `"-"`). Returns the parsed JSON value. Throws if the input is not
+ * valid JSON or the file cannot be read.
+ */
+export function readInputJson(path) {
+    const contents = path === "-" ? readStdin() : readFile(path);
+    try {
+        return JSON.parse(contents);
+    }
+    catch {
+        const source = path === "-" ? "stdin" : `"${path}"`;
+        throw new Error(`Input from ${source} is not valid JSON.`);
+    }
+}
+function readFile(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Cannot read "${path}": ${message}`);
+    }
+}
+function readStdin() {
+    return readFileSync(0, "utf8");
+}

package/dist/bin/create-program.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+/**
+ * Build a fresh `Command` tree for the CLI. Shared between the real
+ * binary (`bin/duvo.ts`) and the test harness so tests can never
+ * silently drift out of sync with the production command set.
+ */
+export declare function createProgram(): Command;

package/dist/bin/create-program.js

@@ -0,0 +1,27 @@
+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 { registerWhoami } from "../commands/whoami.js";
+/**
+ * Build a fresh `Command` tree for the CLI. Shared between the real
+ * binary (`bin/duvo.ts`) and the test harness so tests can never
+ * silently drift out of sync with the production command set.
+ */
+export function createProgram() {
+    const program = new Command();
+    program
+        .name("duvo")
+        .description("Command-line interface for the Duvo public API")
+        .version("0.0.0")
+        .option("--profile <name>", "use a specific profile for this invocation (overrides default profile)");
+    registerLogin(program);
+    registerLogout(program);
+    registerWhoami(program);
+    registerProfiles(program);
+    registerApi(program);
+    registerAgents(program);
+    return program;
+}

package/dist/bin/duvo.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/duvo.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { createProgram } from "../bin/create-program.js";
+import { handleCliError } from "../errors.js";
+createProgram()
+    .parseAsync(process.argv)
+    .catch((error) => {
+    handleCliError(error);
+});

package/dist/client/client.d.ts

@@ -0,0 +1,23 @@
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+export type HttpRequestOptions = {
+    method: string;
+    path: string;
+    apiKey: string;
+    apiBaseUrl: string;
+    /** JSON body. Omitted for GET/HEAD-style requests. */
+    body?: unknown;
+    /** Appended to the resolved URL. */
+    searchParams?: URLSearchParams;
+    /** Request timeout in ms. Defaults to {@link DEFAULT_REQUEST_TIMEOUT_MS}. */
+    timeoutMs?: number;
+};
+/**
+ * Makes an authenticated request to the Duvo public API and returns the
+ * parsed JSON response. Maps well-known status codes to `CliError` with
+ * the right exit code; other non-2xx responses throw a generic
+ * `CliError` containing the server's response body.
+ *
+ * Empty response bodies resolve to `null`. Non-JSON responses resolve to
+ * the raw text — the caller decides how to render it.
+ */
+export declare function httpRequest(options: HttpRequestOptions): Promise<unknown>;

package/dist/client/client.js

@@ -0,0 +1,96 @@
+import { CliError, EXIT_CODE } from "../errors.js";
+export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+/**
+ * Makes an authenticated request to the Duvo public API and returns the
+ * parsed JSON response. Maps well-known status codes to `CliError` with
+ * the right exit code; other non-2xx responses throw a generic
+ * `CliError` containing the server's response body.
+ *
+ * Empty response bodies resolve to `null`. Non-JSON responses resolve to
+ * the raw text — the caller decides how to render it.
+ */
+export async function httpRequest(options) {
+    const url = buildUrl(options.apiBaseUrl, options.path, options.searchParams);
+    const headers = {
+        Authorization: `Bearer ${options.apiKey}`,
+        Accept: "application/json",
+    };
+    const timeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    const init = {
+        method: options.method,
+        headers,
+        signal: AbortSignal.timeout(timeoutMs),
+    };
+    if (options.body !== undefined) {
+        headers["Content-Type"] = "application/json";
+        init.body = JSON.stringify(options.body);
+    }
+    try {
+        const response = await fetch(url, init);
+        return await handleResponse(response, options.method, options.path);
+    }
+    catch (error) {
+        if (isTimeoutError(error)) {
+            throw new CliError(`Request timed out after ${timeoutMs}ms: ${options.method} ${options.path}`);
+        }
+        throw error;
+    }
+}
+function isTimeoutError(error) {
+    return (error instanceof DOMException &&
+        (error.name === "TimeoutError" || error.name === "AbortError"));
+}
+/**
+ * Resolves an API path against the configured base URL. The base URL must
+ * be an origin only (scheme + host + optional port) — any path component
+ * is discarded, because `new URL("/v1/agents", "https://host/foo/")`
+ * resolves to `https://host/v1/agents`, not `https://host/foo/v1/agents`.
+ */
+const ABSOLUTE_URL = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//;
+function buildUrl(base, path, searchParams) {
+    if (ABSOLUTE_URL.test(path)) {
+        throw new CliError(`Invalid path "${path}". Expected an API path like "/v1/agents" — absolute URLs are not allowed.`);
+    }
+    const normalized = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(normalized, ensureTrailingSlash(base));
+    if (searchParams) {
+        for (const [key, value] of searchParams) {
+            url.searchParams.append(key, value);
+        }
+    }
+    return url;
+}
+function ensureTrailingSlash(base) {
+    return base.endsWith("/") ? base : `${base}/`;
+}
+async function handleResponse(response, method, path) {
+    if (response.status === 401) {
+        throw new CliError("Unauthorized. Check that the API key is valid.", EXIT_CODE.AUTH);
+    }
+    if (response.status === 404) {
+        throw new CliError(`Not found: ${method} ${path}`, EXIT_CODE.NOT_FOUND);
+    }
+    if (!response.ok) {
+        const detail = await safeReadText(response);
+        const suffix = detail.length > 0 ? `: ${detail}` : "";
+        throw new CliError(`Request failed (${response.status} ${response.statusText})${suffix}`);
+    }
+    const text = await safeReadText(response);
+    if (text.length === 0) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function safeReadText(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return "";
+    }
+}

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

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

package/dist/commands/agents/get.js

@@ -0,0 +1,42 @@
+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 { printJson } from "../../output/json.js";
+import { renderKeyValue } from "../../output/text.js";
+import { getProfileFlag } from "../shared/profile-flag.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 raw = await httpRequest({
+            method: "GET",
+            path: `/v1/agents/${encodeURIComponent(id)}`,
+            apiKey: resolved.apiKey,
+            apiBaseUrl: resolved.apiBaseUrl,
+        });
+        if (options.json) {
+            printJson(raw);
+            return;
+        }
+        const parsed = getAgentResponseSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new CliError(`Unexpected response from the API: ${parsed.error.message}`);
+        }
+        const { agent } = parsed.data;
+        console.log(renderKeyValue([
+            { label: "ID", value: agent.id },
+            { label: "Name", value: agent.name },
+            { label: "Created", value: agent.created_at ?? "" },
+            { label: "Updated", value: agent.updated_at ?? "" },
+        ]));
+    });
+}

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

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

package/dist/commands/agents/index.js

@@ -0,0 +1,9 @@
+import { registerAgentsGet } from "./get.js";
+import { registerAgentsList } from "./list.js";
+export function registerAgents(program) {
+    const agents = program
+        .command("agents")
+        .description("Manage agents in the Duvo public API");
+    registerAgentsList(agents);
+    registerAgentsGet(agents);
+}

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

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

package/dist/commands/agents/list.js

@@ -0,0 +1,67 @@
+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 { 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";
+const DEFAULT_LIMIT = 20;
+const MIN_LIMIT = 1;
+const MAX_LIMIT = 100;
+const TABLE_COLUMNS = [
+    { header: "ID", cell: (row) => row.id },
+    { header: "NAME", cell: (row) => row.name },
+    { header: "CREATED", cell: (row) => row.created_at ?? "" },
+];
+export function registerAgentsList(agents) {
+    agents
+        .command("list", { isDefault: true })
+        .description("List agents for your team")
+        .option("--limit <n>", `page size (${MIN_LIMIT}-${MAX_LIMIT})`)
+        .option("--offset <n>", "number of agents to skip")
+        .option("--json", "output raw JSON from the API")
+        .action(async function listAction(options) {
+        const limit = parseLimit(options.limit, {
+            defaultValue: DEFAULT_LIMIT,
+            min: MIN_LIMIT,
+            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 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,
+            searchParams,
+        });
+        if (options.json) {
+            printJson(raw);
+            return;
+        }
+        const parsed = listAgentsResponseSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new CliError(`Unexpected response from the API: ${parsed.error.message}`);
+        }
+        const response = parsed.data;
+        if (response.agents.length === 0) {
+            console.log("No agents found.");
+            return;
+        }
+        console.log(renderTable(TABLE_COLUMNS, response.agents));
+        const resolvedOffset = response.offset ?? offset;
+        const summary = response.total === null || response.total === undefined
+            ? `Showing ${response.agents.length} · offset ${resolvedOffset}`
+            : `Showing ${response.agents.length} of ${response.total} · offset ${resolvedOffset}`;
+        console.log(summary);
+    });
+}

package/dist/commands/api-render.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Routes the response through the shared output pipeline per GUIDE.md:
+ * collections render as a table, single objects as a key/value block,
+ * everything else (and `--json`) falls back to pretty JSON. `duvo api`
+ * has no schema, so columns and labels come straight from the response
+ * keys.
+ */
+export declare function renderApiResponse(response: unknown, asJson: boolean): void;

package/dist/commands/api-render.js

@@ -0,0 +1,72 @@
+import { printJson } from "../output/json.js";
+import { renderTable } from "../output/table.js";
+import { renderKeyValue } from "../output/text.js";
+const FALLBACK_TERMINAL_WIDTH = 120;
+const MIN_COLUMN_WIDTH = 8;
+const COLUMN_GUTTER = 2;
+/**
+ * Routes the response through the shared output pipeline per GUIDE.md:
+ * collections render as a table, single objects as a key/value block,
+ * everything else (and `--json`) falls back to pretty JSON. `duvo api`
+ * has no schema, so columns and labels come straight from the response
+ * keys.
+ */
+export function renderApiResponse(response, asJson) {
+    if (asJson) {
+        printJson(response);
+        return;
+    }
+    if (Array.isArray(response)) {
+        if (response.length === 0) {
+            console.log("No results.");
+            return;
+        }
+        if (response.every(isRecord)) {
+            renderTableResponse(response);
+            return;
+        }
+    }
+    if (isRecord(response)) {
+        const entries = Object.entries(response).map(([key, value]) => {
+            return { label: key, value: formatScalar(value) };
+        });
+        console.log(renderKeyValue(entries));
+        return;
+    }
+    printJson(response);
+}
+function renderTableResponse(rows) {
+    const keys = Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
+    const maxWidth = perColumnMaxWidth(keys.length);
+    const columns = keys.map((key) => {
+        return {
+            header: key.toUpperCase(),
+            cell: (row) => formatScalar(row[key]),
+            maxWidth,
+        };
+    });
+    console.log(renderTable(columns, rows));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function perColumnMaxWidth(columnCount) {
+    if (columnCount === 0) {
+        return MIN_COLUMN_WIDTH;
+    }
+    const terminalWidth = process.stdout.columns ?? FALLBACK_TERMINAL_WIDTH;
+    const budget = terminalWidth - COLUMN_GUTTER * (columnCount - 1);
+    return Math.max(MIN_COLUMN_WIDTH, Math.floor(budget / columnCount));
+}
+function formatScalar(value) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return JSON.stringify(value);
+}

package/dist/commands/api.d.ts

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