@tiny-fish/cli 0.1.0 → 0.1.2-next.15

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.d.ts

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

package/dist/commands/run.js

@@ -1,46 +1,64 @@
 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
 function checkRunResult(result, expectComplete = true) {
     if (result.error) {
-        err({ error: result.error, runId: result.runId, status: result.status });
+        err({ error: result.error, run_id: result.run_id, status: result.status });
         process.exit(1);
     }
     if (expectComplete && result.status && result.status !== RunStatus.COMPLETED) {
-        err({ error: `Run ${result.status}`, runId: result.runId, status: result.status });
+        err({ error: `Run ${result.status}`, run_id: result.run_id, status: result.status });
         process.exit(1);
     }
 }
-export function registerRun(program) {
-    program
-        .command("run <goal>")
-        .description("Run a browser automation")
-        .requiredOption("--url <url>", "Target URL for the automation")
+export function registerRun(agentCmd) {
+    const runCmd = agentCmd
+        .command("run")
+        .description("Run a browser automation or manage runs")
+        .option("--url <url>", "Target URL for the automation")
         .option("--sync", "Wait for result without streaming steps")
         .option("--async", "Submit without waiting for result")
         .option("--pretty", "Human-readable output")
+        .argument("[goal]", "Goal to automate")
         .action(async (goal, opts) => {
+        // If no goal is provided and no subcommand matched, show help
+        if (!goal) {
+            runCmd.help();
+            return;
+        }
+        if (!opts.url) {
+            err({ error: "required option '--url <url>' not specified" });
+            process.exit(1);
+        }
         if (opts.sync && opts.async) {
             err({ error: "--sync and --async are mutually exclusive" });
             process.exit(1);
         }
-        // Reject obviously invalid input — accepts bare hostnames like "google.com"
+        // Normalise URL: accept bare hostnames by prepending https://.
+        // The server requires a valid URL — it does not auto-prefix.
+        let normalizedUrl = opts.url;
         try {
             new URL(opts.url);
         }
         catch {
             try {
                 new URL(`https://${opts.url}`);
+                normalizedUrl = `https://${opts.url}`;
             }
             catch {
-                err({ error: "--url does not look like a valid URL" });
+                err({ error: `Invalid --url "${opts.url}". Provide a valid URL, e.g. https://example.com or example.com` });
                 process.exit(1);
             }
         }
+        if (!goal.trim()) {
+            err({ error: 'Goal cannot be empty' });
+            process.exit(1);
+        }
         const apiKey = getApiKey();
-        const req = { goal, url: opts.url };
+        const req = { goal, url: normalizedUrl };
         if (opts.async) {
             let result;
             try {
@@ -50,16 +68,18 @@ export function registerRun(program) {
                 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 };
             if (opts.pretty) {
-                outLine(`Run submitted\nID:     ${result.runId}\nStatus: ${result.status}`);
+                outLine(`Run submitted\nID:     ${asyncResultWithUrl.run_id}\nURL:    ${asyncResultWithUrl.run_url}`);
             }
             else {
-                out(result);
+                out(asyncResultWithUrl);
             }
             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));
@@ -68,17 +88,20 @@ export function registerRun(program) {
                 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 };
             if (opts.pretty) {
-                outLine(`Status: ${result.status}\n\n${JSON.stringify(result.resultJson ?? {}, null, 2)}`);
+                outLine(`Status: ${syncResultWithUrl.status}\n\n${JSON.stringify(syncResultWithUrl.result ?? {}, null, 2)}`);
             }
             else {
-                out(result);
+                out(syncResultWithUrl);
             }
             return;
         }
         // 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;
@@ -88,18 +111,26 @@ export function registerRun(program) {
         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);
             }
@@ -112,34 +143,39 @@ export function registerRun(program) {
         if (streamFailed)
             process.exit(1);
     });
+    return runCmd;
 }
 /**
  * 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, runId: event.runId, status: 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}`, runId: event.runId, status: event.status });
+        err({ error: event.error ?? `Run ${event.status}`, run_id: event.run_id, status: event.status });
         return false;
     }
     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:
-                outLine(`🔗 Live view: ${event.streamingUrl}`);
+                outLine(`🔗 Live view: ${event.streaming_url}`);
                 break;
             case StreamEventType.PROGRESS:
                 outLine(`• ${event.purpose}`);
                 break;
-            case StreamEventType.COMPLETE:
-                outLine(`✓ Completed\n\n${JSON.stringify(event.resultJson ?? {}, null, 2)}`);
+            case StreamEventType.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:
                 // silently skip — keep-alive noise
                 break;
@@ -147,7 +183,13 @@ function handleStreamEvent(event, pretty) {
     }
     else {
         // Raw JSON: emit all events (STREAMING_URL and HEARTBEAT are useful for agents)
-        out(event);
+        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 });
+        }
+        else {
+            out(event);
+        }
     }
     return true;
 }

package/dist/commands/runs.d.ts

@@ -1,2 +1,2 @@
 import { Command } from "commander";
-export declare function registerRuns(program: Command): void;
+export declare function registerRuns(runCmd: Command): void;

package/dist/commands/runs.js

@@ -1,14 +1,11 @@
 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);
-export function registerRuns(program) {
-    const runs = program
-        .command("runs")
-        .description("Manage past automation runs");
-    // ── runs list ──────────────────────────────────────────────────────────────
-    runs
+export function registerRuns(runCmd) {
+    // ── run list ───────────────────────────────────────────────────────────────
+    runCmd
         .command("list")
         .description("List your automation runs")
         .option("--status <status>", "Filter by status (PENDING|RUNNING|COMPLETED|FAILED|CANCELLED)")
@@ -65,8 +62,8 @@ export function registerRuns(program) {
             handleApiError(e);
         }
     });
-    // ── runs get ───────────────────────────────────────────────────────────────
-    runs
+    // ── run get ────────────────────────────────────────────────────────────────
+    runCmd
         .command("get <run_id>")
         .description("Get a run by ID")
         .option("--pretty", "Human-readable output")
@@ -98,4 +95,31 @@ export function registerRuns(program) {
             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/index.js

@@ -12,6 +12,7 @@ program
     .version(version, "-V, --version", "Show version")
     .helpOption("-h, --help", "Show help")
     .addHelpCommand(false)
+    .enablePositionalOptions()
     .option("--debug", "Print HTTP requests and responses to stderr (or set TINYFISH_DEBUG=1)")
     .hook("preAction", (cmd) => {
     if (cmd.opts().debug) {
@@ -19,8 +20,12 @@ program
     }
 });
 registerAuth(program);
-registerRun(program);
-registerRuns(program);
+const agentCmd = program
+    .command("agent")
+    .description("Agent automation commands")
+    .enablePositionalOptions();
+const runCmd = registerRun(agentCmd);
+registerRuns(runCmd);
 // 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/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) {
@@ -18,7 +19,9 @@ function headers(apiKey) {
 async function throwIfError(res) {
     if (!res.ok) {
         const json = await res.json().catch(() => ({}));
-        const message = json.detail ?? `HTTP ${res.status}`;
+        const message = json.error?.message ??
+            json.detail ??
+            `HTTP ${res.status}`;
         throw new ApiError(res.status, message);
     }
 }
@@ -71,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) {
@@ -109,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

@@ -20,41 +20,41 @@ export declare const StreamEventType: {
 };
 export type StreamEventType = (typeof StreamEventType)[keyof typeof StreamEventType];
 export interface RunResult {
-    runId: string;
+    run_id: string;
     status: RunStatus;
-    resultJson?: unknown;
+    result?: unknown;
     error?: string;
 }
 /** Discriminated union of all real SSE event shapes from the API */
 export type StreamEvent = {
     type: typeof StreamEventType.STARTED;
-    runId: string;
+    run_id: string;
     timestamp: string;
 } | {
     type: typeof StreamEventType.STREAMING_URL;
-    runId: string;
-    streamingUrl: string;
+    run_id: string;
+    streaming_url: string;
     timestamp: string;
 } | {
     type: typeof StreamEventType.HEARTBEAT;
     timestamp: string;
 } | {
     type: typeof StreamEventType.PROGRESS;
-    runId: string;
+    run_id: string;
     purpose: string;
     timestamp: string;
 } | {
     type: typeof StreamEventType.COMPLETE;
-    runId: string;
+    run_id: string;
     status: RunStatus;
     timestamp: string;
-    resultJson?: unknown;
+    result?: unknown;
     error?: string;
     help_url?: string;
     help_message?: string;
 } | {
     type: typeof StreamEventType.ERROR;
-    runId?: string;
+    run_id?: string;
     error: string;
     timestamp: string;
 };
@@ -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,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.1.0",
+  "version": "0.1.2-next.15",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {
@@ -13,14 +13,14 @@
   ],
   "scripts": {
     "build": "tsc",
-    "prepack": "npm run build",
     "test": "vitest --run",
     "test:file": "vitest --run",
     "test:watch": "vitest",
     "test:integration": "vitest --run --config vitest.integration.config.ts",
     "lint": "eslint src tests",
     "format": "prettier --write src tests",
-    "type-check": "tsc --noEmit --project tsconfig.all.json"
+    "type-check": "tsc --noEmit --project tsconfig.all.json",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "commander": "^12.0.0",
@@ -37,5 +37,8 @@
   },
   "engines": {
     "node": ">=24.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
   }
 }