@scira/cli 0.1.0

package/dist/tools/file-tools.js

@@ -0,0 +1,128 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { Files } from "files-sdk";
+import { fs } from "files-sdk/fs";
+import { logEvent } from "../storage/run-store.js";
+const MAX_CONTENT = 8000;
+function truncate(text, max = MAX_CONTENT) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max)}\n…[truncated ${text.length - max} chars]`;
+}
+async function takeAsync(iter, max) {
+    const results = [];
+    for await (const item of iter) {
+        results.push(item);
+        if (results.length >= max)
+            break;
+    }
+    return results;
+}
+export function createFileTools(runPath, config, onApprovalRequired) {
+    const dir = config.files.dir;
+    const files = new Files({ adapter: fs({ root: dir }) });
+    async function gate(toolName, description) {
+        if (config.approvalMode === "auto" || !onApprovalRequired)
+            return true;
+        return onApprovalRequired(toolName, description);
+    }
+    return {
+        listFiles: tool({
+            description: "List files in the configured files directory. Use to enumerate available documents before reading them.",
+            inputSchema: z.object({
+                prefix: z.string().optional().describe("Key prefix to filter results (e.g. 'reports/')."),
+                maxResults: z.number().int().min(1).max(200).optional().describe("Max files to return (default 50).")
+            }),
+            execute: async ({ prefix, maxResults = 50 }) => {
+                const items = await takeAsync(files.listAll({ prefix }), maxResults);
+                await logEvent(runPath, "file.list", { prefix, count: items.length });
+                return JSON.stringify(items.map((f) => ({ key: f.key, size: f.size, lastModified: f.lastModified })), null, 2);
+            }
+        }),
+        searchFiles: tool({
+            description: "Search the files directory by glob pattern, substring, or /regex/ string. " +
+                "Glob examples: '**/*.pdf', 'reports/*.md'. Wrap in slashes for regex: '/error|panic/'.",
+            inputSchema: z.object({
+                pattern: z.string().describe("Glob (default), substring, or /regex/ string to match against file keys."),
+                prefix: z.string().optional().describe("Limit the search to keys with this prefix."),
+                maxResults: z.number().int().min(1).max(100).optional().describe("Max results (default 20).")
+            }),
+            execute: async ({ pattern, prefix, maxResults = 20 }) => {
+                const patternArg = pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 2
+                    ? new RegExp(pattern.slice(1, -1))
+                    : pattern;
+                const items = await takeAsync(files.search(patternArg, { prefix, maxResults }), maxResults);
+                await logEvent(runPath, "file.search", { pattern, count: items.length });
+                return JSON.stringify(items.map((f) => ({ key: f.key, size: f.size, lastModified: f.lastModified })), null, 2);
+            }
+        }),
+        getFile: tool({
+            description: "Read the text content of a file from the files directory. " +
+                "Returns the file content (truncated if large). Binary files return a content-type notice.",
+            inputSchema: z.object({
+                key: z.string().describe("File key — path relative to the files directory root.")
+            }),
+            execute: async ({ key }) => {
+                let stored;
+                try {
+                    stored = await files.download(key);
+                }
+                catch (error) {
+                    return `Could not read "${key}": ${error.message}`;
+                }
+                const contentType = stored.type ?? "application/octet-stream";
+                if (contentType.startsWith("image/") ||
+                    contentType.startsWith("video/") ||
+                    contentType.startsWith("audio/") ||
+                    contentType === "application/octet-stream") {
+                    await logEvent(runPath, "file.read", { key, binary: true, contentType });
+                    return `Binary file (${contentType}) — cannot display as text.`;
+                }
+                const text = await stored.text();
+                await logEvent(runPath, "file.read", { key, chars: text.length });
+                return truncate(text);
+            }
+        }),
+        fileExists: tool({
+            description: "Check whether a file exists in the files directory.",
+            inputSchema: z.object({
+                key: z.string().describe("File key to check.")
+            }),
+            execute: async ({ key }) => {
+                const exists = await files.exists(key);
+                return exists
+                    ? `"${key}" exists.`
+                    : `"${key}" does not exist.`;
+            }
+        }),
+        moveFile: tool({
+            description: "Move (rename) a file within the files directory. Requires user approval.",
+            inputSchema: z.object({
+                source: z.string().describe("Current file key."),
+                destination: z.string().describe("Target file key.")
+            }),
+            execute: async ({ source, destination }) => {
+                if (!await gate("moveFile", `Move file:\n  ${source} → ${destination}`)) {
+                    return "Move rejected by user.";
+                }
+                await files.move(source, destination);
+                await logEvent(runPath, "file.move", { source, destination });
+                return `Moved "${source}" → "${destination}"`;
+            }
+        }),
+        deleteFile: tool({
+            description: "Delete a file from the files directory. Requires user approval.",
+            inputSchema: z.object({
+                key: z.string().describe("File key to delete.")
+            }),
+            execute: async ({ key }) => {
+                if (!await gate("deleteFile", `Delete file: "${key}"`)) {
+                    return "Delete rejected by user.";
+                }
+                await files.delete(key);
+                await logEvent(runPath, "file.delete", { key });
+                return `Deleted "${key}".`;
+            }
+        })
+    };
+}

package/dist/tools/mcp-bridge.js

@@ -0,0 +1,118 @@
+import { createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
+import { resolveOAuthToken } from "./mcp-oauth.js";
+const NOOP_BRIDGE = {
+    tools: {},
+    close: async () => { },
+    toolNames: []
+};
+function resolveMcpHeaders(srv, oauthToken) {
+    if (srv.authType === "oauth" && oauthToken) {
+        return { Authorization: `Bearer ${oauthToken}` };
+    }
+    if (srv.authType === "bearer" && srv.bearerToken) {
+        return { Authorization: `Bearer ${srv.bearerToken}` };
+    }
+    if (srv.authType === "header" && srv.headerName && srv.headerValue) {
+        return { [srv.headerName]: srv.headerValue };
+    }
+    return undefined;
+}
+async function connectServer(srv, config) {
+    let client;
+    try {
+        let transport;
+        if (srv.transport === "stdio") {
+            if (!srv.command)
+                throw new Error(`MCP server "${srv.name}" is missing required "command" for stdio transport.`);
+            const cleanEnv = srv.env && Object.keys(srv.env).length > 0
+                ? Object.fromEntries(Object.entries({ ...process.env, ...srv.env }).filter((e) => e[1] !== undefined))
+                : undefined;
+            transport = new Experimental_StdioMCPTransport({
+                command: srv.command,
+                args: srv.args ?? [],
+                stderr: "pipe",
+                ...(cleanEnv ? { env: cleanEnv } : {}),
+            });
+        }
+        else if (srv.transport === "sse") {
+            if (!srv.url)
+                throw new Error(`MCP server "${srv.name}" is missing required "url" for sse transport.`);
+            const oauthToken = (srv.authType === "oauth" && config)
+                ? await resolveOAuthToken(srv, config)
+                : undefined;
+            const headers = resolveMcpHeaders(srv, oauthToken);
+            transport = { type: "sse", url: srv.url, ...(headers ? { headers } : {}) };
+        }
+        else {
+            if (!srv.url)
+                throw new Error(`MCP server "${srv.name}" is missing required "url" for http transport.`);
+            const oauthToken = (srv.authType === "oauth" && config)
+                ? await resolveOAuthToken(srv, config)
+                : undefined;
+            const headers = resolveMcpHeaders(srv, oauthToken);
+            transport = { type: "http", url: srv.url, ...(headers ? { headers } : {}) };
+        }
+        client = await createMCPClient({ transport, clientName: "scira-cli" });
+        const raw = await client.tools();
+        const prefix = srv.toolPrefix ?? "";
+        const prefixed = {};
+        const toolNames = [];
+        for (const [toolName, tool] of Object.entries(raw)) {
+            const finalName = prefix ? `${prefix}${toolName}` : toolName;
+            prefixed[finalName] = tool;
+            toolNames.push(finalName);
+        }
+        const owned = client;
+        return {
+            tools: prefixed,
+            toolNames,
+            close: async () => { try {
+                await owned.close();
+            }
+            catch { /* ignore */ } }
+        };
+    }
+    catch (error) {
+        if (client) {
+            try {
+                await client.close();
+            }
+            catch { /* ignore */ }
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`\n[scira] MCP server "${srv.name}" unavailable: ${message}\n`);
+        return NOOP_BRIDGE;
+    }
+}
+/**
+ * Connect to all enabled MCP servers in config (chromeDevtools + mcp.servers)
+ * and merge their tools into a single bridge.
+ */
+export async function createMcpBridge(config) {
+    const tasks = [];
+    const dt = config.mcp.chromeDevtools;
+    if (dt.enabled) {
+        tasks.push(connectServer({ name: "chromeDevtools", transport: "stdio", command: dt.command, args: dt.args, toolPrefix: dt.toolPrefix }));
+    }
+    for (const srv of config.mcp.servers) {
+        if (srv.enabled)
+            tasks.push(connectServer(srv, config));
+    }
+    if (tasks.length === 0)
+        return NOOP_BRIDGE;
+    const bridges = await Promise.all(tasks);
+    const mergedTools = {};
+    const mergedNames = [];
+    const closeFns = [];
+    for (const b of bridges) {
+        Object.assign(mergedTools, b.tools);
+        mergedNames.push(...b.toolNames);
+        closeFns.push(b.close);
+    }
+    return {
+        tools: mergedTools,
+        toolNames: mergedNames,
+        close: async () => { await Promise.all(closeFns.map((fn) => fn())); }
+    };
+}

package/dist/tools/mcp-oauth.js

@@ -0,0 +1,276 @@
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { exec } from "node:child_process";
+import { saveGlobalMcpConfig } from "../config/load-config.js";
+function toBase64Url(buf) {
+    return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function createVerifier() {
+    return toBase64Url(randomBytes(48));
+}
+function createChallenge(verifier) {
+    return toBase64Url(createHash("sha256").update(verifier).digest());
+}
+async function fetchJson(url) {
+    try {
+        const res = await fetch(url, { headers: { Accept: "application/json" }, redirect: "error" });
+        if (!res.ok)
+            return null;
+        return JSON.parse(await res.text());
+    }
+    catch {
+        return null;
+    }
+}
+async function tryDiscoverFromIssuer(issuer) {
+    for (const path of ["/.well-known/oauth-authorization-server", "/.well-known/openid-configuration"]) {
+        const meta = await fetchJson(issuer.replace(/\/+$/, "") + path);
+        if (meta?.authorization_endpoint && meta?.token_endpoint) {
+            return {
+                authorizationUrl: meta.authorization_endpoint,
+                tokenUrl: meta.token_endpoint,
+                registrationUrl: meta.registration_endpoint ?? null,
+                suggestedScope: meta.scopes_supported?.join(" ") ?? null,
+            };
+        }
+    }
+    return null;
+}
+function parseBearerResourceMetadata(wwwAuthenticate) {
+    if (!wwwAuthenticate)
+        return { resourceMetadataUrl: null, scope: null };
+    const bearerMatch = wwwAuthenticate.match(/Bearer\s+(.+)/i);
+    if (!bearerMatch?.[1])
+        return { resourceMetadataUrl: null, scope: null };
+    const params = {};
+    const pairs = bearerMatch[1].match(/([a-zA-Z_]+)\s*=\s*("[^"]*"|[^,\s]+)/g) ?? [];
+    for (const pair of pairs) {
+        const eqIdx = pair.indexOf("=");
+        const key = pair.slice(0, eqIdx).trim().toLowerCase();
+        const val = pair.slice(eqIdx + 1).trim().replace(/^"|"$/g, "");
+        params[key] = val;
+    }
+    return { resourceMetadataUrl: params["resource_metadata"] ?? null, scope: params["scope"] ?? null };
+}
+async function probeServerChallenge(url) {
+    try {
+        const res = await fetch(url, { method: "GET", headers: { Accept: "application/json" }, redirect: "error" }).catch(() => null);
+        return parseBearerResourceMetadata(res?.headers.get("www-authenticate") ?? null);
+    }
+    catch {
+        return { resourceMetadataUrl: null, scope: null };
+    }
+}
+async function tryResourceMetadata(url) {
+    const rm = await fetchJson(url);
+    return rm?.authorization_servers?.[0] ?? null;
+}
+export async function discoverOAuthEndpoints(srv) {
+    if (srv.oauthAuthorizationUrl && srv.oauthTokenUrl) {
+        return { authorizationUrl: srv.oauthAuthorizationUrl, tokenUrl: srv.oauthTokenUrl, registrationUrl: null, suggestedScope: null };
+    }
+    const issuer = srv.oauthIssuerUrl ?? null;
+    if (issuer) {
+        const found = await tryDiscoverFromIssuer(issuer);
+        if (found)
+            return found;
+    }
+    if (srv.url) {
+        const parsed = new URL(srv.url);
+        const origin = parsed.origin;
+        const path = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
+        // Step 1: probe the MCP server URL for WWW-Authenticate: Bearer resource_metadata=...
+        const challenge = await probeServerChallenge(srv.url);
+        const rmCandidates = [
+            ...(challenge.resourceMetadataUrl ? [challenge.resourceMetadataUrl] : []),
+            ...(path ? [`${origin}/.well-known/oauth-protected-resource${path}`] : []),
+            `${origin}/.well-known/oauth-protected-resource`,
+        ];
+        for (const rmUrl of rmCandidates) {
+            const asIssuer = await tryResourceMetadata(rmUrl);
+            if (asIssuer) {
+                const found = await tryDiscoverFromIssuer(asIssuer);
+                if (found)
+                    return { ...found, suggestedScope: found.suggestedScope ?? challenge.scope };
+            }
+        }
+        // Step 2: try AS discovery directly on origin
+        const fromOrigin = await tryDiscoverFromIssuer(origin);
+        if (fromOrigin)
+            return fromOrigin;
+    }
+    throw new Error(`Could not discover OAuth endpoints for "${srv.name}". ` +
+        "Provide --oauth-issuer <url> or --oauth-auth-url + --oauth-token-url when adding.");
+}
+async function registerDynamicClient(registrationUrl, redirectUri) {
+    const res = await fetch(registrationUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify({
+            client_name: "Scira CLI",
+            redirect_uris: [redirectUri],
+            grant_types: ["authorization_code", "refresh_token"],
+            response_types: ["code"],
+            token_endpoint_auth_method: "none",
+        }),
+    });
+    if (!res.ok)
+        throw new Error("Dynamic client registration failed — provide --oauth-client-id manually");
+    const data = JSON.parse(await res.text());
+    if (!data.client_id)
+        throw new Error("Dynamic registration did not return client_id — provide --oauth-client-id manually");
+    return { clientId: data.client_id, clientSecret: data.client_secret };
+}
+function patchClientId(mcp, name, clientId, clientSecret) {
+    return {
+        ...mcp,
+        servers: mcp.servers.map((s) => s.name === name ? { ...s, oauthClientId: clientId, ...(clientSecret ? { oauthClientSecret: clientSecret } : {}) } : s),
+    };
+}
+function openBrowser(url) {
+    const cmd = process.platform === "darwin" ? `open "${url}"` :
+        process.platform === "win32" ? `start "" "${url}"` :
+            `xdg-open "${url}"`;
+    exec(cmd, () => { });
+}
+function waitForCallback(port, timeoutMs = 120_000) {
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const u = new URL(req.url ?? "/", `http://localhost:${port}`);
+            const code = u.searchParams.get("code");
+            const state = u.searchParams.get("state");
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end("<html><body><h2>OAuth connected — you can close this tab.</h2></body></html>");
+            server.close();
+            if (code && state)
+                resolve({ code, state });
+            else
+                reject(new Error("OAuth callback missing code or state"));
+        });
+        server.listen(port, "127.0.0.1");
+        const timer = setTimeout(() => {
+            server.close();
+            reject(new Error("OAuth flow timed out (2 min). Run `scira mcp oauth <name>` to retry."));
+        }, timeoutMs);
+        server.once("close", () => clearTimeout(timer));
+    });
+}
+async function exchangeCode(opts) {
+    const body = new URLSearchParams({
+        grant_type: "authorization_code",
+        code: opts.code,
+        redirect_uri: opts.redirectUri,
+        client_id: opts.clientId,
+        code_verifier: opts.verifier,
+    });
+    if (opts.clientSecret)
+        body.set("client_secret", opts.clientSecret);
+    const res = await fetch(opts.tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+        body,
+    });
+    const data = JSON.parse(await res.text());
+    if (!res.ok || !data.access_token) {
+        throw new Error(data.error_description ?? data.error ?? "Token exchange failed");
+    }
+    return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token,
+        expiresAt: data.expires_in ? Date.now() + data.expires_in * 1000 : undefined,
+    };
+}
+async function refreshToken(opts) {
+    const body = new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: opts.refreshToken,
+        client_id: opts.clientId,
+    });
+    if (opts.clientSecret)
+        body.set("client_secret", opts.clientSecret);
+    const res = await fetch(opts.tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+        body,
+    });
+    const data = JSON.parse(await res.text());
+    if (!res.ok || !data.access_token) {
+        throw new Error(data.error_description ?? data.error ?? "Token refresh failed");
+    }
+    return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token ?? opts.refreshToken,
+        expiresAt: data.expires_in ? Date.now() + data.expires_in * 1000 : undefined,
+    };
+}
+function patchTokens(mcp, name, tokens) {
+    return {
+        ...mcp,
+        servers: mcp.servers.map((s) => s.name === name
+            ? { ...s, oauthAccessToken: tokens.accessToken, oauthRefreshToken: tokens.refreshToken, oauthTokenExpiresAt: tokens.expiresAt }
+            : s),
+    };
+}
+export async function runOAuthFlow(srv, config) {
+    const port = 49152 + Math.floor(Math.random() * 16383);
+    const redirectUri = `http://localhost:${port}/callback`;
+    const endpoints = await discoverOAuthEndpoints(srv);
+    const { authorizationUrl, tokenUrl } = endpoints;
+    let clientId = srv.oauthClientId;
+    let clientSecret = srv.oauthClientSecret;
+    let updatedConfig = config;
+    if (!clientId) {
+        if (!endpoints.registrationUrl) {
+            throw new Error(`"${srv.name}" does not support dynamic client registration. ` +
+                "Re-add with --oauth-client-id <id> (see the provider's app/developer settings).");
+        }
+        process.stdout.write(`Registering Scira CLI with ${srv.name} OAuth server…\n`);
+        const reg = await registerDynamicClient(endpoints.registrationUrl, redirectUri);
+        clientId = reg.clientId;
+        clientSecret = reg.clientSecret ?? clientSecret;
+        const patchedMcp = patchClientId(config.mcp, srv.name, clientId, clientSecret);
+        await saveGlobalMcpConfig(patchedMcp);
+        updatedConfig = { ...config, mcp: patchedMcp };
+        process.stdout.write(`Registered client_id: ${clientId}\n`);
+    }
+    const verifier = createVerifier();
+    const challenge = createChallenge(verifier);
+    const state = toBase64Url(randomBytes(16));
+    const scope = srv.oauthScopes ?? endpoints.suggestedScope ?? undefined;
+    const params = new URLSearchParams({
+        response_type: "code",
+        client_id: clientId,
+        redirect_uri: redirectUri,
+        code_challenge: challenge,
+        code_challenge_method: "S256",
+        state,
+    });
+    if (scope)
+        params.set("scope", scope);
+    const fullUrl = `${authorizationUrl}?${params}`;
+    process.stdout.write(`\nOpening browser for OAuth…\nIf it didn't open, paste this URL:\n${fullUrl}\n\nWaiting for callback on ${redirectUri} …\n`);
+    openBrowser(fullUrl);
+    const { code, state: returnedState } = await waitForCallback(port);
+    if (returnedState !== state)
+        throw new Error("OAuth state mismatch — possible CSRF");
+    const tokens = await exchangeCode({ tokenUrl, code, verifier, redirectUri, clientId, clientSecret });
+    await saveGlobalMcpConfig(patchTokens(updatedConfig.mcp, srv.name, tokens));
+    process.stdout.write(`\nOAuth connected for "${srv.name}". Token saved to ~/.scira/config.json.\n`);
+}
+export async function resolveOAuthToken(srv, config) {
+    if (srv.oauthAccessToken && (!srv.oauthTokenExpiresAt || srv.oauthTokenExpiresAt - Date.now() > 60_000)) {
+        return srv.oauthAccessToken;
+    }
+    if (srv.oauthRefreshToken && srv.oauthClientId) {
+        const { tokenUrl } = await discoverOAuthEndpoints(srv);
+        const tokens = await refreshToken({
+            tokenUrl,
+            refreshToken: srv.oauthRefreshToken,
+            clientId: srv.oauthClientId,
+            clientSecret: srv.oauthClientSecret,
+        });
+        await saveGlobalMcpConfig(patchTokens(config.mcp, srv.name, tokens));
+        return tokens.accessToken;
+    }
+    throw new Error(`OAuth session expired for "${srv.name}". Run: scira mcp oauth ${srv.name}`);
+}

package/dist/tools/open-url.js

@@ -0,0 +1,99 @@
+import process from "node:process";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Readability } from "@mozilla/readability";
+import { JSDOM } from "jsdom";
+import { Exa } from "exa-js";
+import Parallel from "parallel-web";
+import { Firecrawl } from "@mendable/firecrawl-js";
+import { requireSearchProvider } from "../providers/llm/readiness.js";
+// ── lazy singleton clients ──
+let _exa;
+let _parallel;
+let _firecrawl;
+function getExa() {
+    requireSearchProvider("exa");
+    if (!_exa)
+        _exa = new Exa(process.env.EXA_API_KEY);
+    return _exa;
+}
+function getParallel() {
+    requireSearchProvider("parallel");
+    if (!_parallel)
+        _parallel = new Parallel({ apiKey: process.env.PARALLEL_API_KEY });
+    return _parallel;
+}
+function getFirecrawl() {
+    requireSearchProvider("firecrawl");
+    if (!_firecrawl)
+        _firecrawl = new Firecrawl({ apiKey: process.env.FIRECRAWL_API_KEY });
+    return _firecrawl;
+}
+// ── provider extractors ──
+async function parallelExtract(url, config) {
+    const parallel = getParallel();
+    const response = await parallel.extract({
+        urls: [url],
+        max_chars_total: config.search.maxCharsTotal ?? 10000,
+        advanced_settings: { full_content: true }
+    });
+    const result = response.results?.[0];
+    if (!result)
+        return undefined;
+    const text = (result.full_content ?? "") || (result.excerpts ?? []).join("\n\n");
+    if (!text.trim())
+        return undefined;
+    return { title: result.title ?? url, text: text.trim() };
+}
+async function exaExtract(url) {
+    const exa = getExa();
+    const response = await exa.getContents([url], { text: true });
+    const result = response.results?.[0];
+    if (!result?.text?.trim())
+        return undefined;
+    return { title: result.title ?? url, text: result.text.trim() };
+}
+async function firecrawlScrape(url) {
+    const firecrawl = getFirecrawl();
+    const doc = await firecrawl.scrape(url, { formats: ["markdown"] });
+    const text = doc.markdown ?? doc.summary ?? "";
+    if (!text.trim())
+        return undefined;
+    return { title: doc.metadata?.title ?? url, text: text.trim() };
+}
+const EXTRACTORS = {
+    parallel: (url, config) => parallelExtract(url, config),
+    exa: (url) => exaExtract(url),
+    firecrawl: (url) => firecrawlScrape(url)
+};
+// ── raw fetch + readability fallback ──
+async function rawFetch(url) {
+    const response = await fetch(url, { headers: { "user-agent": "scira-cli/0.1" } });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+    }
+    const html = await response.text();
+    const dom = new JSDOM(html, { url });
+    const article = new Readability(dom.window.document).parse();
+    return {
+        title: article?.title ?? dom.window.document.title ?? url,
+        text: article?.textContent?.trim() || dom.window.document.body.textContent?.trim() || ""
+    };
+}
+export async function openUrl(url, config) {
+    const provider = config.search.provider;
+    try {
+        const page = await EXTRACTORS[provider](url, config);
+        if (page)
+            return page;
+    }
+    catch {
+        // fall through to raw fetch
+    }
+    return rawFetch(url);
+}
+export async function writeSnapshot(snapshotsDir, sourceId, page) {
+    const path = join(snapshotsDir, `${sourceId}.md`);
+    await writeFile(path, `# ${page.title}\n\n${page.text}\n`);
+    return path;
+}