@tiny-fish/cli 0.1.4-next.37 → 0.1.4-next.40

package/README.md

@@ -59,6 +59,35 @@ tinyfish agent run get <run_id> --pretty
 tinyfish agent run cancel <run_id> --pretty
 ```
 
+### Search
+
+```bash
+# Query TinyFish Search
+tinyfish search query "agentql pricing"
+
+# Add location and language hints
+tinyfish search query "agentql pricing" --location US --language en
+
+# Human-readable output
+tinyfish search query "agentql pricing" --pretty
+```
+
+### Fetch
+
+```bash
+# Fetch extracted content from one or more URLs
+tinyfish fetch content get https://agentql.com
+
+# Choose the output format
+tinyfish fetch content get https://agentql.com --format markdown
+
+# Include links and image links
+tinyfish fetch content get https://agentql.com --links --image-links
+
+# Human-readable output
+tinyfish fetch content get https://agentql.com --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.

package/dist/commands/fetch.d.ts

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

package/dist/commands/fetch.js

@@ -0,0 +1,66 @@
+import { getApiKey } from "../lib/auth.js";
+import { fetchContentGet } from "../lib/client.js";
+import { handleApiError, out, outLine } from "../lib/output.js";
+function printPrettyFetch(response) {
+    outLine(`Results: ${response.results.length}`);
+    outLine(`Errors: ${response.errors.length}`);
+    outLine("");
+    if (response.results.length > 0) {
+        outLine("Successful fetches:");
+        for (const result of response.results) {
+            outLine(`- ${result.url}`);
+            outLine(`  Format: ${result.format}`);
+            if (result.title)
+                outLine(`  Title: ${result.title}`);
+            if (result.final_url && result.final_url !== result.url)
+                outLine(`  Final URL: ${result.final_url}`);
+            outLine("");
+        }
+    }
+    if (response.errors.length > 0) {
+        outLine("Errors:");
+        for (const error of response.errors) {
+            outLine(`- ${error.url}`);
+            outLine(`  ${error.error}`);
+            outLine("");
+        }
+    }
+}
+export function registerFetch(program) {
+    const fetchCmd = program
+        .command("fetch")
+        .description("Fetch commands")
+        .enablePositionalOptions();
+    const contentCmd = fetchCmd
+        .command("content")
+        .description("Content extraction commands")
+        .enablePositionalOptions();
+    contentCmd
+        .command("get")
+        .description("Fetch clean content from one or more URLs")
+        .argument("<urls...>", "One or more URLs to fetch")
+        .option("--format <format>", "Output format: markdown, html, or json")
+        .option("--links", "Include extracted links")
+        .option("--image-links", "Include extracted image links")
+        .option("--pretty", "Human-readable output")
+        .action(async (urls, opts) => {
+        const apiKey = getApiKey();
+        try {
+            const response = await fetchContentGet({
+                urls,
+                ...(opts.format !== undefined ? { format: opts.format } : {}),
+                ...(opts.links !== undefined ? { links: opts.links } : {}),
+                ...(opts.imageLinks !== undefined ? { image_links: opts.imageLinks } : {}),
+            }, apiKey);
+            if (opts.pretty) {
+                printPrettyFetch(response);
+            }
+            else {
+                out(response);
+            }
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    });
+}

package/dist/commands/search.d.ts

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

package/dist/commands/search.js

@@ -0,0 +1,50 @@
+import { getApiKey } from "../lib/auth.js";
+import { searchQuery } from "../lib/client.js";
+import { handleApiError, out, outLine } from "../lib/output.js";
+function printPrettySearch(response) {
+    outLine(`Query: ${response.query}`);
+    outLine(`Total results: ${response.total_results}`);
+    outLine("");
+    if (response.results.length === 0) {
+        outLine("No results.");
+        return;
+    }
+    for (const result of response.results) {
+        outLine(`${result.position}. ${result.title}`);
+        outLine(`   ${result.url}`);
+        outLine(`   ${result.snippet}`);
+        outLine("");
+    }
+}
+export function registerSearch(program) {
+    const searchCmd = program
+        .command("search")
+        .description("Search commands")
+        .enablePositionalOptions();
+    searchCmd
+        .command("query")
+        .description("Query TinyFish Search")
+        .argument("<query>", "Search query")
+        .option("--location <value>", "Search location hint")
+        .option("--language <value>", "Search language hint")
+        .option("--pretty", "Human-readable output")
+        .action(async (query, opts) => {
+        const apiKey = getApiKey();
+        try {
+            const response = await searchQuery({
+                query,
+                ...(opts.location !== undefined ? { location: opts.location } : {}),
+                ...(opts.language !== undefined ? { language: opts.language } : {}),
+            }, apiKey);
+            if (opts.pretty) {
+                printPrettySearch(response);
+            }
+            else {
+                out(response);
+            }
+        }
+        catch (error) {
+            handleApiError(error);
+        }
+    });
+}

package/dist/index.js

@@ -3,8 +3,10 @@ import { createRequire } from "module";
 import { Command } from "commander";
 import { registerAuth } from "./commands/auth.js";
 import { registerBatch } from "./commands/batch.js";
+import { registerFetch } from "./commands/fetch.js";
 import { registerRun } from "./commands/run.js";
 import { registerRuns } from "./commands/runs.js";
+import { registerSearch } from "./commands/search.js";
 const { version } = createRequire(import.meta.url)("../package.json");
 const program = new Command();
 program
@@ -28,6 +30,8 @@ const agentCmd = program
 const runCmd = registerRun(agentCmd);
 registerRuns(runCmd);
 registerBatch(agentCmd);
+registerSearch(program);
+registerFetch(program);
 // 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,10 +1,12 @@
-import { type AgentRunAsyncResponse, type AgentRunParams, type AgentRunResponse, type AgentRunWithStreamingResponse, type Run, type RunListParams, type RunListResponse } from "@tiny-fish/sdk";
+import { type AgentRunAsyncResponse, type AgentRunParams, type AgentRunResponse, type AgentRunWithStreamingResponse, type FetchGetContentsParams, type FetchResponse, type Run, type RunListParams, type RunListResponse, type SearchQueryParams, type SearchQueryResponse } 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 searchQuery(params: SearchQueryParams, apiKey: string): Promise<SearchQueryResponse>;
+export declare function fetchContentGet(params: FetchGetContentsParams, apiKey: string): Promise<FetchResponse>;
 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, TinyFish, runSchema, } from "@tiny-fish/sdk";
+import { APIStatusError, fetchResponseSchema, searchQueryResponseSchema, TinyFish, runSchema, } from "@tiny-fish/sdk";
 import { BASE_URL } from "./constants.js";
 import { ApiError } from "./output.js";
 import { z } from "zod";
@@ -115,6 +115,24 @@ export async function getRun(runId, apiKey) {
         rethrowSdkError(error);
     }
 }
+export async function searchQuery(params, apiKey) {
+    try {
+        const response = await createSdkClient(apiKey).search.query(params);
+        return searchQueryResponseSchema.parse(response);
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
+}
+export async function fetchContentGet(params, apiKey) {
+    try {
+        const response = await createSdkClient(apiKey).fetch.getContents(params);
+        return fetchResponseSchema.parse(response);
+    }
+    catch (error) {
+        rethrowSdkError(error);
+    }
+}
 export async function cancelRun(runId, apiKey) {
     try {
         const response = await createSdkClient(apiKey).post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, { json: {} });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.1.4-next.37",
+  "version": "0.1.4-next.40",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {
@@ -16,7 +16,15 @@
     "test": "vitest --run",
     "test:file": "vitest --run",
     "test:watch": "vitest",
-    "test:integration": "vitest --run --config vitest.integration.config.ts",
+    "test:integration:auth": "vitest --run --config vitest.integration.config.ts tests/auth.integration.test.ts",
+    "test:integration:api:fetch": "vitest --run --passWithNoTests --config vitest.integration.config.ts tests/api.integration.test.ts --testNamePattern \"fetch content get|skips real API coverage when TINYFISH_API_KEY is not set\"",
+    "test:integration:api:search": "vitest --run --passWithNoTests --config vitest.integration.config.ts tests/api.integration.test.ts --testNamePattern \"search query|skips real API coverage when TINYFISH_API_KEY is not set\"",
+    "test:integration:api:sync": "vitest --run --passWithNoTests --config vitest.integration.config.ts tests/api.integration.test.ts --testNamePattern \"agent run --sync|skips real API coverage when TINYFISH_API_KEY is not set\"",
+    "test:integration:api:stream": "vitest --run --passWithNoTests --config vitest.integration.config.ts tests/api.integration.test.ts --testNamePattern \"agent run streaming exits cleanly after COMPLETE|skips real API coverage when TINYFISH_API_KEY is not set\"",
+    "test:integration:api:async": "vitest --run --passWithNoTests --config vitest.integration.config.ts tests/api.integration.test.ts --testNamePattern \"agent run --async returns a run id that can be fetched and listed|skips real API coverage when TINYFISH_API_KEY is not set\"",
+    "test:integration:api:cancel": "vitest --run --passWithNoTests --config vitest.integration.config.ts tests/api.integration.test.ts --testNamePattern \"agent run cancel cancels an in-flight run|skips real API coverage when TINYFISH_API_KEY is not set\"",
+    "test:integration:api:batch": "vitest --run --passWithNoTests --config vitest.integration.config.ts tests/api.integration.test.ts --testNamePattern \"batch commands work end-to-end against the real API|skips real API coverage when TINYFISH_API_KEY is not set\"",
+    "test:integration": "npm run test:integration:auth && npm run test:integration:api:fetch && npm run test:integration:api:search && npm run test:integration:api:sync && npm run test:integration:api:stream && npm run test:integration:api:async && npm run test:integration:api:cancel && npm run test:integration:api:batch",
     "lint": "eslint src tests",
     "format": "prettier --write src tests",
     "type-check": "tsc --noEmit --project tsconfig.all.json",