@tiny-fish/cli 0.1.3-next.31 → 0.1.3-next.32

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/lib/client.d.ts

@@ -1,9 +1,10 @@
-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>;
+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>;

package/dist/lib/client.js

@@ -1,138 +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",
-    };
-}
-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);
-    }
-}
-/** 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,
+function createSdkClient(apiKey, timeout) {
+    return new TinyFishCliClient({
+        apiKey,
+        baseURL: BASE_URL,
+        maxRetries: 0,
+        ...(timeout !== undefined ? { timeout } : {}),
     });
-    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();
+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));
+}
+const cancelRunResponseSchema = z.object({
+    run_id: z.string(),
+    status: z.string(),
+    cancelled_at: z.string(),
+    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);
+    }
 }
-// ── 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();
+    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) {
-    const res = await postJson("/v1/runs/batch", { run_ids: runIds }, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
-    return res.json();
+    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) {
-    const res = await postJson("/v1/runs/batch/cancel", { run_ids: runIds }, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
-    return res.json();
+    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,99 +1,4 @@
-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;
-    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;
-}
-export interface RunApiResponse {
-    run_id: string;
-    status: RunStatus;
-    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 ListRunsOptions {
-    status?: RunStatus;
-    limit?: number;
-    cursor?: string;
-}
+import type { Run, RunStatus } from "@tiny-fish/sdk";
 export interface CancelRunResponse {
     run_id: string;
     status: RunStatus | string;
@@ -115,7 +20,7 @@ export interface BatchRunResponse {
     } | null;
 }
 export interface BatchGetResponse {
-    data: RunApiResponse[];
+    data: Run[];
     not_found: string[] | null;
 }
 export interface BatchCancelResult {

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,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.1.3-next.31",
+  "version": "0.1.3-next.32",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {
@@ -23,8 +23,10 @@
     "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",