@tiny-fish/cli 0.1.1 → 0.1.2-next.16

package/README.md

@@ -0,0 +1,87 @@
+# TinyFish CLI
+
+Run web automations from your terminal, shell scripts, and CI/CD pipelines.
+
+## Installation
+
+```bash
+npm install -g @tiny-fish/cli
+```
+
+Requires Node.js 24+.
+
+## Authentication
+
+Get your API key from [agent.tinyfish.ai](https://agent.tinyfish.ai).
+
+```bash
+# Interactive (opens browser, prompts for key)
+tinyfish auth login
+
+# CI/CD safe (pipe key via stdin)
+echo $TINYFISH_API_KEY | tinyfish auth set
+
+# Or set via environment variable
+export TINYFISH_API_KEY=sk-tinyfish-...
+```
+
+## Usage
+
+### Run an automation
+
+```bash
+# Stream steps as they happen (default)
+tinyfish agent run "Find the pricing page" --url https://example.com
+
+# Human-readable output
+tinyfish agent run "Find the pricing page" --url https://example.com --pretty
+
+# Wait for result without streaming
+tinyfish agent run "Find the pricing page" --url https://example.com --sync
+
+# Submit and return immediately (don't wait)
+tinyfish agent run "Find the pricing page" --url https://example.com --async
+```
+
+### Manage runs
+
+```bash
+# List recent runs
+tinyfish agent run list --pretty
+
+# Filter by status
+tinyfish agent run list --status RUNNING --pretty
+
+# Inspect a run
+tinyfish agent run get <run_id> --pretty
+
+# Cancel a run
+tinyfish agent run cancel <run_id> --pretty
+```
+
+### Output format
+
+By default all commands output newline-delimited JSON to stdout — pipe-friendly for agents and scripts. Add `--pretty` for human-readable output.
+
+Errors are JSON to stderr with exit code 1. Ctrl+C during a streaming run cancels it automatically.
+
+### Debug
+
+```bash
+TINYFISH_DEBUG=1 tinyfish agent run "..." --url https://example.com
+# or
+tinyfish --debug agent run "..." --url https://example.com
+```
+
+## CI/CD
+
+```yaml
+- name: Run automation
+  env:
+    TINYFISH_API_KEY: ${{ secrets.TINYFISH_API_KEY }}
+  run: |
+    tinyfish agent run "Check that the login flow works" \
+      --url https://staging.example.com \
+      --sync \
+      --pretty
+```

package/dist/commands/auth.js

@@ -1,7 +1,7 @@
 import { spawn } from "child_process";
 import * as readline from "readline";
 import { DASHBOARD_URL, clearConfig, loadConfig, maskKey, saveConfig, validateKeyFormat, } from "../lib/auth.js";
-import { err, out, outLine } from "../lib/output.js";
+import { err, errLine, out, outLine } from "../lib/output.js";
 /**
  * Read a key from stdin without echoing it to the terminal.
  * Uses setRawMode on TTY so characters are never written to the screen.
@@ -71,7 +71,7 @@ export function registerAuth(program) {
         .command("login")
         .description("Open the API keys page and save your key interactively")
         .action(async () => {
-        process.stderr.write(`Opening ${DASHBOARD_URL} in your browser...\n`);
+        errLine(`Opening ${DASHBOARD_URL} in your browser...`);
         try {
             // Use spawn with an explicit args array — no shell, no interpolation
             let cmd;
@@ -166,6 +166,7 @@ export function registerAuth(program) {
         else {
             out(result);
         }
+        process.exit(1);
     });
     auth
         .command("logout")

package/dist/commands/run.js

@@ -1,6 +1,6 @@
 import { getApiKey } from "../lib/auth.js";
-import { runAsync, runStream, runSync } from "../lib/client.js";
-import { err, handleApiError, out, outLine } from "../lib/output.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
@@ -53,6 +53,10 @@ export function registerRun(agentCmd) {
                 process.exit(1);
             }
         }
+        if (!goal.trim()) {
+            err({ error: 'Goal cannot be empty' });
+            process.exit(1);
+        }
         const apiKey = getApiKey();
         const req = { goal, url: normalizedUrl };
         if (opts.async) {
@@ -67,7 +71,7 @@ export function registerRun(agentCmd) {
             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 };
             if (opts.pretty) {
-                outLine(`Run submitted\nID:     ${asyncResultWithUrl.run_id}\nStatus: ${asyncResultWithUrl.status}\nURL:    ${asyncResultWithUrl.run_url}`);
+                outLine(`Run submitted\nID:     ${asyncResultWithUrl.run_id}\nURL:    ${asyncResultWithUrl.run_url}`);
             }
             else {
                 out(asyncResultWithUrl);
@@ -75,7 +79,7 @@ export function registerRun(agentCmd) {
             return;
         }
         if (opts.sync) {
-            process.stderr.write("Waiting for result...\n");
+            errLine("Waiting for result...");
             let result;
             try {
                 result = await runSync(req, apiKey, AbortSignal.timeout(RUN_TIMEOUT_MS));
@@ -97,6 +101,7 @@ export function registerRun(agentCmd) {
         // Default: SSE stream — 20 min timeout + Ctrl+C cancellation
         const controller = new AbortController();
         let siginted = false;
+        let capturedRunId = null;
         const timeout = setTimeout(() => controller.abort(), RUN_TIMEOUT_MS);
         const onSigint = () => {
             siginted = true;
@@ -106,18 +111,26 @@ export function registerRun(agentCmd) {
         let streamFailed = false;
         try {
             for await (const event of runStream(req, apiKey, controller.signal)) {
-                if (!handleStreamEvent(event, opts.pretty)) {
+                if (!handleStreamEvent(event, opts.pretty, (id) => { capturedRunId = id; })) {
                     streamFailed = true;
                     break;
                 }
             }
         }
         catch (e) {
-            if (controller.signal.aborted) {
-                if (siginted) {
-                    process.stderr.write("\n");
-                    process.exit(130);
+            if (controller.signal.aborted && siginted) {
+                let cancelled = false;
+                if (capturedRunId) {
+                    try {
+                        await cancelRun(capturedRunId, apiKey);
+                        cancelled = true;
+                    }
+                    catch { /* ignore */ }
                 }
+                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);
             }
@@ -136,7 +149,7 @@ export function registerRun(agentCmd) {
  * Handle one SSE event from the stream.
  * Returns false on terminal error (caller should exit 1); true otherwise.
  */
-function handleStreamEvent(event, pretty) {
+function handleStreamEvent(event, pretty, onRunId) {
     if (event.type === StreamEventType.ERROR) {
         err({ error: event.error, run_id: event.run_id, status: StreamEventType.ERROR });
         return false;
@@ -148,6 +161,8 @@ function handleStreamEvent(event, pretty) {
     if (pretty) {
         switch (event.type) {
             case StreamEventType.STARTED:
+                if (onRunId && event.run_id)
+                    onRunId(event.run_id);
                 outLine(`▶ Run started`);
                 break;
             case StreamEventType.STREAMING_URL:

package/dist/commands/runs.js

@@ -1,5 +1,5 @@
 import { getApiKey } from "../lib/auth.js";
-import { getRun, listRuns } from "../lib/client.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);
@@ -95,4 +95,31 @@ export function registerRuns(runCmd) {
             handleApiError(e);
         }
     });
+    // ── run cancel ────────────────────────────────────────────────────────────
+    runCmd
+        .command("cancel <run_id>")
+        .description("Cancel a run by ID")
+        .option("--pretty", "Human-readable output")
+        .action(async (runId, opts) => {
+        const apiKey = getApiKey();
+        try {
+            const result = await cancelRun(runId, apiKey);
+            if (opts.pretty) {
+                if (result.status === RunStatus.CANCELLED) {
+                    outLine(result.message
+                        ? `Run ${result.run_id} cancelled (${result.message}).`
+                        : `Run ${result.run_id} cancelled.`);
+                }
+                else {
+                    outLine(`Run ${result.run_id} already finished (${result.status}).`);
+                }
+            }
+            else {
+                out(result);
+            }
+        }
+        catch (e) {
+            handleApiError(e);
+        }
+    });
 }

package/dist/lib/client.d.ts

@@ -1,6 +1,7 @@
-import type { ListRunsOptions, ListRunsResponse, RunApiResponse, RunRequest, RunResult, StreamEvent } from "./types.js";
+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>;
+export declare function cancelRun(runId: string, apiKey: string): Promise<CancelRunResponse>;

package/dist/lib/client.js

@@ -1,5 +1,6 @@
 import { BASE_URL } from "./constants.js";
 import { ApiError } from "./output.js";
+const API_TIMEOUT_MS = 30_000;
 // ── Debug logging ─────────────────────────────────────────────────────────────
 const DEBUG_ENABLED = /^(1|true)$/i.test(process.env["TINYFISH_DEBUG"] ?? "");
 function debugLog(msg) {
@@ -73,7 +74,7 @@ export async function runSync(req, apiKey, signal) {
 }
 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(30_000));
+    const res = await postJson("/v1/automation/run-async", req, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
     return res.json();
 }
 export async function* runStream(req, apiKey, signal) {
@@ -111,8 +112,12 @@ export async function listRuns(opts, apiKey) {
     if (opts.cursor)
         params.set("cursor", opts.cursor);
     const qs = params.size ? `?${params}` : "";
-    return getJson(`/v1/runs${qs}`, apiKey, AbortSignal.timeout(30_000));
+    return getJson(`/v1/runs${qs}`, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
 }
 export async function getRun(runId, apiKey) {
-    return getJson(`/v1/runs/${encodeURIComponent(runId)}`, apiKey, AbortSignal.timeout(30_000));
+    return getJson(`/v1/runs/${encodeURIComponent(runId)}`, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
+}
+export async function cancelRun(runId, apiKey) {
+    const res = await postJson(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {}, apiKey, AbortSignal.timeout(API_TIMEOUT_MS));
+    return res.json();
 }

package/dist/lib/output.d.ts

@@ -5,5 +5,6 @@ export declare class ApiError extends Error {
 }
 export declare function out(data: unknown): void;
 export declare function outLine(line: string): void;
+export declare function errLine(line: string): void;
 export declare function err(data: unknown): void;
 export declare function handleApiError(e: unknown): never;

package/dist/lib/output.js

@@ -14,6 +14,9 @@ export function out(data) {
 export function outLine(line) {
     process.stdout.write(line + "\n");
 }
+export function errLine(line) {
+    process.stderr.write(line + "\n");
+}
 export function err(data) {
     const payload = typeof data === "string" ? { error: data } : data;
     process.stderr.write(JSON.stringify(payload) + "\n");

package/dist/lib/types.d.ts

@@ -94,3 +94,9 @@ export interface ListRunsOptions {
     limit?: number;
     cursor?: string;
 }
+export interface CancelRunResponse {
+    run_id: string;
+    status: RunStatus | string;
+    cancelled_at: string;
+    message: string | null;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.1.1",
-  "description": "TinyFish CLI \u2014 run web automations from your terminal",
+  "version": "0.1.2-next.16",
+  "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {
     "tinyfish": "./dist/index.js"
@@ -39,7 +39,6 @@
     "node": ">=24.0.0"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
-    "access": "restricted"
+    "registry": "https://registry.npmjs.org/"
   }
 }