honeydo 0.1.0

package/packages/doubao/dist/cli.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+/**
+ * doubao — CLI for generating images via the Doubao (Volces Ark) API.
+ *
+ * Sends a prompt to the Ark image-generation endpoint, walks a model fallback
+ * chain (5-0 → lite → 4-5) when a model is not activated for the account,
+ * downloads the result, and saves it to a file. Last stdout line is always
+ * "Saved to: <absolute path>" so scripts can grep it.
+ */
+import { mkdir, writeFile } from "node:fs/promises";
+import { realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+const DEFAULT_MODEL = "doubao-seedream-5-0-260128";
+const FALLBACK_MODELS = [
+    "doubao-seedream-5-0-lite-260128",
+    "doubao-seedream-4-5-251128",
+];
+const MODEL_CANDIDATES = [DEFAULT_MODEL, ...FALLBACK_MODELS];
+export const DEFAULT_SIZE = "2K";
+const PRESET_SIZES = new Set(["2K", "3K"]);
+const PIXEL_SIZE_PATTERN = /^(\d{2,5})x(\d{2,5})$/i;
+const API_URL = "https://ark.cn-beijing.volces.com/api/v3/images/generations";
+// ---------------------------------------------------------------------------
+// Pure helpers (unit-tested)
+// ---------------------------------------------------------------------------
+export function normalizeSize(sizeInput) {
+    const trimmedSize = sizeInput.trim();
+    const upperSize = trimmedSize.toUpperCase();
+    if (PRESET_SIZES.has(upperSize))
+        return upperSize;
+    const sizeMatch = PIXEL_SIZE_PATTERN.exec(trimmedSize);
+    if (sizeMatch)
+        return `${sizeMatch[1]}x${sizeMatch[2]}`;
+    throw new Error('Invalid size. Supported values: "2K", "3K", or "<width>x<height>" (for example "3072x2048").');
+}
+export function isModelNotOpenError(status, errorText) {
+    return status === 404 && errorText.includes("ModelNotOpen");
+}
+export function resolveSizeForModel(size, model) {
+    // 3K shorthand is available in 5.0 models; map it to explicit pixels for older fallbacks.
+    if (size === "3K" && !model.startsWith("doubao-seedream-5-0")) {
+        return "3072x3072";
+    }
+    return size;
+}
+export function parseCliArgs(argv) {
+    try {
+        const { values, positionals } = parseArgs({
+            args: argv,
+            options: {
+                size: { type: "string" },
+                output: { type: "string" },
+                help: { type: "boolean" },
+            },
+            allowPositionals: true,
+        });
+        return {
+            prompt: positionals[0],
+            size: values.size,
+            output: values.output,
+            help: values.help ?? false,
+        };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function sanitizePrompt(prompt) {
+    return prompt
+        .substring(0, 50)
+        .replace(/[^a-z0-9]/gi, "_")
+        .toLowerCase();
+}
+export async function generateImage(input) {
+    const normalizedSize = input.size ? normalizeSize(input.size) : DEFAULT_SIZE;
+    let result = null;
+    let modelUsed = DEFAULT_MODEL;
+    let sizeUsed = normalizedSize;
+    let lastModelNotOpenError = "";
+    for (const candidateModel of MODEL_CANDIDATES) {
+        const candidateSize = resolveSizeForModel(normalizedSize, candidateModel);
+        const requestBody = {
+            model: candidateModel,
+            prompt: input.prompt,
+            sequential_image_generation: "disabled",
+            response_format: "url",
+            size: candidateSize,
+            stream: false,
+            watermark: false,
+        };
+        const response = await fetch(API_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`,
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (response.ok) {
+            result = (await response.json());
+            modelUsed = candidateModel;
+            sizeUsed = candidateSize;
+            break;
+        }
+        const errorText = await response.text();
+        if (isModelNotOpenError(response.status, errorText)) {
+            lastModelNotOpenError = `Doubao API error: ${response.status} ${response.statusText} - ${errorText}`;
+            continue;
+        }
+        throw new Error(`Doubao API error: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    if (!result) {
+        throw new Error(`No available model for this account. Tried: ${MODEL_CANDIDATES.join(", ")}. Last error: ${lastModelNotOpenError}`);
+    }
+    const imageUrl = result.data?.[0]?.url;
+    if (!imageUrl) {
+        throw new Error("No image URL in response from Doubao API");
+    }
+    const imageResponse = await fetch(imageUrl);
+    if (!imageResponse.ok) {
+        throw new Error(`Failed to download image from ${imageUrl}: ${imageResponse.status} ${imageResponse.statusText}`);
+    }
+    const imageBuffer = await imageResponse.arrayBuffer();
+    const filePath = input.output
+        ? resolve(input.output)
+        : join(process.cwd(), "generated_images", `${Date.now()}_${sanitizePrompt(input.prompt)}.png`);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, Buffer.from(imageBuffer));
+    const returnedSize = typeof result.data?.[0]?.size === "string"
+        ? result.data[0].size
+        : "unknown";
+    return {
+        filePath,
+        model: typeof result.model === "string" ? result.model : modelUsed,
+        requestedSize: normalizedSize,
+        appliedSize: sizeUsed,
+        returnedSize,
+    };
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+const HELP = `Usage: doubao "<prompt>" [options]
+
+Generate an image via the Doubao (Volces Ark) API and save it to a file.
+
+Options:
+  "<prompt>"            (required) Text description of the image to generate
+      --size <s>        "2K" (default), "3K", or "<width>x<height>" (e.g. 3072x2048)
+      --output <path>   Output file path (default: ./generated_images/<ts>_<prompt>.png)
+      --help            Show this help
+
+Exit codes: 0 success | 1 API error / missing DOUBAO_API_KEY | 2 bad args
+On success the last stdout line is "Saved to: <absolute path>".`;
+async function main() {
+    const parsed = parseCliArgs(process.argv.slice(2));
+    if ("error" in parsed) {
+        process.stderr.write(`doubao: ${parsed.error}\n`);
+        process.exit(2);
+    }
+    if (parsed.help) {
+        process.stdout.write(`${HELP}\n`);
+        process.exit(0);
+    }
+    if (!parsed.prompt) {
+        process.stderr.write("doubao: prompt is required (pass it as the first argument)\n");
+        process.exit(2);
+    }
+    const apiKey = process.env.DOUBAO_API_KEY;
+    if (!apiKey) {
+        process.stderr.write("doubao: DOUBAO_API_KEY environment variable is not set\n");
+        process.exit(1);
+    }
+    try {
+        const r = await generateImage({
+            prompt: parsed.prompt,
+            size: parsed.size,
+            output: parsed.output,
+            apiKey,
+        });
+        process.stdout.write([
+            "Image generated successfully!",
+            `Model: ${r.model}`,
+            `Requested size: ${r.requestedSize}`,
+            `Applied size: ${r.appliedSize}`,
+            `Returned size: ${r.returnedSize}`,
+            `Saved to: ${r.filePath}`,
+        ].join("\n") + "\n");
+        process.exit(0);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`doubao: Error generating image: ${msg}\n`);
+        process.exit(1);
+    }
+}
+const invokedDirectly = process.argv[1] !== undefined &&
+    realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+if (invokedDirectly) {
+    main().catch((err) => {
+        process.stderr.write(`doubao: fatal ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    });
+}

package/packages/gcli/dist/cli.d.ts

@@ -0,0 +1,465 @@
+#!/usr/bin/env node
+/**
+ * gcli — thin wrapper around the `agy` and `claude` CLI backends.
+ *
+ * Default backend is claude: bare `gcli ...` is exactly `gcli claude ...`.
+ * `gcli agy ...` routes to the agy CLI (explicit subcommand required); the
+ * claude backend can switch cc-switch providers inline via
+ * `claude -p ... --settings`. Adds value over calling the backends directly:
+ * prompt via argv or stdin (`-p -`), 50k-char output truncation, a hard
+ * timeout (spawn SIGTERM), explicit exit codes, and empty-output detection.
+ *
+ * The claude backend resolves `--provider <name>` from the cc-switch SQLite
+ * DB (read-only) and never rewrites ~/.claude/settings.json — the provider
+ * switch happens entirely through claude's own `--settings` merge. In a TTY
+ * without --provider it offers an interactive arrow-key picker over the
+ * cc-switch provider list (↑↓/j/k move · Enter confirm · Esc keep default);
+ * the last confirmed provider is remembered in ~/.config/gcli/last-provider
+ * and reused silently in print mode. Without a TTY the picker never triggers
+ * (zero prompts, zero DB reads, zero memory-file IO) so skills/CI never hang.
+ *
+ * Note: on the default (claude) path --yolo/--sandbox are rejected (exit 2);
+ * agy users must opt in via the explicit `gcli agy` subcommand.
+ *
+ * Timeout is enforced by spawn SIGTERM (deterministic), not via either
+ * backend's own timeout flag.
+ */
+export declare const DEFAULT_TIMEOUT_MS = 300000;
+export declare const CHARACTER_LIMIT = 50000;
+export declare const API_DEFAULT_MAX_TOKENS = 80000;
+/**
+ * Path to the cc-switch SQLite database. cc-switch ships provider configs
+ * (including ANTHROPIC_* env) here; gcli reads it read-only to resolve
+ * `--provider <name>` for the claude backend.
+ */
+export declare const CC_SWITCH_DB_PATH: string;
+/**
+ * Memory file for the last picker-confirmed provider (D2). Content is a
+ * single UTF-8 line with the provider name. Read on the TTY claude path with
+ * no --provider (exact-name match against the current list; mismatch/missing/
+ * unreadable → silently ignored); written best-effort after a picker confirm.
+ * Never read or written on a non-TTY path (zero side effects for skills/CI).
+ */
+export declare const LAST_PROVIDER_PATH: string;
+/**
+ * Quota subtitle cache (revise-3, C-Q5): `{[name]: {ts, ok, text?}}`.
+ * TTL ok 60s / fail 15s (statusline-sage semantics); reads/writes are
+ * best-effort — the quota subtitle is an optimization, never an error.
+ */
+export declare const QUOTA_CACHE_PATH: string;
+export type Subcommand = "agy" | "claude" | "api";
+export type SubcommandResult = {
+    subcommand: Subcommand | undefined;
+    rest: string[];
+} | {
+    error: string;
+};
+/** Three-layer provider-name match outcome (C4). */
+export type MatchOutcome = {
+    matched: string;
+} | {
+    none: true;
+} | {
+    ambiguous: string[];
+};
+export type ProviderEnvResult = {
+    env: Record<string, string>;
+} | {
+    error: string;
+};
+/** One picker keypress → state transition (C-P2). */
+export type PickerKeyAction = {
+    type: "move";
+    index: number;
+} | {
+    type: "confirm";
+} | {
+    type: "skip";
+} | {
+    type: "noop";
+};
+/** One selectable row of the arrow-key picker: a cc-switch provider. */
+export type PickerEntry = {
+    name: string;
+    quota?: string;
+};
+/** Result of the arrow-key picker (C-P1): a picked provider, or a skip. */
+export type PickerOutcome = {
+    kind: "select";
+    entry: PickerEntry;
+} | {
+    kind: "skip";
+};
+/** A cc-switch provider row as exposed to the claude backend. */
+export type RawProvider = {
+    name: string;
+    settingsConfig: unknown;
+};
+export type ProviderLookup = {
+    ok: true;
+    providers: RawProvider[];
+} | {
+    ok: false;
+    kind: "db-missing" | "sqlite-missing" | "parse";
+    message: string;
+};
+/** Normalized spawn result shared by both backends (print mode). */
+export type SpawnResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    signal?: string | null;
+    timedOut?: boolean;
+};
+/** Spawn result for interactive mode: stdio inherited, nothing captured. */
+export type InteractiveSpawnResult = {
+    exitCode: number;
+    signal?: string | null;
+    spawnError?: string;
+};
+/** Injectable dependencies for `run()` — tests pass fakes (C1/C2 routing). */
+export type RunDeps = {
+    readCcSwitchProvider: () => Promise<ProviderLookup>;
+    runClaude: (args: string[], timeoutMs?: number, cwd?: string) => Promise<SpawnResult>;
+    runAgy: (args: string[], timeoutMs?: number, cwd?: string) => Promise<SpawnResult>;
+    /**
+     * api backend: POST to an anthropic-compatible /v1/messages endpoint.
+     * Implementations handle fetch + SSE parsing + idle/absolute timeout and
+     * return a normalized RunOutcome (0 success / 1 error·timeout·empty).
+     * Injected so acceptance tests never hit a real API.
+     */
+    runApi: (req: ApiRequest) => Promise<RunOutcome>;
+    readStdin: () => Promise<string>;
+    runClaudeInteractive: (args: string[], cwd?: string) => Promise<InteractiveSpawnResult>;
+    runAgyInteractive: (args: string[], cwd?: string) => Promise<InteractiveSpawnResult>;
+    isInteractive: () => boolean;
+    /**
+     * TTY-only arrow-key provider picker (C-P1/C-P3): present the cc-switch
+     * provider entries (the production impl appends its own trailing 不切换
+     * row — `entries` holds providers only) and resolve the confirmed entry,
+     * or {kind:"skip"} on Esc / the 不切换 row. `initialIndex` is the caller-
+     * computed row to highlight (memory hit or 0); implementations clamp it.
+     * Only ever invoked on the claude path in a TTY with no --provider —
+     * non-interactive callers (skills/CI/pipes) must see zero prompts and
+     * zero extra cc-switch DB reads.
+     */
+    pickProvider: (entries: PickerEntry[], initialIndex: number) => Promise<PickerOutcome>;
+    /**
+     * Quota subtitles (revise-3, C-Q4): given every menu provider's {name, env},
+     * resolve name → formatted quota text (only providers with usable data are
+     * in the Map). Only invoked on the TTY menu path right before pickProvider —
+     * silent reuse / explicit --provider / non-TTY / degraded paths never call.
+     */
+    fetchProviderQuotas: (items: {
+        name: string;
+        env: Record<string, string>;
+    }[]) => Promise<Map<string, string>>;
+    /**
+     * Read the remembered provider name (D2): trimmed first line of
+     * LAST_PROVIDER_PATH, or undefined when missing/empty/unreadable. Only
+     * invoked on the TTY claude path with no --provider.
+     */
+    readLastProvider: () => Promise<string | undefined>;
+    /**
+     * Persist the picker-confirmed provider name (D2). Best-effort: failures
+     * are swallowed (memory is an optimization, never an error). Only invoked
+     * after an arrow-key picker confirm, before any backend spawn.
+     */
+    writeLastProvider: (name: string) => Promise<void>;
+};
+export type RunOutcome = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+/**
+ * Detect a leading `agy`/`claude`/`api` subcommand and strip it. Strict (C1):
+ * - argv[0] === "agy"    → subcommand "agy",    rest = argv.slice(1)
+ * - argv[0] === "claude" → subcommand "claude", rest = argv.slice(1)
+ * - argv[0] === "api"    → subcommand "api",    rest = argv.slice(1)
+ * - argv empty OR argv[0] starts with "-" → subcommand undefined (default
+ *   backend: claude)
+ * - argv[0] any other non-empty token → error "unknown subcommand: <x>"
+ *
+ * This keeps `gcli -p claude` (argv[0]="-p") on the default claude path with
+ * prompt="claude" — the subcommand must literally lead.
+ */
+export declare function parseSubcommand(argv: string[]): SubcommandResult;
+export declare function truncate(text: string): string;
+export interface GcliOptions {
+    /** Omit for interactive mode (no -p emitted). */
+    prompt?: string;
+    model?: string;
+    yolo: boolean;
+    sandbox: boolean;
+    cwd?: string;
+    timeoutMs: number;
+    /** Args forwarded to the backend verbatim (from `--`). */
+    passthrough?: string[];
+}
+/** Translate gcli options into agy argv. Timeout is enforced by spawn kill.
+ * prompt is optional — when undefined, no -p is emitted (interactive mode). */
+export declare function buildAgyArgs(opts: GcliOptions): string[];
+/**
+ * Three-layer provider name matching (C4a):
+ * 1. exact equality
+ * 2. case-insensitive equality
+ * 3. substring (query within name, case-insensitive)
+ * Within the first layer that produces any hit: 1 → {matched}, >1 →
+ * {ambiguous}, 0 → fall through. No layer hits → {none}.
+ */
+export declare function matchProviderName(query: string, names: string[]): MatchOutcome;
+/**
+ * Parse a `settings_config` JSON string and return its `env` block (C4c).
+ * Errors (with diagnostics) on malformed JSON, non-object root, or a
+ * missing/non-object env.
+ */
+export declare function extractProviderEnv(settingsConfigJson: string): ProviderEnvResult;
+/**
+ * Copy provider env and explicitly pin `ANTHROPIC_MODEL` (C5).
+ *
+ * Why: `claude --settings` is a *merge*, not replace — a stale
+ * ANTHROPIC_MODEL in the global settings.json would leak through. We always
+ * set the key (empty string when nothing is derivable — JSON.stringify omits
+ * undefined, which would let a stale global value leak back in).
+ *
+ * Priority: model > provider ANTHROPIC_MODEL > DEFAULT_SONNET_MODEL
+ * > DEFAULT_OPUS_MODEL > first sorted DEFAULT_*_MODEL.
+ */
+export declare function buildSettingsEnv(providerEnv: Record<string, string>, model?: string): Record<string, string>;
+/**
+ * Shape of a readline keypress event's `key` argument (C-P2, revise-2).
+ */
+export type PickerKeyInput = {
+    name?: string;
+    ctrl?: boolean;
+    meta?: boolean;
+};
+/**
+ * Map one arrow-key picker keypress to its state transition (C-P2, revise-2).
+ *
+ * `k` is the keypress event's `key` object:
+ * - "up" / "k"   → move up one row, wrapping past the top (环形)
+ * - "down" / "j" → move down one row, wrapping past the bottom (环形)
+ * - "return" / "enter" → confirm the current row (the physical Enter key
+ *   emits "return" in raw mode; "enter" is the LF byte, which a tty may
+ *   substitute for CR in input buffered before raw mode was enabled)
+ * - "escape"     → skip (不切换)
+ * - Emacs (revise-2): ctrl+"n" ≡ down, ctrl+"p" ≡ up (same wrap); ctrl+"g"
+ *   ≡ escape → skip; meta+"<" → first row (absolute), meta+">" → last row
+ *   (absolute). Horizontal Emacs keys (C-f/C-b/C-a/C-e) and paging (C-v/M-v)
+ *   are deliberately NOT mapped — meaningless in a vertical menu.
+ * - anything else → noop (ctrl-c is handled by the caller: restore raw-mode,
+ *   exit 130)
+ *
+ * `index` is the highlighted row, `count` the total rendered rows INCLUDING
+ * the trailing 不切换 row. Movement wraps with `(index±1+count)%count`; with
+ * count <= 0 moves are a noop (nothing is rendered).
+ */
+export declare function applyPickerKey(k: PickerKeyInput, index: number, count: number): PickerKeyAction;
+/** One rate-limit window: usage percentage + ISO8601 reset timestamp. */
+export type QuotaWindow = {
+    pct: number;
+    resetIso: string;
+};
+/** Parsed quota windows: short = 5h rolling, weekly = long window. */
+export type QuotaWindows = {
+    short?: QuotaWindow;
+    weekly?: QuotaWindow;
+};
+/**
+ * Map a provider env to its quota API request (C-Q1):
+ * - base contains kimi.com / moonshot → kimi: `{domain}/coding/v1/usages`,
+ *   `Authorization: Bearer <token>` (bare token gets 401)
+ * - base contains bigmodel / z.ai → glm: `{domain}/api/monitor/usage/quota/limit`,
+ *   `Authorization: <token>` (NO Bearer prefix)
+ * - anything else (deepseek / packy / anthropic official / …) or missing
+ *   base/token/scheme → null: no quota API, zero requests, no subtitle.
+ */
+export declare function buildQuotaRequest(env: {
+    ANTHROPIC_BASE_URL?: string;
+    ANTHROPIC_AUTH_TOKEN?: string;
+}): {
+    kind: "kimi" | "glm";
+    url: string;
+    authHeader: string;
+} | null;
+/**
+ * Parse kimi `/coding/v1/usages` (C-Q2): `limits[]` entries with
+ * window.duration == 300 + MINUTE → short (5h) window; top-level `usage` →
+ * weekly. Malformed shapes yield missing windows, never throw.
+ */
+export declare function parseKimiUsages(body: unknown): QuotaWindows;
+/**
+ * Parse GLM `/api/monitor/usage/quota/limit` (C-Q2): data.limits[] entries
+ * with type == "TOKENS_LIMIT"; sorted by nextResetTime ascending — first is
+ * the short (5h) window, last the weekly one.
+ */
+export declare function parseGlmQuota(body: unknown): QuotaWindows;
+/**
+ * Format quota windows as the menu subtitle (C-Q3): `5h:P% wk:P% ↻<rel>`
+ * (short reset preferred for the ↻ segment); missing windows degrade; a
+ * missing/expired reset omits the ↻ segment entirely; no windows → "".
+ */
+export declare function formatQuota(q: QuotaWindows, nowMs: number): string;
+export interface ClaudeOptions {
+    /** Omit for interactive mode (no -p emitted). */
+    prompt?: string;
+    /** If provided, the env is wrapped as `--settings '{"env":{...}}'`. */
+    settingsEnv?: Record<string, string>;
+    cwd?: string;
+    /** Args forwarded to the backend verbatim (from `--`). */
+    passthrough?: string[];
+}
+/**
+ * Build claude argv (C8). `--model` is NOT passed here — for the claude
+ * backend it goes into the settings env's ANTHROPIC_MODEL via buildSettingsEnv.
+ * `--cwd` becomes `claude --add-dir` to match the agy convention.
+ * prompt is optional — when undefined, no -p is emitted (interactive mode).
+ */
+export declare function buildClaudeArgs(opts: ClaudeOptions): string[];
+/**
+ * Injectable api request (the shape deps.runApi consumes). All fields the
+ * production fetch impl needs, with nothing backend-specific leaking into the
+ * pure layer.
+ */
+export interface ApiRequest {
+    url: string;
+    token: string;
+    model: string;
+    maxTokens: number;
+    prompt: string;
+    stream: boolean;
+    timeoutMs: number;
+}
+/**
+ * Build the HTTP body for an anthropic-compatible /v1/messages request.
+ *
+ * thinking is intentionally NOT disabled: k3's extended thinking is the quality
+ * source for creative+SVG tasks (dry-run: single-block ~768-char thinking yields
+ * high-quality output in ~45s vs claude-agent's 53min). We rely on a sufficient
+ * --max-tokens budget (default 80000) to cover both thinking and text, not on
+ * disabling thinking. Disabling it would discard the very capability we chose
+ * k3 for.
+ */
+export declare function buildApiBody(req: Pick<ApiRequest, "model" | "maxTokens" | "prompt" | "stream">): Record<string, unknown>;
+/**
+ * Build the full URL for the messages endpoint. The cc-switch base_url is
+ * stored with a trailing slash (e.g. `https://api.kimi.com/coding/`); we
+ * append `v1/messages` without doubling the slash.
+ */
+export declare function buildApiEndpoint(baseUrl: string): string;
+/**
+ * SSE line → extracted text delta, or null if the line carries no text payload.
+ *
+ * Handles anthropic-compatible streaming events:
+ * - `data:{...}` JSON with `delta.type === "text_delta"` → the text fragment
+ * - `thinking_delta` / `signature_delta` / control events → null (ignored)
+ * - non-`data:` lines / malformed JSON → null
+ *
+ * The `data:` prefix is matched greedily and the remainder is trimmed, so both
+ * `data:{...}` (kimi, no space) and `data: {...}` (with space) parse the same.
+ */
+export declare function extractTextDelta(line: string): string | null;
+/**
+ * Aggregate text from a non-streaming messages response body.
+ *
+ * Non-stream responses look like `{ content: [{ type: "text", text: "..." }] }`;
+ * we concatenate every text block in order.
+ */
+export declare function extractNonStreamText(body: unknown): string;
+export interface ParsedArgs {
+    prompt?: string;
+    model?: string;
+    yolo: boolean;
+    sandbox: boolean;
+    cwd?: string;
+    timeoutMs: number;
+    version: boolean;
+    help: boolean;
+    provider?: string;
+    /** Force the provider picker menu, even in print mode (claude path only). */
+    pick: boolean;
+    /** Args after `--`, passed through to the backend verbatim. */
+    passthrough: string[];
+}
+export type ParseResult = ParsedArgs | {
+    error: string;
+};
+export declare function parseCliArgs(argv: string[]): ParseResult;
+/**
+ * Parsed options for the api backend. Unlike agy/claude there is no
+ * `passthrough`: the api backend builds an HTTP body directly, so unknown
+ * flags have no target to forward to and are rejected (exit 2).
+ */
+export interface ParsedApiArgs {
+    prompt?: string;
+    model?: string;
+    provider?: string;
+    maxTokens: number;
+    timeoutMs: number;
+    stream: boolean;
+    version: boolean;
+    help: boolean;
+    /** --cwd was supplied (warned + ignored by the api backend). */
+    cwd?: string;
+}
+export type ParseApiResult = ParsedApiArgs | {
+    error: string;
+};
+/**
+ * Parse argv for the api backend. Strict (contract: api does NOT passthrough):
+ * unknown flags and bare positionals are errors (`unknown option/positional`),
+ * mapped to exit 2 by the caller. `--no-stream` is accepted via
+ * `allowNegative` and flips `stream` to false.
+ */
+export declare function parseApiArgs(argv: string[]): ParseApiResult;
+export declare function runAgy(args: string[], timeoutMs: number, cwd?: string): Promise<SpawnResult>;
+/**
+ * Spawn the claude CLI with the same IO/timeout contract as `runAgy` (C6/C9).
+ * stdin is inherited so a piped prompt reaches claude when gcli passes `-p -`
+ * through. SIGTERM enforces the timeout deterministically.
+ */
+export declare function runClaude(args: string[], timeoutMs: number, cwd?: string): Promise<SpawnResult>;
+/** Spawn agy in interactive TUI mode (no -p, inherited stdio). */
+export declare function runAgyInteractive(args: string[], cwd?: string): Promise<InteractiveSpawnResult>;
+/** Spawn claude in interactive TUI mode (no -p, inherited stdio). */
+export declare function runClaudeInteractive(args: string[], cwd?: string): Promise<InteractiveSpawnResult>;
+/**
+ * Production deps.runApi: POST an anthropic-compatible /v1/messages request
+ * and return a normalized RunOutcome.
+ *
+ * - stream=true: reads the SSE body chunk-by-chunk, decodes UTF-8, splits on
+ *   newlines, and aggregates `text_delta` payloads into stdout. Two clocks
+ *   guard against hangs: an idle timer (reset on every text-bearing chunk)
+ *   and an absolute timer (timeoutMs). Either firing aborts the fetch via
+ *   AbortController → exit 1 with a timeout message.
+ * - stream=false: awaits the full JSON body and extracts `content[].text`,
+ *   then applies the 50k-char truncation.
+ *
+ * HTTP errors (non-2xx, network failure, abort) → exit 1 with diagnostics on
+ * stderr; stdout stays empty so the caller's empty-output guard still works.
+ */
+export declare function runApi(req: ApiRequest): Promise<RunOutcome>;
+/**
+ * Read all `app_type='claude'` providers from cc-switch.db (C4b/C4c).
+ *
+ * Uses `sqlite3 -readonly -json` (never opens the DB for write). Matching
+ * stays in the pure `matchProviderName` so it is unit-testable without a DB.
+ *
+ * Errors are classified for the caller: sqlite-missing (binary not on PATH),
+ * db-missing (sqlite3 exited non-zero, e.g. file absent), parse (bad JSON).
+ */
+export declare function readCcSwitchProvider(dbPath: string): Promise<ProviderLookup>;
+/**
+ * Validate a provider name against the allowlist (C4b). Returns the name, or
+ * an error object suitable for an exit-2 stderr line.
+ */
+export declare function validateProviderName(name: string): string | {
+    error: string;
+};
+/**
+ * Route argv to the agy / claude / api backend via injectable deps (C1/C2).
+ * Returns a {exitCode, stdout, stderr} outcome; main() owns process.exit.
+ */
+export declare function run(argv: string[], deps: RunDeps): Promise<RunOutcome>;