@tiny-fish/cli 0.1.0 → 0.1.1

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

@@ -2,45 +2,59 @@ import { getApiKey } from "../lib/auth.js";
 import { runAsync, runStream, runSync } from "../lib/client.js";
 import { err, 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);
             }
         }
         const apiKey = getApiKey();
-        const req = { goal, url: opts.url };
+        const req = { goal, url: normalizedUrl };
         if (opts.async) {
             let result;
             try {
@@ -50,11 +64,13 @@ 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}\nStatus: ${asyncResultWithUrl.status}\nURL:    ${asyncResultWithUrl.run_url}`);
             }
             else {
-                out(result);
+                out(asyncResultWithUrl);
             }
             return;
         }
@@ -68,11 +84,13 @@ 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;
         }
@@ -112,6 +130,7 @@ export function registerRun(program) {
         if (streamFailed)
             process.exit(1);
     });
+    return runCmd;
 }
 /**
  * Handle one SSE event from the stream.
@@ -119,11 +138,11 @@ export function registerRun(program) {
  */
 function handleStreamEvent(event, pretty) {
     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) {
@@ -132,14 +151,16 @@ function handleStreamEvent(event, pretty) {
                 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 +168,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

@@ -3,12 +3,9 @@ import { 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")

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.js

@@ -18,7 +18,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);
     }
 }

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;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.1.0",
-  "description": "TinyFish CLI — run web automations from your terminal",
+  "version": "0.1.1",
+  "description": "TinyFish CLI \u2014 run web automations from your terminal",
   "type": "module",
   "bin": {
     "tinyfish": "./dist/index.js"
@@ -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,9 @@
   },
   "engines": {
     "node": ">=24.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "restricted"
   }
 }