@tiny-fish/cli 0.1.7-next.67 → 0.1.8-next.70

package/dist/commands/profile.d.ts

@@ -1,2 +1,14 @@
 import { Command } from "commander";
+import type { CookieRecord } from "../lib/types.js";
+export declare function extractChromeCookies(domain: string): Promise<CookieRecord[]>;
+export declare function extractAllChromeCookies(): Promise<CookieRecord[]>;
+type TldtsParse = (host: string, opts: {
+    allowPrivateDomains: boolean;
+}) => {
+    domain?: string;
+};
+export declare function groupByCanonicalDomain(cookies: CookieRecord[], parse: TldtsParse): Map<string, CookieRecord[]>;
+export declare const MAX_COOKIES_PER_UPLOAD = 3000;
+export declare function buildChunks(groups: Map<string, CookieRecord[]>): CookieRecord[][];
 export declare function registerProfile(program: Command): void;
+export {};

package/dist/commands/profile.js

@@ -23,14 +23,11 @@ function getChromeCookiesPath() {
     if (platform === "linux") {
         return path.join(os.homedir(), ".config", "google-chrome", "Default", "Cookies");
     }
-    // Windows guard — handled in extractChromeCookies
+    // Windows guard — handled in withCookiesDb
     return "";
 }
 function validateDomain(domain) {
-    if (domain.includes("/") ||
-        domain.includes("://") ||
-        /\s/.test(domain) ||
-        /:\d/.test(domain)) {
+    if (domain.includes("/") || domain.includes("://") || /\s/.test(domain) || /:\d/.test(domain)) {
         err({ error: "domain must be a plain hostname (e.g. github.com)" });
         process.exit(1);
     }
@@ -40,7 +37,8 @@ const CHROME_EPOCH_DELTA_SECONDS = 11644473600;
 function chromeTimeToUnix(chromeMicros) {
     return Math.floor(chromeMicros / 1e6) - CHROME_EPOCH_DELTA_SECONDS;
 }
-async function extractChromeCookies(domain) {
+// Sets up chrome-cookies-secure in a temp dir and calls fn; cleans up after.
+async function withCookiesDb(fn) {
     if (process.platform === "win32") {
         throw new UserFacingError("Cookie extraction is not supported on Windows yet");
     }
@@ -56,20 +54,7 @@ async function extractChromeCookies(domain) {
         // chrome-cookies-secure is a CommonJS module — use createRequire to load it
         const require = createRequire(import.meta.url);
         const chromeCookies = require("chrome-cookies-secure");
-        // "puppeteer" format returns an array with capitalized boolean fields and
-        // Chrome-internal microsecond timestamps — convert to our CookieRecord shape.
-        const raw = await chromeCookies.getCookiesPromised(`https://${domain}`, "puppeteer", tmpDir);
-        return raw.map((c) => ({
-            name: c.name,
-            value: c.value,
-            domain: c.domain,
-            path: c.path,
-            secure: c.Secure ?? false,
-            httpOnly: c.HttpOnly ?? false,
-            ...(c.expires && c.expires > 0
-                ? { expires: chromeTimeToUnix(c.expires) }
-                : {}),
-        }));
+        return await fn(tmpDir, chromeCookies);
     }
     finally {
         try {
@@ -80,6 +65,132 @@ async function extractChromeCookies(domain) {
         }
     }
 }
+// Extract cookies for a single domain using an already-open cookies DB.
+async function extractDomain(tmpDir, chromeCookies, domain) {
+    // "puppeteer" format returns an array with capitalized boolean fields and
+    // Chrome-internal microsecond timestamps — convert to our CookieRecord shape.
+    const raw = await chromeCookies.getCookiesPromised(`https://${domain}`, "puppeteer", tmpDir);
+    return raw.map((c) => ({
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: c.path,
+        secure: c.Secure ?? false,
+        httpOnly: c.HttpOnly ?? false,
+        ...(c.expires && c.expires > 0 ? { expires: chromeTimeToUnix(c.expires) } : {}),
+    }));
+}
+// Exported for testing
+export async function extractChromeCookies(domain) {
+    return withCookiesDb((tmpDir, chromeCookies) => extractDomain(tmpDir, chromeCookies, domain));
+}
+// Exported for testing
+export async function extractAllChromeCookies() {
+    return withCookiesDb(async (tmpDir, chromeCookies) => {
+        const { DatabaseSync } = createRequire(import.meta.url)("node:sqlite");
+        let sqliteDb = null;
+        let hostKeys;
+        try {
+            sqliteDb = new DatabaseSync(path.join(tmpDir, "Cookies")); // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal
+            // Only import domains with auth-relevant cookies — skips tracking/analytics junk.
+            // A domain qualifies if it has any HttpOnly cookie (session/auth indicator) or
+            // a cookie whose name suggests authentication.
+            const rows = sqliteDb
+                .prepare(`SELECT DISTINCT host_key FROM cookies
+           WHERE is_httponly = 1
+              OR name LIKE '%session%'
+              OR name LIKE '%token%'
+              OR name LIKE '%auth%'
+              OR name LIKE '%sid%'
+              OR name LIKE '%login%'
+              OR name LIKE '%user%'
+              OR name LIKE '%account%'`)
+                .all();
+            hostKeys = rows.map((r) => r.host_key);
+        }
+        catch (e) {
+            throw new UserFacingError(`Failed to read Chrome cookies database: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        finally {
+            try {
+                sqliteDb?.close();
+            }
+            catch {
+                // Ignore
+            }
+        }
+        // 2. Canonicalize host_keys → registrable domains (mirrors frontend/app/lib/services/domain-utils.ts)
+        const require = createRequire(import.meta.url);
+        const { parse } = require("tldts");
+        const registrableDomains = new Set();
+        for (const hk of hostKeys) {
+            const cleaned = hk.startsWith(".") ? hk.slice(1) : hk;
+            const result = parse(cleaned, { allowPrivateDomains: true });
+            if (result.domain)
+                registrableDomains.add(result.domain.toLowerCase());
+        }
+        errLine(`Scanning ${registrableDomains.size} domains from Chrome...`);
+        // 3. Extract per-domain and concat
+        const all = [];
+        for (const domain of registrableDomains) {
+            try {
+                const cookies = await extractDomain(tmpDir, chromeCookies, domain);
+                all.push(...cookies);
+            }
+            catch {
+                // skip domains chrome-cookies-secure can't parse (IPs, .local, etc.)
+            }
+        }
+        // 4. Dedup by name+domain+path
+        const seen = new Set();
+        return all.filter((c) => {
+            const key = `${c.name}\t${c.domain}\t${c.path}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    });
+}
+// Exported for testing
+export function groupByCanonicalDomain(cookies, parse) {
+    const groups = new Map();
+    for (const c of cookies) {
+        const cleaned = c.domain.startsWith(".") ? c.domain.slice(1) : c.domain;
+        const cd = parse(cleaned, { allowPrivateDomains: true }).domain?.toLowerCase() ?? cleaned;
+        const bucket = groups.get(cd) ?? [];
+        bucket.push(c);
+        groups.set(cd, bucket);
+    }
+    return groups;
+}
+// Exported for testing
+export const MAX_COOKIES_PER_UPLOAD = 3000;
+// Exported for testing
+export function buildChunks(groups) {
+    const chunks = [];
+    let current = [];
+    for (const group of groups.values()) {
+        // A group that alone exceeds the cap is its own chunk (never split a canonical domain)
+        if (group.length > MAX_COOKIES_PER_UPLOAD) {
+            if (current.length > 0) {
+                chunks.push(current);
+                current = [];
+            }
+            chunks.push(group);
+        }
+        else if (current.length + group.length > MAX_COOKIES_PER_UPLOAD) {
+            chunks.push(current);
+            current = [...group];
+        }
+        else {
+            current.push(...group);
+        }
+    }
+    if (current.length > 0)
+        chunks.push(current);
+    return chunks;
+}
 // ── Pretty printers ───────────────────────────────────────────────────────────
 function printPrettyProfileCreate(profile) {
     outLine("Profile created");
@@ -120,26 +231,69 @@ export function registerProfile(program) {
     });
     profileCmd
         .command("import-cookies")
-        .description("Import Chrome cookies for a domain into a profile")
-        .requiredOption("--domain <domain>", "Domain to import cookies for (e.g. github.com)")
+        .description("Import Chrome cookies into a profile. Use --domain for a single domain or --all-domains for every domain in your Chrome profile. Exactly one must be provided.")
+        .option("--domain <domain>", "Domain to import cookies for (e.g. github.com)")
+        .option("--all-domains", "Import cookies for all registrable domains (e.g. github.com) found in your Chrome profile. IPs and non-resolvable hostnames (e.g. localhost) are skipped.")
         .option("--profile-id <id>", "Profile ID to import cookies into (creates new profile if omitted)")
         .option("--pretty", "Human-readable output")
         .action(async (opts) => {
+        // Mutual-exclusivity guard — must provide exactly one of --domain / --all-domains
+        if (!opts.domain && !opts.allDomains) {
+            err({ error: "Provide exactly one of --domain or --all-domains" });
+            process.exit(1);
+        }
+        if (opts.domain && opts.allDomains) {
+            err({ error: "Provide exactly one of --domain or --all-domains" });
+            process.exit(1);
+        }
         const apiKey = getApiKey();
-        validateDomain(opts.domain);
+        if (opts.domain) {
+            validateDomain(opts.domain);
+        }
         let profileId = opts.profileId;
         try {
             // Extract cookies before creating profile to avoid orphan profiles
             // if extraction fails (Windows, no Chrome, no cookies).
-            const cookies = await extractChromeCookies(opts.domain);
+            const cookies = opts.allDomains
+                ? await extractAllChromeCookies()
+                : await extractChromeCookies(opts.domain);
             if (cookies.length === 0) {
-                throw new UserFacingError(`No Chrome cookies found for ${opts.domain}. Are you logged in to this site in Chrome?`);
+                throw new UserFacingError(opts.allDomains
+                    ? "No Chrome cookies found. Is Google Chrome installed and have you logged in to any sites?"
+                    : `No Chrome cookies found for ${opts.domain}. Are you logged in to this site in Chrome?`);
             }
             if (profileId === undefined) {
-                const created = await profileCreate(opts.domain, apiKey);
+                const name = opts.allDomains ? "chrome-import" : opts.domain;
+                const created = await profileCreate(name, apiKey);
                 profileId = created.id;
             }
-            const result = await profileUpload(profileId, cookies, apiKey);
+            let result;
+            if (opts.allDomains) {
+                // Batch upload — never split a canonical domain across chunks
+                const require = createRequire(import.meta.url);
+                const { parse } = require("tldts");
+                const groups = groupByCanonicalDomain(cookies, parse);
+                const chunks = buildChunks(groups);
+                let cookieCount = 0;
+                const domainsUpdated = [];
+                const domainsFailed = [];
+                for (const chunk of chunks) {
+                    const r = await profileUpload(profileId, chunk, apiKey);
+                    cookieCount += r.cookie_count;
+                    domainsUpdated.push(...r.domains_updated);
+                    if (r.domains_failed)
+                        domainsFailed.push(...r.domains_failed);
+                }
+                result = {
+                    profile_id: profileId,
+                    cookie_count: cookieCount,
+                    domains_updated: domainsUpdated,
+                    ...(domainsFailed.length > 0 ? { domains_failed: domainsFailed } : {}),
+                };
+            }
+            else {
+                result = await profileUpload(profileId, cookies, apiKey);
+            }
             if (result.domains_failed && result.domains_failed.length > 0) {
                 errLine(`Warning: failed to update cookies for domains: ${result.domains_failed.join(", ")}`);
             }

package/dist/lib/client.js

@@ -1,12 +1,14 @@
 import { APIStatusError, agentRunAsyncResponseSchema, agentRunResponseSchema, agentRunWithStreamingResponseSchema, fetchResponseSchema, browserSessionSchema, searchQueryResponseSchema, TinyFish, runSchema, runStatusSchema, } from "@tiny-fish/sdk";
-import { BASE_URL } from "./constants.js";
+import { BASE_URL, CLI_VERSION } from "./constants.js";
 import { ApiError } from "./output.js";
 import { z } from "zod";
 class TinyFishCliClient extends TinyFish {
     _buildHeaders() {
+        const base = super._buildHeaders();
         return {
-            ...super._buildHeaders(),
+            ...base,
             "X-TF-Request-Origin": "tinyfish-cli",
+            "User-Agent": `${base["User-Agent"] ?? ""} @tiny-fish/cli/${CLI_VERSION}`.trim(),
         };
     }
 }

package/dist/lib/constants.d.ts

@@ -1,3 +1,4 @@
+export declare const CLI_VERSION: string;
 export declare const BASE_URL: string;
 /** URL where users can create and manage API keys */
 export declare function getDashboardUrl(source?: string): string;

package/dist/lib/constants.js

@@ -1,3 +1,7 @@
+import { createRequire } from "module";
+const _require = createRequire(import.meta.url);
+const _pkg = _require("../../package.json");
+export const CLI_VERSION = _pkg.version;
 /** Base URL for the TinyFish API. Override with TINYFISH_API_URL for staging/self-hosted (must be https). */
 const apiUrlOverride = process.env["TINYFISH_API_URL"]?.trim();
 if (apiUrlOverride) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.1.7-next.67",
+  "version": "0.1.8-next.70",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {