@tiny-fish/cli 0.1.5-next.47 → 0.1.5-next.50

package/README.md

@@ -36,6 +36,13 @@ 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
 
+# Use a browser profile and stricter agent limits
+tinyfish agent run "Check checkout" \
+  --url https://example.com \
+  --browser-profile stealth \
+  --mode strict \
+  --max-steps 75
+
 # Wait for result without streaming
 tinyfish agent run "Find the pricing page" --url https://example.com --sync
 
@@ -85,10 +92,19 @@ tinyfish agent run list --status RUNNING --pretty
 # Inspect a run
 tinyfish agent run get <run_id> --pretty
 
+# Print the step-by-step trace
+tinyfish agent run steps <run_id> --pretty
+
+# Watch a run live (polls the steps endpoint; exits when the run finishes)
+tinyfish agent run watch <run_id> --pretty
+tinyfish agent run watch <run_id> --pretty --interval 5000 --timeout 600000
+
 # Cancel a run
 tinyfish agent run cancel <run_id> --pretty
 ```
 
+**Important token scope note:** CLI run commands are scoped to the user's personal API key (`TINYFISH_API_KEY` or `tinyfish auth`). MCP tool calls are scoped to the MCP token. These are different run namespaces, so `tinyfish agent run get <mcp_run_id>` returning 404 is expected behavior, not a CLI bug.
+
 ### Search
 
 ```bash
@@ -139,6 +155,8 @@ Errors are JSON to stderr with exit code 1. Ctrl+C during a streaming run cancel
 
 `--output-schema` and `--output-schema-file` are mutually exclusive. Both inputs must parse to a top-level JSON object. The CLI only validates that outer shape locally; the API performs full schema validation and may return errors such as `INVALID_INPUT` or feature-flag access failures.
 
+`--browser-profile` accepts `lite` or `stealth`. `--mode` accepts `default` or `strict`. `--max-steps` accepts values from 1 to 500. `--session-id <uuid>` is a caller-provided UUID that lets concurrent `--sync` calls stay idempotent.
+
 ### Debug
 
 ```bash

package/dist/commands/browser.js

@@ -1,6 +1,16 @@
 import { getApiKey } from "../lib/auth.js";
 import { browserSessionCreate } from "../lib/client.js";
-import { handleApiError, out, outLine } from "../lib/output.js";
+import { err, handleApiError, out, outLine } from "../lib/output.js";
+const VALID_BROWSER_PROFILES = ["lite", "stealth"];
+function parseBrowserProfile(value) {
+    if (value === undefined)
+        return undefined;
+    if (VALID_BROWSER_PROFILES.includes(value)) {
+        return value;
+    }
+    err({ error: `Invalid --browser-profile "${value}". Must be one of: lite, stealth` });
+    process.exit(1);
+}
 function printPrettyBrowserSession(session) {
     outLine("Browser session created");
     outLine(`Session ID: ${session.session_id}`);
@@ -20,12 +30,15 @@ export function registerBrowser(program) {
         .command("create")
         .description("Create a remote browser session")
         .option("--url <value>", "Open a URL after session creation")
+        .option("--browser-profile <profile>", "Browser profile for execution (lite|stealth)")
         .option("--pretty", "Human-readable output")
         .action(async (opts) => {
         const apiKey = getApiKey();
+        const browserProfile = parseBrowserProfile(opts.browserProfile);
         try {
             const response = await browserSessionCreate({
                 ...(opts.url !== undefined ? { url: opts.url } : {}),
+                ...(browserProfile !== undefined ? { browser_profile: browserProfile } : {}),
             }, apiKey);
             if (opts.pretty) {
                 printPrettyBrowserSession(response);

package/dist/commands/run.js

@@ -5,6 +5,19 @@ 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 { BASE_URL } from "../lib/constants.js";
+const VALID_BROWSER_PROFILES = ["lite", "stealth"];
+const VALID_MODES = ["default", "strict"];
+const MAX_STEPS_LIMIT = 500;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function parseSessionId(value) {
+    if (value === undefined)
+        return undefined;
+    if (!UUID_RE.test(value)) {
+        err({ error: `Invalid --session-id "${value}". Must be a UUID.` });
+        process.exit(1);
+    }
+    return value;
+}
 const outputSchemaFieldSchema = z.object({}).catchall(z.unknown());
 function extractErrorMessage(error) {
     if (typeof error === "string")
@@ -48,6 +61,28 @@ function parseOutputSchema(rawOutputSchema, sourceLabel) {
     }
     return result.data;
 }
+function parseChoice(value, valid, flag) {
+    if (value === undefined)
+        return undefined;
+    if (valid.includes(value))
+        return value;
+    err({ error: `Invalid ${flag} "${value}". Must be one of: ${valid.join(", ")}` });
+    process.exit(1);
+}
+function parseMaxSteps(value) {
+    if (value === undefined)
+        return undefined;
+    if (!/^\d+$/.test(value)) {
+        err({ error: `Invalid --max-steps "${value}". Must be a positive integer.` });
+        process.exit(1);
+    }
+    const maxSteps = Number(value);
+    if (maxSteps < 1 || maxSteps > MAX_STEPS_LIMIT) {
+        err({ error: `--max-steps must be between 1 and ${MAX_STEPS_LIMIT}.` });
+        process.exit(1);
+    }
+    return maxSteps;
+}
 async function loadOutputSchema(opts) {
     if (opts.outputSchema !== undefined && opts.outputSchemaFile !== undefined) {
         err({ error: "--output-schema and --output-schema-file are mutually exclusive" });
@@ -77,8 +112,13 @@ export function registerRun(agentCmd) {
         .option("--async", "Submit without waiting for result")
         .option("--output-schema <json>", "Inline JSON Schema object for structured output")
         .option("--output-schema-file <path>", "Path to a JSON file containing the output schema")
+        .option("--browser-profile <profile>", "Browser profile for execution (lite|stealth)")
+        .option("--max-steps <n>", `Maximum tool-call steps before stopping (1-${MAX_STEPS_LIMIT})`)
+        .option("--mode <mode>", "Agent behavior mode (default|strict)")
+        .option("--session-id <uuid>", "Caller-provided UUID for idempotency / parallel-safe --sync")
         .option("--pretty", "Human-readable output")
         .argument("[goal]", "Goal to automate")
+        .addHelpText("after", "\nToken scope note:\n  CLI runs use your personal API key. MCP runs use the MCP token.\n  These are different namespaces; getting an MCP run ID with the CLI returns 404 by design.\n")
         .action(async (goal, opts) => {
         // If no goal is provided and no subcommand matched, show help
         if (!goal) {
@@ -114,11 +154,18 @@ export function registerRun(agentCmd) {
             process.exit(1);
         }
         const outputSchema = await loadOutputSchema(opts);
+        const browserProfile = parseChoice(opts.browserProfile, VALID_BROWSER_PROFILES, "--browser-profile");
+        const mode = parseChoice(opts.mode, VALID_MODES, "--mode");
+        const maxSteps = parseMaxSteps(opts.maxSteps);
+        const sessionId = parseSessionId(opts.sessionId);
         const apiKey = getApiKey();
         const req = {
             goal,
             url: normalizedUrl,
             ...(outputSchema !== undefined ? { output_schema: outputSchema } : {}),
+            ...(browserProfile !== undefined ? { browser_profile: browserProfile } : {}),
+            ...(mode !== undefined || maxSteps !== undefined ? { agent_config: { mode, max_steps: maxSteps } } : {}),
+            ...(sessionId !== undefined ? { session_id: sessionId } : {}),
         };
         if (opts.async) {
             let result;

package/dist/commands/runs.js

@@ -1,8 +1,73 @@
 import { RunStatus } from "@tiny-fish/sdk";
 import { getApiKey } from "../lib/auth.js";
-import { cancelRun, getRun, listRuns } from "../lib/client.js";
+import { cancelRun, getRun, getRunSteps, listRuns } from "../lib/client.js";
 import { err, handleApiError, out, outLine } from "../lib/output.js";
 const VALID_STATUSES = Object.values(RunStatus);
+const DEFAULT_WATCH_TIMEOUT_MS = 1_800_000;
+const DEFAULT_WATCH_INTERVAL_MS = 3000;
+const MIN_WATCH_INTERVAL_MS = 500;
+const TERMINAL_STATUSES = [
+    RunStatus.COMPLETED,
+    RunStatus.FAILED,
+    RunStatus.CANCELLED,
+];
+function formatStep(step, index) {
+    const action = step.action ?? "(no action)";
+    const meta = [step.status, step.duration].filter(Boolean).join(", ");
+    return `${String(index + 1).padStart(2, " ")}. ${action}${meta ? ` (${meta})` : ""}`;
+}
+function parsePositiveInt(value, flag, defaultMs, minMs = 1) {
+    if (value === undefined)
+        return defaultMs;
+    // Reject "5000ms", "1e3", "+5", and similar — only whole-digit input.
+    if (!/^\d+$/.test(value)) {
+        err({ error: `Invalid ${flag} "${value}". Must be a whole-number integer in milliseconds (>= ${minMs}).` });
+        process.exit(1);
+    }
+    const parsed = Number(value);
+    if (parsed < minMs) {
+        err({ error: `Invalid ${flag} "${value}". Must be an integer >= ${minMs}ms.` });
+        process.exit(1);
+    }
+    return parsed;
+}
+function withDeadline(promise, deadline, signal) {
+    return new Promise((resolve, reject) => {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            reject(new Error("watch deadline exceeded"));
+            return;
+        }
+        if (signal.aborted) {
+            reject(new Error("watch aborted"));
+            return;
+        }
+        const timer = setTimeout(() => reject(new Error("watch deadline exceeded")), remaining);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new Error("watch aborted"));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((v) => { clearTimeout(timer); signal.removeEventListener("abort", onAbort); resolve(v); }, (e) => { clearTimeout(timer); signal.removeEventListener("abort", onAbort); reject(e); });
+    });
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new Error("aborted"));
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new Error("aborted"));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
 export function registerRuns(runCmd) {
     // ── run list ───────────────────────────────────────────────────────────────
     runCmd
@@ -95,6 +160,107 @@ export function registerRuns(runCmd) {
             handleApiError(e);
         }
     });
+    runCmd
+        .command("steps <run_id>")
+        .description("Print the step-by-step trace for a run")
+        .option("--pretty", "Human-readable output")
+        .action(async (runId, opts) => {
+        const apiKey = getApiKey();
+        try {
+            const result = await getRunSteps(runId, apiKey);
+            if (opts.pretty) {
+                if (result.steps.length === 0) {
+                    outLine("No steps found.");
+                    return;
+                }
+                outLine(`Run ID: ${result.run_id}`);
+                for (const [index, step] of result.steps.entries()) {
+                    outLine(formatStep(step, index));
+                    outLine(`    ${step.timestamp}`);
+                }
+            }
+            else {
+                out(result);
+            }
+        }
+        catch (e) {
+            handleApiError(e);
+        }
+    });
+    runCmd
+        .command("watch <run_id>")
+        .description("Poll a run and print new steps as they arrive (exits when run reaches a terminal status)")
+        .option("--pretty", "Human-readable output")
+        .option("--timeout <ms>", `Stop polling after this many milliseconds (default: ${DEFAULT_WATCH_TIMEOUT_MS})`)
+        .option("--interval <ms>", `Poll interval (default: ${DEFAULT_WATCH_INTERVAL_MS}, min: ${MIN_WATCH_INTERVAL_MS})`)
+        .action(async (runId, opts) => {
+        const apiKey = getApiKey();
+        const timeoutMs = parsePositiveInt(opts.timeout, "--timeout", DEFAULT_WATCH_TIMEOUT_MS);
+        const intervalMs = parsePositiveInt(opts.interval, "--interval", DEFAULT_WATCH_INTERVAL_MS, MIN_WATCH_INTERVAL_MS);
+        const controller = new AbortController();
+        const onSigint = () => {
+            controller.abort();
+            process.exit(130);
+        };
+        process.once("SIGINT", onSigint);
+        const deadline = Date.now() + timeoutMs;
+        const seen = new Set();
+        try {
+            const initial = await withDeadline(getRun(runId, apiKey), deadline, controller.signal);
+            if (TERMINAL_STATUSES.includes(initial.status)) {
+                err({
+                    error: `Run ${runId} is already ${initial.status}; nothing to watch. Use 'tinyfish agent run steps ${runId}' for the trace.`,
+                });
+                process.exit(1);
+            }
+            while (!controller.signal.aborted) {
+                // One API call per tick — the steps endpoint also returns the run's current status.
+                const tick = await withDeadline(getRunSteps(runId, apiKey), deadline, controller.signal);
+                let nextIndex = seen.size;
+                for (const step of tick.steps) {
+                    if (seen.has(step.id))
+                        continue;
+                    seen.add(step.id);
+                    if (opts.pretty) {
+                        outLine(formatStep(step, nextIndex));
+                        outLine(`    ${step.timestamp}`);
+                    }
+                    else {
+                        out(step);
+                    }
+                    nextIndex += 1;
+                }
+                if (TERMINAL_STATUSES.includes(tick.status)) {
+                    if (opts.pretty)
+                        outLine(`Run ${tick.status.toLowerCase()}.`);
+                    return;
+                }
+                if (Date.now() + intervalMs > deadline) {
+                    err({ error: `Watch timed out after ${timeoutMs}ms (run still ${tick.status}).` });
+                    process.exit(1);
+                }
+                try {
+                    await sleep(intervalMs, controller.signal);
+                }
+                catch {
+                    return; // aborted
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof Error && e.message === "watch deadline exceeded") {
+                err({ error: `Watch timed out after ${timeoutMs}ms.` });
+                process.exit(1);
+            }
+            if (e instanceof Error && e.message === "watch aborted") {
+                return; // SIGINT handler already triggered process.exit(130)
+            }
+            handleApiError(e);
+        }
+        finally {
+            process.off("SIGINT", onSigint);
+        }
+    });
     // ── run cancel ────────────────────────────────────────────────────────────
     runCmd
         .command("cancel <run_id>")

package/dist/lib/client.d.ts

@@ -1,13 +1,14 @@
-import { type AgentRunAsyncResponse, type AgentRunResponse, type AgentRunWithStreamingResponse, type FetchGetContentsParams, type FetchResponse, type BrowserSession, type BrowserSessionCreateParams, type Run, type RunListParams, type RunListResponse, type SearchQueryParams, type SearchQueryResponse } from "@tiny-fish/sdk";
-import type { BatchCancelResponse, BatchGetResponse, BatchRunRequest, BatchRunResponse, CancelRunResponse, CliAgentRunParams } from "./types.js";
+import { type AgentRunAsyncResponse, type AgentRunResponse, type AgentRunWithStreamingResponse, type FetchGetContentsParams, type FetchResponse, type BrowserSession, type Run, type RunListParams, type RunListResponse, type SearchQueryParams, type SearchQueryResponse } from "@tiny-fish/sdk";
+import type { BatchCancelResponse, BatchGetResponse, BatchRunRequest, BatchRunResponse, CancelRunResponse, CliAgentRunParams, CliBrowserSessionCreateParams, RunStepsResponse } from "./types.js";
 export declare function runSync(req: CliAgentRunParams, apiKey: string): Promise<AgentRunResponse>;
 export declare function runAsync(req: CliAgentRunParams, apiKey: string): Promise<AgentRunAsyncResponse>;
 export declare function runStream(req: CliAgentRunParams, 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 getRunSteps(runId: string, apiKey: string): Promise<RunStepsResponse>;
 export declare function searchQuery(params: SearchQueryParams, apiKey: string): Promise<SearchQueryResponse>;
 export declare function fetchContentGet(params: FetchGetContentsParams, apiKey: string): Promise<FetchResponse>;
-export declare function browserSessionCreate(params: BrowserSessionCreateParams, apiKey: string): Promise<BrowserSession>;
+export declare function browserSessionCreate(params: CliBrowserSessionCreateParams, apiKey: string): Promise<BrowserSession>;
 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,4 +1,4 @@
-import { APIStatusError, fetchResponseSchema, browserSessionSchema, searchQueryResponseSchema, TinyFish, runSchema, } from "@tiny-fish/sdk";
+import { APIStatusError, agentRunAsyncResponseSchema, agentRunResponseSchema, agentRunWithStreamingResponseSchema, fetchResponseSchema, browserSessionSchema, searchQueryResponseSchema, TinyFish, runSchema, runStatusSchema, } from "@tiny-fish/sdk";
 import { BASE_URL } from "./constants.js";
 import { ApiError } from "./output.js";
 import { z } from "zod";
@@ -54,6 +54,23 @@ const batchCancelResponseSchema = z.object({
     results: z.array(batchCancelResultSchema),
     not_found: z.array(z.string()).nullable(),
 });
+const runStepSchema = z.object({
+    id: z.string(),
+    timestamp: z.string(),
+    status: z.string(),
+    action: z.string().nullable(),
+    screenshot: z.string().nullable(),
+    duration: z.string().nullable(),
+    target_elements: z.array(z.unknown()).optional(),
+    snapshot_url: z.string().optional(),
+});
+const runStepsResponseSchema = z.object({
+    run_id: z.string(),
+    // Same payload as `GET /v1/runs/:id` — `?screenshots=none` just suppresses base64 image fields.
+    // We surface `status` so callers (e.g. `agent run watch` polling) can avoid a redundant get-run.
+    status: runStatusSchema,
+    steps: z.array(runStepSchema),
+});
 function parseWithSchema(schema, value, message) {
     const result = schema.safeParse(value);
     if (!result.success) {
@@ -61,9 +78,59 @@ function parseWithSchema(schema, value, message) {
     }
     return result.data;
 }
+function normalizeStreamEvent(event) {
+    if (typeof event !== "object" || event === null || event.type !== "COMPLETE") {
+        return event;
+    }
+    const data = event;
+    return {
+        ...data,
+        result: typeof data["result"] === "object" && data["result"] !== null ? data["result"] : null,
+        error: typeof data["error"] === "object" && data["error"] !== null ? data["error"] : null,
+    };
+}
+async function* parseSseStream(stream) {
+    const reader = stream.getReader();
+    let buffer = "";
+    const parseLine = (rawLine) => {
+        const line = rawLine.trim();
+        if (!line || line.startsWith(":") || !line.startsWith("data:"))
+            return undefined;
+        try {
+            return JSON.parse(line.slice("data:".length).trim());
+        }
+        catch {
+            return undefined;
+        }
+    };
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += value;
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const rawLine of lines) {
+                const event = parseLine(rawLine);
+                if (event !== undefined)
+                    yield event;
+            }
+        }
+        const finalEvent = parseLine(buffer);
+        if (finalEvent !== undefined)
+            yield finalEvent;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
 export async function runSync(req, apiKey) {
     try {
-        return await createSdkClient(apiKey).agent.run(req);
+        const response = await createSdkClient(apiKey).post("/v1/automation/run", {
+            json: req,
+        });
+        return parseWithSchema(agentRunResponseSchema, response, "Invalid agent run response");
     }
     catch (error) {
         rethrowSdkError(error);
@@ -71,7 +138,10 @@ export async function runSync(req, apiKey) {
 }
 export async function runAsync(req, apiKey) {
     try {
-        return await createSdkClient(apiKey).agent.queue(req);
+        const response = await createSdkClient(apiKey).post("/v1/automation/run-async", {
+            json: req,
+        });
+        return parseWithSchema(agentRunAsyncResponseSchema, response, "Invalid async run response");
     }
     catch (error) {
         rethrowSdkError(error);
@@ -80,9 +150,14 @@ export async function runAsync(req, apiKey) {
 export async function* runStream(req, apiKey, signal) {
     let stream = null;
     try {
-        stream = await createSdkClient(apiKey).agent.stream(req, { signal });
-        for await (const event of stream) {
-            yield event;
+        stream = await createSdkClient(apiKey).postStream("/v1/automation/run-sse", {
+            json: req,
+            signal,
+        });
+        for await (const event of parseSseStream(stream)) {
+            const parsed = agentRunWithStreamingResponseSchema.safeParse(normalizeStreamEvent(event));
+            if (parsed.success)
+                yield parsed.data;
         }
     }
     catch (error) {
@@ -91,7 +166,7 @@ export async function* runStream(req, apiKey, signal) {
     finally {
         if (stream) {
             try {
-                await stream.close();
+                await stream.cancel();
             }
             catch {
                 // Ignore close errors — the original stream result/error already decided control flow.
@@ -115,6 +190,17 @@ export async function getRun(runId, apiKey) {
         rethrowSdkError(error);
     }
 }
+export async function getRunSteps(runId, apiKey) {
+    try {
+        // The public GET /v1/runs/:id route returns the base run payload plus `steps`;
+        // the installed SDK runSchema only models the base run, so steps need this local schema.
+        const response = await createSdkClient(apiKey).get(`/v1/runs/${encodeURIComponent(runId)}`, { params: { screenshots: "none" } });
+        return parseWithSchema(runStepsResponseSchema, response, "Invalid run steps response");
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
+}
 export async function searchQuery(params, apiKey) {
     try {
         const response = await createSdkClient(apiKey).search.query(params);
@@ -135,7 +221,7 @@ export async function fetchContentGet(params, apiKey) {
 }
 export async function browserSessionCreate(params, apiKey) {
     try {
-        const response = await createSdkClient(apiKey).browser.sessions.create(params);
+        const response = await createSdkClient(apiKey).post("/v1/browser", { json: params });
         return browserSessionSchema.parse(response);
     }
     catch (error) {

package/dist/lib/types.d.ts

@@ -1,7 +1,32 @@
-import type { AgentRunParams, Run, RunStatus } from "@tiny-fish/sdk";
+import type { AgentRunParams, BrowserProfile, Run, RunStatus } from "@tiny-fish/sdk";
 export type OutputSchema = Record<string, unknown>;
 export interface CliAgentRunParams extends AgentRunParams {
     output_schema?: OutputSchema;
+    agent_config?: {
+        mode?: "default" | "strict";
+        max_steps?: number;
+    };
+    browser_profile?: BrowserProfile;
+    session_id?: string;
+}
+export interface RunStep {
+    id: string;
+    timestamp: string;
+    status: string;
+    action: string | null;
+    screenshot: string | null;
+    duration: string | null;
+    target_elements?: unknown[];
+    snapshot_url?: string;
+}
+export interface RunStepsResponse {
+    run_id: string;
+    status: RunStatus;
+    steps: RunStep[];
+}
+export interface CliBrowserSessionCreateParams {
+    url?: string;
+    browser_profile?: "lite" | "stealth";
 }
 export interface CancelRunResponse {
     run_id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.1.5-next.47",
+  "version": "0.1.5-next.50",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {
@@ -49,7 +49,8 @@
   },
   "overrides": {
     "vite": "7.3.2",
-    "brace-expansion": "5.0.5"
+    "brace-expansion": "5.0.5",
+    "postcss": "8.5.10"
   },
   "engines": {
     "node": ">=24.0.0"