@tiny-fish/cli 0.1.3-next.26 → 0.1.3-next.27

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/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,31 @@
+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.
+        throw new Error(`Failed to read batch store at ${file}: ${e.message}`);
+    }
+}
+/** 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,10 @@
-import type { CancelRunResponse, ListRunsOptions, ListRunsResponse, RunApiResponse, RunRequest, RunResult, StreamEvent } from "./types.js";
+import type { BatchCancelResponse, BatchGetResponse, BatchRunRequest, BatchRunResponse, 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>;
 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

@@ -123,3 +123,16 @@ export async function cancelRun(runId, apiKey) {
     const res = await postJson(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {}, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
     return res.json();
 }
+// ── Batch operations ──────────────────────────────────────────────────────────
+export async function submitBatch(req, apiKey) {
+    const res = await postJson("/v1/automation/run-batch", req, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
+    return res.json();
+}
+export async function getBatchRuns(runIds, apiKey) {
+    const res = await postJson("/v1/runs/batch", { run_ids: runIds }, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
+    return res.json();
+}
+export async function cancelBatchRuns(runIds, apiKey) {
+    const res = await postJson("/v1/runs/batch/cancel", { run_ids: runIds }, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
+    return res.json();
+}

package/dist/lib/types.d.ts

@@ -100,3 +100,38 @@ export interface CancelRunResponse {
     cancelled_at: string;
     message: string | null;
 }
+export interface BatchRunEntry {
+    url: string;
+    goal: string;
+}
+export interface BatchRunRequest {
+    runs: BatchRunEntry[];
+}
+export interface BatchRunResponse {
+    run_ids: string[] | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+}
+export interface BatchGetResponse {
+    data: RunApiResponse[];
+    not_found: string[] | null;
+}
+export interface BatchCancelResult {
+    run_id: 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.1.3-next.26",
+  "version": "0.1.3-next.27",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {