@tiny-fish/cli 0.1.3 → 0.1.4-next.35

package/dist/commands/batch.d.ts

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

package/dist/commands/batch.js

@@ -0,0 +1,223 @@
+import * as fs from "fs";
+import { randomUUID } from "crypto";
+import { getApiKey } from "../lib/auth.js";
+import { cancelBatchRuns, getBatchRuns, submitBatch } from "../lib/client.js";
+import { findBatch, loadBatches, saveBatch } from "../lib/batch-store.js";
+import { err, handleApiError, out, outLine } from "../lib/output.js";
+import { BASE_URL } from "../lib/constants.js";
+// ── CSV parsing ───────────────────────────────────────────────────────────────
+/**
+ * Parse one RFC 4180 field from `line` starting at `pos`.
+ * Returns { value, next } where `next` is the index after the field (at the
+ * delimiter comma or end-of-string). Throws on unclosed quotes.
+ */
+function parseField(line, pos, rowNum) {
+    if (line[pos] === '"') {
+        // Quoted field — read until closing unescaped quote
+        let value = "";
+        let i = pos + 1;
+        while (i < line.length) {
+            if (line[i] === '"') {
+                if (line[i + 1] === '"') {
+                    value += '"';
+                    i += 2;
+                    continue;
+                } // escaped quote
+                i++; // skip closing quote
+                break;
+            }
+            value += line[i++];
+        }
+        if (i > line.length)
+            throw new Error(`Row ${rowNum}: unclosed quote in field`);
+        // Skip optional comma after closing quote
+        return { value, next: line[i] === "," ? i + 1 : i };
+    }
+    // Unquoted field — read to next comma
+    const commaIdx = line.indexOf(",", pos);
+    if (commaIdx === -1)
+        return { value: line.slice(pos).trim(), next: line.length };
+    return { value: line.slice(pos, commaIdx).trim(), next: commaIdx + 1 };
+}
+/** Parse a strict two-column CSV with header row (url,goal). Supports RFC 4180 quoted fields. */
+function parseCsv(content) {
+    const lines = content.split(/\r?\n/).filter((l) => l.trim().length > 0);
+    if (lines.length === 0)
+        throw new Error("CSV file is empty");
+    const header = lines[0].trim();
+    if (header !== "url,goal") {
+        throw new Error(`Invalid CSV header: "${header}". Expected: "url,goal"`);
+    }
+    const dataLines = lines.slice(1);
+    if (dataLines.length === 0)
+        throw new Error("CSV file has no data rows");
+    return dataLines.map((line, idx) => {
+        const rowNum = idx + 2;
+        const urlField = parseField(line, 0, rowNum);
+        if (urlField.next >= line.length && line.indexOf(",") === -1) {
+            throw new Error(`Row ${rowNum}: missing comma separator — "${line}"`);
+        }
+        const goalField = parseField(line, urlField.next, rowNum);
+        if (!urlField.value)
+            throw new Error(`Row ${rowNum}: missing url — "${line}"`);
+        if (!goalField.value)
+            throw new Error(`Row ${rowNum}: missing goal — "${line}"`);
+        return { url: urlField.value, goal: goalField.value };
+    });
+}
+// ── register ──────────────────────────────────────────────────────────────────
+export function registerBatch(agentCmd) {
+    const batchCmd = agentCmd
+        .command("batch")
+        .description("Batch run operations")
+        .enablePositionalOptions();
+    // ── batch run ───────────────────────────────────────────────────────────────
+    batchCmd
+        .command("run")
+        .description("Submit a batch of runs from a CSV file (columns: url,goal)")
+        .requiredOption("--input <file>", "Path to CSV file with columns: url,goal")
+        .option("--pretty", "Human-readable output")
+        .action(async (opts) => {
+        // Read CSV file
+        let csvContent;
+        try {
+            csvContent = fs.readFileSync(opts.input, "utf8");
+        }
+        catch {
+            err({ error: `Cannot read file: ${opts.input}` });
+            process.exit(1);
+        }
+        // Parse CSV — throws on any malformed input
+        let runs;
+        try {
+            runs = parseCsv(csvContent);
+        }
+        catch (e) {
+            err({ error: String(e instanceof Error ? e.message : e), recommended_action: "Fix the CSV file and try again" });
+            process.exit(1);
+        }
+        const apiKey = getApiKey();
+        const response = await submitBatch({ runs }, apiKey).catch(handleApiError);
+        // Surface application-level errors from the API before persisting
+        if (response.error)
+            handleApiError(response.error);
+        const runIds = response.run_ids;
+        if (!runIds || runIds.length === 0) {
+            err({ error: "Batch submission returned no run IDs", recommended_action: "Check the API key and try again" });
+            process.exit(1);
+        }
+        const submitted = runIds.length;
+        const batchId = randomUUID();
+        const createdAt = new Date().toISOString();
+        const batch = {
+            batch_id: batchId,
+            run_ids: runIds,
+            total: runs.length,
+            submitted,
+            created_at: createdAt,
+        };
+        saveBatch(batch);
+        const resultsUrl = `${BASE_URL}/runs`;
+        if (opts.pretty) {
+            outLine("Batch submitted");
+            outLine(`ID:        ${batchId}`);
+            outLine(`Total:     ${runs.length}`);
+            outLine(`Submitted: ${submitted}`);
+            outLine(`Runs URL:  ${resultsUrl}`);
+        }
+        else {
+            out({ data: { batch_id: batchId, total: runs.length, submitted, results_url: resultsUrl } });
+        }
+    });
+    // ── batch list ──────────────────────────────────────────────────────────────
+    batchCmd
+        .command("list")
+        .description("List locally tracked batches")
+        .option("--pretty", "Human-readable output")
+        .action((opts) => {
+        const batches = loadBatches();
+        if (opts.pretty) {
+            if (batches.length === 0) {
+                outLine("No batches found.");
+                return;
+            }
+            outLine(`${"BATCH ID".padEnd(38)}  ${"TOTAL".padEnd(6)}  ${"SUBMITTED".padEnd(9)}  CREATED AT`);
+            outLine(`${"-".repeat(38)}  ${"-".repeat(6)}  ${"-".repeat(9)}  ${"-".repeat(24)}`);
+            for (const b of batches) {
+                outLine(`${b.batch_id.padEnd(38)}  ${String(b.total).padEnd(6)}  ${String(b.submitted).padEnd(9)}  ${b.created_at}`);
+            }
+        }
+        else {
+            out(batches);
+        }
+    });
+    // ── batch get ───────────────────────────────────────────────────────────────
+    batchCmd
+        .command("get <batch_id>")
+        .description("Get run results for a batch")
+        .option("--pretty", "Human-readable output")
+        .action(async (batchId, opts) => {
+        const batch = findBatch(batchId);
+        if (!batch) {
+            err({ error: `Batch not found: ${batchId}` });
+            process.exit(1);
+        }
+        const apiKey = getApiKey();
+        const response = await getBatchRuns(batch.run_ids, apiKey).catch(handleApiError);
+        if (opts.pretty) {
+            outLine(`Batch:     ${batchId}`);
+            outLine(`Total:     ${batch.total}`);
+            outLine(`Found:     ${response.data.length}`);
+            if (response.not_found && response.not_found.length > 0) {
+                outLine(`Not found: ${response.not_found.length}`);
+            }
+            for (const run of response.data) {
+                outLine("");
+                outLine(`Run:    ${run.run_id}`);
+                outLine(`Status: ${run.status}${run.num_of_steps != null ? `  (${run.num_of_steps} steps)` : ""}`);
+                outLine(`Goal:   ${run.goal}`);
+                if (run.result != null) {
+                    outLine(`Result: ${JSON.stringify(run.result, null, 2).replace(/\n/g, "\n        ")}`);
+                }
+                else if (run.error) {
+                    outLine(`Error:  ${JSON.stringify(run.error)}`);
+                }
+            }
+        }
+        else {
+            out({ batch_id: batchId, ...response });
+        }
+    });
+    // ── batch cancel ─────────────────────────────────────────────────────────────
+    batchCmd
+        .command("cancel <batch_id>")
+        .description("Cancel all runs in a batch")
+        .option("--pretty", "Human-readable output")
+        .action(async (batchId, opts) => {
+        const batch = findBatch(batchId);
+        if (!batch) {
+            err({ error: `Batch not found: ${batchId}` });
+            process.exit(1);
+        }
+        const apiKey = getApiKey();
+        const response = await cancelBatchRuns(batch.run_ids, apiKey).catch(handleApiError);
+        if (opts.pretty) {
+            const cancelled = response.results.filter((r) => r.status === "CANCELLED").length;
+            outLine(`Batch ${batchId}: ${cancelled}/${response.results.length} run(s) cancelled.`);
+            if (response.results.length > 0) {
+                outLine("");
+                outLine(`${"RUN ID".padEnd(36)}  ${"STATUS".padEnd(10)}  CANCELLED AT`);
+                outLine(`${"-".repeat(36)}  ${"-".repeat(10)}  ${"-".repeat(24)}`);
+                for (const r of response.results) {
+                    outLine(`${r.run_id.padEnd(36)}  ${r.status.padEnd(10)}  ${r.cancelled_at ?? "-"}`);
+                }
+            }
+            if (response.not_found && response.not_found.length > 0) {
+                outLine(`\nNot found: ${response.not_found.join(", ")}`);
+            }
+        }
+        else {
+            out(response);
+        }
+    });
+}

package/dist/commands/run.js

@@ -1,15 +1,30 @@
+import { EventType, RunStatus } from "@tiny-fish/sdk";
 import { getApiKey } from "../lib/auth.js";
 import { cancelRun, runAsync, runStream, runSync } from "../lib/client.js";
 import { err, errLine, handleApiError, out, outLine } from "../lib/output.js";
-import { RunStatus, StreamEventType } from "../lib/types.js";
 import { BASE_URL } from "../lib/constants.js";
-const RUN_TIMEOUT_MS = 20 * 60 * 1000; // 20 minutes
+function extractErrorMessage(error) {
+    if (typeof error === "string")
+        return error;
+    if (typeof error === "object" && error !== null) {
+        const maybeError = error;
+        if (typeof maybeError.message === "string") {
+            return maybeError.message;
+        }
+    }
+    return undefined;
+}
 function checkRunResult(result, expectComplete = true) {
-    if (result.error) {
-        err({ error: result.error, run_id: result.run_id, status: result.status });
+    const errorMessage = extractErrorMessage(result.error);
+    if (errorMessage) {
+        err({
+            error: errorMessage,
+            run_id: result.run_id,
+            status: "status" in result ? result.status : undefined,
+        });
         process.exit(1);
     }
-    if (expectComplete && result.status && result.status !== RunStatus.COMPLETED) {
+    if (expectComplete && "status" in result && result.status && result.status !== RunStatus.COMPLETED) {
         err({ error: `Run ${result.status}`, run_id: result.run_id, status: result.status });
         process.exit(1);
     }
@@ -68,8 +83,11 @@ export function registerRun(agentCmd) {
                 handleApiError(e);
             }
             checkRunResult(result, false); // async = PENDING is expected
-            const { run_id: _asyncRunId, ...asyncRest } = result; // eslint-disable-line @typescript-eslint/no-unused-vars
-            const asyncResultWithUrl = { run_id: result.run_id, run_url: `${BASE_URL}/runs/${result.run_id}`, ...asyncRest };
+            const asyncResultWithUrl = {
+                ...result,
+                status: RunStatus.PENDING,
+                run_url: `${BASE_URL}/runs/${result.run_id}`,
+            };
             if (opts.pretty) {
                 outLine(`Run submitted\nID:     ${asyncResultWithUrl.run_id}\nURL:    ${asyncResultWithUrl.run_url}`);
             }
@@ -82,14 +100,16 @@ export function registerRun(agentCmd) {
             errLine("Waiting for result...");
             let result;
             try {
-                result = await runSync(req, apiKey, AbortSignal.timeout(RUN_TIMEOUT_MS));
+                result = await runSync(req, apiKey);
             }
             catch (e) {
                 handleApiError(e);
             }
             checkRunResult(result);
-            const { run_id: _syncRunId, ...syncRest } = result; // eslint-disable-line @typescript-eslint/no-unused-vars
-            const syncResultWithUrl = { run_id: result.run_id, run_url: `${BASE_URL}/runs/${result.run_id}`, ...syncRest };
+            const syncResultWithUrl = {
+                ...result,
+                run_url: `${BASE_URL}/runs/${result.run_id}`,
+            };
             if (opts.pretty) {
                 outLine(`Status: ${syncResultWithUrl.status}\n\n${JSON.stringify(syncResultWithUrl.result ?? {}, null, 2)}`);
             }
@@ -98,11 +118,10 @@ export function registerRun(agentCmd) {
             }
             return;
         }
-        // Default: SSE stream — 20 min timeout + Ctrl+C cancellation
+        // Default: SSE stream — Ctrl+C cancels the active run.
         const controller = new AbortController();
         let siginted = false;
         let capturedRunId = null;
-        const timeout = setTimeout(() => controller.abort(), RUN_TIMEOUT_MS);
         const onSigint = () => {
             siginted = true;
             controller.abort();
@@ -115,6 +134,9 @@ export function registerRun(agentCmd) {
                     streamFailed = true;
                     break;
                 }
+                if (event.type === EventType.COMPLETE) {
+                    break;
+                }
             }
         }
         catch (e) {
@@ -130,14 +152,9 @@ export function registerRun(agentCmd) {
                 process.stderr.write(cancelled ? "\nRun cancelled.\n" : "\n");
                 process.exit(130);
             }
-            if (controller.signal.aborted) {
-                err({ error: "Run timed out after 20 minutes" });
-                process.exit(1);
-            }
             handleApiError(e);
         }
         finally {
-            clearTimeout(timeout);
             process.removeListener("SIGINT", onSigint);
         }
         if (streamFailed)
@@ -150,42 +167,37 @@ export function registerRun(agentCmd) {
  * Returns false on terminal error (caller should exit 1); true otherwise.
  */
 function handleStreamEvent(event, pretty, onRunId) {
-    if (event.type === StreamEventType.ERROR) {
-        err({ error: event.error, run_id: event.run_id, status: StreamEventType.ERROR });
-        return false;
-    }
-    if (event.type === StreamEventType.COMPLETE && event.status !== RunStatus.COMPLETED) {
-        err({ error: event.error ?? `Run ${event.status}`, run_id: event.run_id, status: event.status });
+    if (event.type === EventType.COMPLETE && event.status !== RunStatus.COMPLETED) {
+        err({ error: event.error?.message ?? `Run ${event.status}`, run_id: event.run_id, status: event.status });
         return false;
     }
     if (pretty) {
         switch (event.type) {
-            case StreamEventType.STARTED:
+            case EventType.STARTED:
                 if (onRunId && event.run_id)
                     onRunId(event.run_id);
                 outLine(`▶ Run started`);
                 break;
-            case StreamEventType.STREAMING_URL:
+            case EventType.STREAMING_URL:
                 outLine(`🔗 Live view: ${event.streaming_url}`);
                 break;
-            case StreamEventType.PROGRESS:
+            case EventType.PROGRESS:
                 outLine(`• ${event.purpose}`);
                 break;
-            case StreamEventType.COMPLETE: {
+            case EventType.COMPLETE: {
                 const runUrl = `${BASE_URL}/runs/${event.run_id}`;
                 outLine(`✓ Completed\n\n${JSON.stringify(event.result ?? {}, null, 2)}\n\nView run: ${runUrl}`);
                 break;
             }
-            case StreamEventType.HEARTBEAT:
+            case EventType.HEARTBEAT:
                 // silently skip — keep-alive noise
                 break;
         }
     }
     else {
         // Raw JSON: emit all events (STREAMING_URL and HEARTBEAT are useful for agents)
-        if (event.type === StreamEventType.COMPLETE) {
-            const { run_id: _eventRunId, ...eventRest } = event; // eslint-disable-line @typescript-eslint/no-unused-vars
-            out({ run_id: event.run_id, run_url: `${BASE_URL}/runs/${event.run_id}`, ...eventRest });
+        if (event.type === EventType.COMPLETE) {
+            out({ ...event, run_url: `${BASE_URL}/runs/${event.run_id}` });
         }
         else {
             out(event);

package/dist/commands/runs.js

@@ -1,7 +1,7 @@
+import { RunStatus } from "@tiny-fish/sdk";
 import { getApiKey } from "../lib/auth.js";
 import { cancelRun, getRun, listRuns } from "../lib/client.js";
 import { err, handleApiError, out, outLine } from "../lib/output.js";
-import { RunStatus } from "../lib/types.js";
 const VALID_STATUSES = Object.values(RunStatus);
 export function registerRuns(runCmd) {
     // ── run list ───────────────────────────────────────────────────────────────

package/dist/index.js

@@ -2,6 +2,7 @@
 import { createRequire } from "module";
 import { Command } from "commander";
 import { registerAuth } from "./commands/auth.js";
+import { registerBatch } from "./commands/batch.js";
 import { registerRun } from "./commands/run.js";
 import { registerRuns } from "./commands/runs.js";
 const { version } = createRequire(import.meta.url)("../package.json");
@@ -26,6 +27,7 @@ const agentCmd = program
     .enablePositionalOptions();
 const runCmd = registerRun(agentCmd);
 registerRuns(runCmd);
+registerBatch(agentCmd);
 // Await parseAsync so async command handlers complete before the process exits
 program.parseAsync(process.argv).catch((e) => {
     process.stderr.write(JSON.stringify({ error: e instanceof Error ? e.message : String(e) }) + "\n");

package/dist/lib/auth.d.ts

@@ -1,4 +1,5 @@
 export { DASHBOARD_URL } from "./constants.js";
+export declare function configDir(): string;
 interface TinyfishConfig {
     api_key?: string;
 }

package/dist/lib/auth.js

@@ -5,7 +5,7 @@ import { err } from "./output.js";
 const KEY_PREFIXES = ["sk-tinyfish-", "sk-mino-"];
 const MIN_KEY_LENGTH = 20;
 export { DASHBOARD_URL } from "./constants.js";
-function configDir() {
+export function configDir() {
     // os.homedir() is cross-platform; process.env.HOME is undefined on Windows
     return path.join(os.homedir(), ".tinyfish");
 }

package/dist/lib/batch-store.d.ts

@@ -0,0 +1,5 @@
+import type { LocalBatch } from "./types.js";
+export declare function loadBatches(): LocalBatch[];
+/** Appends `batch` to the persistent store. Reads existing entries first. */
+export declare function saveBatch(batch: LocalBatch): void;
+export declare function findBatch(batchId: string): LocalBatch | undefined;

package/dist/lib/batch-store.js

@@ -0,0 +1,32 @@
+import * as fs from "fs";
+import { configDir } from "./auth.js";
+function batchesFile() {
+    return `${configDir()}/batches.json`;
+}
+export function loadBatches() {
+    const file = batchesFile();
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (Array.isArray(raw))
+            return raw;
+        return [];
+    }
+    catch (e) {
+        // File does not exist — treat as empty store (expected on first use)
+        if (typeof e === "object" && e !== null && e.code === "ENOENT")
+            return [];
+        // Any other error (corrupt JSON, permission denied) — rethrow rather than
+        // silently returning [] and risking saveBatch() overwriting the store.
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to read batch store at ${file}: ${message}`, { cause: e });
+    }
+}
+/** Appends `batch` to the persistent store. Reads existing entries first. */
+export function saveBatch(batch) {
+    fs.mkdirSync(configDir(), { recursive: true, mode: 0o700 });
+    const existing = loadBatches();
+    fs.writeFileSync(batchesFile(), JSON.stringify([...existing, batch], null, 2), { mode: 0o600 });
+}
+export function findBatch(batchId) {
+    return loadBatches().find((b) => b.batch_id === batchId);
+}

package/dist/lib/client.d.ts

@@ -1,7 +1,11 @@
-import type { CancelRunResponse, ListRunsOptions, ListRunsResponse, RunApiResponse, RunRequest, RunResult, StreamEvent } from "./types.js";
-export declare function runSync(req: RunRequest, apiKey: string, signal?: AbortSignal): Promise<RunResult>;
-export declare function runAsync(req: RunRequest, apiKey: string): Promise<RunResult>;
-export declare function runStream(req: RunRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<StreamEvent>;
-export declare function listRuns(opts: ListRunsOptions, apiKey: string): Promise<ListRunsResponse>;
-export declare function getRun(runId: string, apiKey: string): Promise<RunApiResponse>;
+import { type AgentRunAsyncResponse, type AgentRunParams, type AgentRunResponse, type AgentRunWithStreamingResponse, type Run, type RunListParams, type RunListResponse } from "@tiny-fish/sdk";
+import type { BatchCancelResponse, BatchGetResponse, BatchRunRequest, BatchRunResponse, CancelRunResponse } from "./types.js";
+export declare function runSync(req: AgentRunParams, apiKey: string): Promise<AgentRunResponse>;
+export declare function runAsync(req: AgentRunParams, apiKey: string): Promise<AgentRunAsyncResponse>;
+export declare function runStream(req: AgentRunParams, apiKey: string, signal?: AbortSignal): AsyncGenerator<AgentRunWithStreamingResponse>;
+export declare function listRuns(opts: RunListParams, apiKey: string): Promise<RunListResponse>;
+export declare function getRun(runId: string, apiKey: string): Promise<Run>;
 export declare function cancelRun(runId: string, apiKey: string): Promise<CancelRunResponse>;
+export declare function submitBatch(req: BatchRunRequest, apiKey: string): Promise<BatchRunResponse>;
+export declare function getBatchRuns(runIds: string[], apiKey: string): Promise<BatchGetResponse>;
+export declare function cancelBatchRuns(runIds: string[], apiKey: string): Promise<BatchCancelResponse>;

package/dist/lib/client.js

@@ -1,125 +1,159 @@
+import { APIStatusError, TinyFish, runSchema, } from "@tiny-fish/sdk";
 import { BASE_URL } from "./constants.js";
 import { ApiError } from "./output.js";
-const API_TIMEOUT_MS = 30_000;
-// ── Debug logging ─────────────────────────────────────────────────────────────
-function isDebugEnabled() {
-    return /^(1|true)$/i.test(process.env["TINYFISH_DEBUG"] ?? "");
-}
-function debugLog(msg) {
-    if (isDebugEnabled()) {
-        process.stderr.write(`[debug] ${msg}\n`);
+import { z } from "zod";
+class TinyFishCliClient extends TinyFish {
+    _buildHeaders() {
+        return {
+            ...super._buildHeaders(),
+            "X-TF-Request-Origin": "tinyfish-cli",
+        };
     }
 }
-// ── Shared HTTP helpers ───────────────────────────────────────────────────────
-function headers(apiKey) {
-    return {
-        "X-API-Key": apiKey,
-        "Content-Type": "application/json",
-        "X-TF-Request-Origin": "tinyfish-cli",
-    };
+function createSdkClient(apiKey, timeout) {
+    return new TinyFishCliClient({
+        apiKey,
+        baseURL: BASE_URL,
+        maxRetries: 0,
+        ...(timeout !== undefined ? { timeout } : {}),
+    });
 }
-async function throwIfError(res) {
-    if (!res.ok) {
-        const json = await res.json().catch(() => ({}));
-        const message = json.error?.message ??
-            json.detail ??
-            `HTTP ${res.status}`;
-        throw new ApiError(res.status, message);
+function rethrowSdkError(error) {
+    if (error instanceof APIStatusError) {
+        throw new ApiError(error.statusCode, error.message);
     }
+    if (error instanceof Error) {
+        throw error;
+    }
+    throw new Error(String(error));
 }
-/** POST JSON to a path and return the raw Response, throwing ApiError on non-2xx. */
-async function postJson(path, body, apiKey, signal) {
-    const start = Date.now();
-    debugLog(`--> POST ${path}`);
-    const res = await fetch(`${BASE_URL}${path}`, {
-        method: "POST",
-        headers: headers(apiKey),
-        body: JSON.stringify(body),
-        signal,
-    });
-    debugLog(`<-- ${res.status} (${Date.now() - start}ms)`);
-    await throwIfError(res);
-    return res;
-}
-/** GET a path and return the parsed JSON body, throwing ApiError on non-2xx. */
-async function getJson(path, apiKey, signal) {
-    const start = Date.now();
-    debugLog(`--> GET ${path}`);
-    const res = await fetch(`${BASE_URL}${path}`, {
-        method: "GET",
-        headers: headers(apiKey),
-        signal,
-    });
-    debugLog(`<-- ${res.status} (${Date.now() - start}ms)`);
-    await throwIfError(res);
-    return res.json();
+const cancelRunResponseSchema = z.object({
+    run_id: z.string(),
+    status: z.string(),
+    cancelled_at: z.string().nullable(),
+    message: z.string().nullable(),
+});
+const batchRunResponseSchema = z.object({
+    run_ids: z.array(z.string()).nullable(),
+    error: z.object({
+        code: z.string(),
+        message: z.string(),
+    }).nullable(),
+});
+const batchGetResponseSchema = z.object({
+    data: z.array(runSchema),
+    not_found: z.array(z.string()).nullable(),
+});
+const batchCancelResultSchema = z.object({
+    run_id: z.string(),
+    status: z.string(),
+    cancelled_at: z.string().nullable(),
+    message: z.string().nullable(),
+});
+const batchCancelResponseSchema = z.object({
+    results: z.array(batchCancelResultSchema),
+    not_found: z.array(z.string()).nullable(),
+});
+function parseWithSchema(schema, value, message) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        throw new Error(message);
+    }
+    return result.data;
 }
-/** Yield parsed StreamEvents from a single SSE data line. */
-function* parseSseLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("data:"))
-        return;
-    const data = trimmed.slice(5).trim();
-    if (!data || data === "[DONE]")
-        return;
+export async function runSync(req, apiKey) {
     try {
-        yield JSON.parse(data);
+        return await createSdkClient(apiKey).agent.run(req);
     }
-    catch {
-        // malformed SSE line — skip
+    catch (error) {
+        rethrowSdkError(error);
     }
 }
-// ── Automation run ────────────────────────────────────────────────────────────
-export async function runSync(req, apiKey, signal) {
-    const res = await postJson("/v1/automation/run", req, apiKey, signal);
-    return res.json();
-}
 export async function runAsync(req, apiKey) {
-    // Async just submits the job — 30 s is plenty to get an ACK
-    const res = await postJson("/v1/automation/run-async", req, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
-    return res.json();
+    try {
+        return await createSdkClient(apiKey).agent.queue(req);
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
 }
 export async function* runStream(req, apiKey, signal) {
-    const res = await postJson("/v1/automation/run-sse", req, apiKey, signal);
-    if (!res.body) {
-        throw new ApiError(200, "Empty response body");
-    }
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            // Flush remaining buffer — handles final event without trailing newline
-            for (const line of buffer.split("\n")) {
-                yield* parseSseLine(line);
-            }
-            break;
+    let stream = null;
+    try {
+        stream = await createSdkClient(apiKey).agent.stream(req, { signal });
+        for await (const event of stream) {
+            yield event;
         }
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-            yield* parseSseLine(line);
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
+    finally {
+        if (stream) {
+            try {
+                await stream.close();
+            }
+            catch {
+                // Ignore close errors — the original stream result/error already decided control flow.
+            }
         }
     }
 }
-// ── Run history ───────────────────────────────────────────────────────────────
 export async function listRuns(opts, apiKey) {
-    const params = new URLSearchParams();
-    if (opts.status)
-        params.set("status", opts.status);
-    if (opts.limit != null)
-        params.set("limit", String(opts.limit));
-    if (opts.cursor)
-        params.set("cursor", opts.cursor);
-    const qs = params.size ? `?${params}` : "";
-    return getJson(`/v1/runs${qs}`, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
+    try {
+        return await createSdkClient(apiKey).runs.list(opts);
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
 }
 export async function getRun(runId, apiKey) {
-    return getJson(`/v1/runs/${encodeURIComponent(runId)}`, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
+    try {
+        return await createSdkClient(apiKey).runs.get(runId);
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
 }
 export async function cancelRun(runId, apiKey) {
-    const res = await postJson(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {}, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
-    return res.json();
+    try {
+        const response = await createSdkClient(apiKey).post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, { json: {} });
+        return parseWithSchema(cancelRunResponseSchema, response, "Invalid cancel run response");
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
+}
+export async function submitBatch(req, apiKey) {
+    try {
+        const response = await createSdkClient(apiKey).post("/v1/automation/run-batch", {
+            json: req,
+        });
+        return parseWithSchema(batchRunResponseSchema, response, "Invalid batch run response");
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
+}
+export async function getBatchRuns(runIds, apiKey) {
+    try {
+        const response = await createSdkClient(apiKey).post("/v1/runs/batch", {
+            json: { run_ids: runIds },
+        });
+        return parseWithSchema(batchGetResponseSchema, response, "Invalid batch get response");
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
+}
+export async function cancelBatchRuns(runIds, apiKey) {
+    try {
+        const response = await createSdkClient(apiKey).post("/v1/runs/batch/cancel", {
+            json: { run_ids: runIds },
+        });
+        return parseWithSchema(batchCancelResponseSchema, response, "Invalid batch cancel response");
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
 }

package/dist/lib/types.d.ts

@@ -1,102 +1,42 @@
-export interface RunRequest {
-    goal: string;
-    url: string;
-}
-export declare const RunStatus: {
-    readonly PENDING: "PENDING";
-    readonly RUNNING: "RUNNING";
-    readonly COMPLETED: "COMPLETED";
-    readonly FAILED: "FAILED";
-    readonly CANCELLED: "CANCELLED";
-};
-export type RunStatus = (typeof RunStatus)[keyof typeof RunStatus];
-export declare const StreamEventType: {
-    readonly STARTED: "STARTED";
-    readonly STREAMING_URL: "STREAMING_URL";
-    readonly HEARTBEAT: "HEARTBEAT";
-    readonly PROGRESS: "PROGRESS";
-    readonly COMPLETE: "COMPLETE";
-    readonly ERROR: "ERROR";
-};
-export type StreamEventType = (typeof StreamEventType)[keyof typeof StreamEventType];
-export interface RunResult {
-    run_id: string;
-    status: RunStatus;
-    result?: unknown;
-    error?: string;
-}
-/** Discriminated union of all real SSE event shapes from the API */
-export type StreamEvent = {
-    type: typeof StreamEventType.STARTED;
-    run_id: string;
-    timestamp: string;
-} | {
-    type: typeof StreamEventType.STREAMING_URL;
-    run_id: string;
-    streaming_url: string;
-    timestamp: string;
-} | {
-    type: typeof StreamEventType.HEARTBEAT;
-    timestamp: string;
-} | {
-    type: typeof StreamEventType.PROGRESS;
-    run_id: string;
-    purpose: string;
-    timestamp: string;
-} | {
-    type: typeof StreamEventType.COMPLETE;
+import type { Run, RunStatus } from "@tiny-fish/sdk";
+export interface CancelRunResponse {
     run_id: string;
-    status: RunStatus;
-    timestamp: string;
-    result?: unknown;
-    error?: string;
-    help_url?: string;
-    help_message?: string;
-} | {
-    type: typeof StreamEventType.ERROR;
-    run_id?: string;
-    error: string;
-    timestamp: string;
-};
-export interface RunError {
-    message: string;
-    category: string;
-    retry_after: string | null;
-    help_url: string | null;
-    help_message: string | null;
+    status: RunStatus | string;
+    cancelled_at: string | null;
+    message: string | null;
 }
-export interface RunApiResponse {
-    run_id: string;
-    status: RunStatus;
+export interface BatchRunEntry {
+    url: string;
     goal: string;
-    created_at: string;
-    started_at: string | null;
-    finished_at: string | null;
-    num_of_steps: number;
-    result: unknown;
-    error: RunError | null;
-    streaming_url: string | null;
-    browser_config: {
-        proxy_enabled: boolean | null;
-        proxy_country_code: string | null;
-    } | null;
 }
-export interface ListRunsResponse {
-    data: RunApiResponse[];
-    pagination: {
-        total: number;
-        next_cursor: string | null;
-        has_more: boolean;
-    };
+export interface BatchRunRequest {
+    runs: BatchRunEntry[];
 }
-export interface ListRunsOptions {
-    status?: RunStatus;
-    limit?: number;
-    cursor?: string;
+export interface BatchRunResponse {
+    run_ids: string[] | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
 }
-export interface CancelRunResponse {
+export interface BatchGetResponse {
+    data: Run[];
+    not_found: string[] | null;
+}
+export interface BatchCancelResult {
     run_id: string;
-    status: RunStatus | string;
-    cancelled_at: string;
+    status: string;
+    cancelled_at: string | null;
     message: string | null;
 }
+export interface BatchCancelResponse {
+    results: BatchCancelResult[];
+    not_found: string[] | null;
+}
+export interface LocalBatch {
+    batch_id: string;
+    run_ids: string[];
+    total: number;
+    submitted: number;
+    created_at: string;
+}

package/dist/lib/types.js

@@ -1,18 +1 @@
-// ── Automation run request ────────────────────────────────────────────────────
-// ── Run status enum ───────────────────────────────────────────────────────────
-export const RunStatus = {
-    PENDING: "PENDING",
-    RUNNING: "RUNNING",
-    COMPLETED: "COMPLETED",
-    FAILED: "FAILED",
-    CANCELLED: "CANCELLED",
-};
-// ── SSE event types ───────────────────────────────────────────────────────────
-export const StreamEventType = {
-    STARTED: "STARTED",
-    STREAMING_URL: "STREAMING_URL",
-    HEARTBEAT: "HEARTBEAT",
-    PROGRESS: "PROGRESS",
-    COMPLETE: "COMPLETE",
-    ERROR: "ERROR",
-};
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.1.3",
-  "description": "TinyFish CLI \u2014 run web automations from your terminal",
+  "version": "0.1.4-next.35",
+  "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {
     "tinyfish": "./dist/index.js"
@@ -23,18 +23,24 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@tiny-fish/sdk": "^0.0.7",
     "commander": "^12.0.0",
-    "globals": "^17.4.0"
+    "globals": "^17.4.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@types/node": "^20.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.0.0",
-    "@typescript-eslint/parser": "^8.0.0",
-    "eslint": "^9.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.2",
+    "@typescript-eslint/parser": "^8.57.2",
+    "eslint": "^10.1.0",
     "prettier": "^3.0.0",
     "typescript": "^5.0.0",
     "vitest": "^3.0.0"
   },
+  "overrides": {
+    "brace-expansion": "5.0.5"
+  },
   "engines": {
     "node": ">=24.0.0"
   },