@tavily/cli 0.0.0-stage → 1.0.0

package/dist/client-factory-LWJMZVKT.js

@@ -0,0 +1,338 @@
+#!/usr/bin/env node
+import {
+  getApiBaseUrl,
+  getHumanId,
+  isOauthToken
+} from "./chunk-AERAIFZU.js";
+import {
+  isObject,
+  messageOf
+} from "./chunk-5JXZZSLS.js";
+
+// src/core/mcp-client.ts
+import { TavilyRequestError } from "@tavily/core";
+
+// src/core/sse.ts
+async function* sseDataLines(chunks) {
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  for await (const chunk of chunks) {
+    buffer += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const payload2 = dataPayload(line);
+      if (payload2 !== void 0) yield payload2;
+    }
+  }
+  buffer += decoder.decode();
+  const payload = dataPayload(buffer);
+  if (payload !== void 0) yield payload;
+}
+function dataPayload(rawLine) {
+  const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+  if (!line.startsWith("data:")) return void 0;
+  const rest = line.slice(5);
+  return rest.startsWith(" ") ? rest.slice(1) : rest;
+}
+
+// src/core/mcp-client.ts
+var MCP_URL = "https://mcp.tavily.com/mcp";
+var TIMEOUT_MS = 18e4;
+function raiseIfApiError(parsed, isError) {
+  if (!isObject(parsed) || !("error" in parsed)) return;
+  if (!isError && typeof parsed.status === "string") return;
+  const detail = parsed.detail;
+  const message = isObject(detail) && typeof detail.error === "string" ? detail.error : String(parsed.error);
+  throw new TavilyRequestError({
+    status: typeof parsed.status === "number" ? parsed.status : 0,
+    body: parsed,
+    message
+  });
+}
+function rpcError(error) {
+  return new Error(
+    isObject(error) && typeof error.message === "string" ? error.message : JSON.stringify(error)
+  );
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function unwrapResult(data) {
+  const result = isObject(data.result) ? data.result : {};
+  const isError = result.isError === true;
+  const structured = result.structuredContent;
+  if (structured && (typeof structured === "object" || typeof structured === "string")) {
+    const parsed = typeof structured === "string" ? parseJson(structured) : structured;
+    if (parsed === void 0) {
+      throw new TavilyRequestError({
+        status: 0,
+        body: structured,
+        message: "The Tavily MCP server returned malformed structuredContent (not valid JSON)."
+      });
+    }
+    raiseIfApiError(parsed, isError);
+    return parsed;
+  }
+  const content = result.content;
+  if (Array.isArray(content) && content.length > 0) {
+    const first = content[0];
+    const textVal = isObject(first) && typeof first.text === "string" ? first.text : "";
+    const parsed = parseJson(textVal);
+    if (parsed === void 0) return { raw: textVal };
+    raiseIfApiError(parsed, isError);
+    return parsed;
+  }
+  return result;
+}
+function createMcpClient(opts) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const headers = {
+    Authorization: `Bearer ${opts.token}`,
+    "Content-Type": "application/json",
+    Accept: "application/json, text/event-stream",
+    "x-client-source": "tavily-cli",
+    ...opts.clientName ? { "x-client-name": opts.clientName } : {},
+    // mcp-session-id stops the remote MCP from generating its own session; X-Session-Id is
+    // forwarded to the Tavily API for session attribution.
+    "mcp-session-id": opts.sessionId,
+    "X-Session-Id": opts.sessionId,
+    ...opts.humanId ? { "X-Human-Id": opts.humanId } : {}
+  };
+  async function call(toolName, args) {
+    const requestBody = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: { name: toolName, arguments: args }
+    };
+    let status;
+    let text;
+    try {
+      const resp = await fetchImpl(MCP_URL, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+        redirect: "manual"
+      });
+      status = resp.status;
+      text = await resp.text();
+    } catch (e) {
+      throw new Error(`Could not reach the Tavily MCP server: ${messageOf(e)}`);
+    }
+    if (status < 200 || status >= 300) {
+      throw new TavilyRequestError({
+        status,
+        body: text,
+        message: `MCP request failed with status ${status}`
+      });
+    }
+    const payload = text.split("\n").map(dataPayload).find((p) => p !== void 0);
+    const message = parseJson(payload ?? text);
+    if (!isObject(message)) {
+      if (payload === void 0) throw new Error(`Unexpected MCP response: ${text.slice(0, 500)}`);
+      throw new TavilyRequestError({
+        status: 0,
+        body: payload,
+        message: "The Tavily MCP server returned a malformed SSE message (not a JSON object)."
+      });
+    }
+    if ("error" in message) throw rpcError(message.error);
+    return unwrapResult(message);
+  }
+  return {
+    search: (body) => call("tavily_search", body),
+    extract: (body) => call("tavily_extract", body),
+    crawl: (body) => call("tavily_crawl", body),
+    map: (body) => call("tavily_map", body),
+    research: (body) => call("tavily_research", body),
+    researchStream: () => Promise.reject(
+      new TavilyRequestError({
+        status: 0,
+        body: null,
+        message: "Streaming is not available with OAuth credentials; use an API key."
+      })
+    ),
+    getResearch: (requestId) => call("tavily_get_research", { request_id: requestId })
+  };
+}
+
+// src/core/session.ts
+import { randomUUID } from "crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import path from "path";
+function newId() {
+  return randomUUID().replace(/-/g, "");
+}
+function parsePid(text) {
+  const trimmed = text.trim();
+  return /^\d+$/.test(trimmed) ? Number(trimmed) : null;
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function grandparentPid(ppid, host, readFile = (p) => readFileSync(p, "utf8")) {
+  try {
+    if (host.platform === "linux") {
+      const stat = readFile(`/proc/${ppid}/stat`);
+      const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/);
+      return parsePid(fields[1] ?? "");
+    }
+    const [cmd, args] = host.platform === "win32" ? [
+      "powershell",
+      [
+        "-NoProfile",
+        "-Command",
+        `(Get-CimInstance Win32_Process -Filter 'ProcessId=${ppid}').ParentProcessId`
+      ]
+    ] : ["ps", ["-o", "ppid=", "-p", String(ppid)]];
+    const res = host.exec.run(cmd, args, { timeoutMs: 2e3 });
+    return res.ok ? parsePid(res.stdout) : null;
+  } catch {
+    return null;
+  }
+}
+function readSessions(file) {
+  try {
+    const data = JSON.parse(readFileSync(file, "utf8"));
+    return isObject(data) ? data : {};
+  } catch {
+    return {};
+  }
+}
+function writeSessions(configDir, file, sessions) {
+  mkdirSync(configDir, { recursive: true, mode: 448 });
+  writeFileSync(file, `${JSON.stringify(sessions, null, 2)}
+`, { mode: 384 });
+}
+function resolveSessionId(opts) {
+  const file = path.join(opts.configDir, "session.json");
+  const sessions = readSessions(file);
+  const ppid = String(opts.ppid);
+  const byParent = sessions[ppid];
+  if (byParent !== void 0) return byParent;
+  const gppid = opts.gppid();
+  const byGrandparent = gppid === null ? void 0 : sessions[String(gppid)];
+  if (gppid !== null && byGrandparent !== void 0 && opts.pidAlive(gppid)) return byGrandparent;
+  const alive = {};
+  for (const [pid, sid] of Object.entries(sessions)) {
+    if (opts.pidAlive(Number(pid))) alive[pid] = sid;
+  }
+  const id = newId();
+  alive[ppid] = id;
+  if (gppid !== null) alive[String(gppid)] = id;
+  writeSessions(opts.configDir, file, alive);
+  return id;
+}
+var cached;
+function getSessionId(host) {
+  if (cached === void 0) {
+    try {
+      cached = resolveSessionId({
+        configDir: path.join(host.home, ".tavily"),
+        ppid: process.ppid,
+        gppid: () => grandparentPid(process.ppid, host),
+        pidAlive
+      });
+    } catch {
+      cached = newId();
+    }
+  }
+  return cached;
+}
+
+// src/core/tavily-client.ts
+import { createTransport } from "@tavily/core";
+var DEFAULT_HTTP_TIMEOUT = 60;
+var SEARCH_MAX_TIMEOUT = 120;
+function createTavilyClient(opts) {
+  const transport = opts.transport ?? createTransport({
+    ...opts.apiKey ? { apiKey: opts.apiKey } : {},
+    clientSource: opts.apiKey ? "tavily-cli" : "tavily-cli-keyless",
+    ...opts.apiBaseUrl ? { apiBaseURL: opts.apiBaseUrl } : {},
+    sessionId: opts.sessionId,
+    ...opts.humanId ? { humanId: opts.humanId } : {},
+    ...opts.clientName ? { clientName: opts.clientName } : {},
+    ...opts.projectId ? { projectId: opts.projectId } : {},
+    ...opts.orgId ? { orgId: opts.orgId } : {}
+  });
+  const withTimeout = (body, defaultTimeout) => {
+    const timeout = typeof body.timeout === "number" ? body.timeout : defaultTimeout;
+    return { body: { ...body, timeout }, timeout };
+  };
+  return {
+    async search(body) {
+      const timeout = typeof body.timeout === "number" ? body.timeout : DEFAULT_HTTP_TIMEOUT;
+      return await transport.post("search", body, {
+        timeoutSeconds: Math.min(timeout, SEARCH_MAX_TIMEOUT)
+      });
+    },
+    async extract(body) {
+      const r = withTimeout(body, 30);
+      return await transport.post("extract", r.body, { timeoutSeconds: r.timeout });
+    },
+    async crawl(body) {
+      const r = withTimeout(body, 150);
+      return await transport.post("crawl", r.body, { timeoutSeconds: r.timeout });
+    },
+    async map(body) {
+      const r = withTimeout(body, 150);
+      return await transport.post("map", r.body, { timeoutSeconds: r.timeout });
+    },
+    async research(body) {
+      return await transport.post(
+        "research",
+        { stream: false, citation_format: "numbered", ...body },
+        {}
+      );
+    },
+    async researchStream(body) {
+      const chunks = await transport.stream(
+        "research",
+        { citation_format: "numbered", ...body, stream: true },
+        {}
+      );
+      return sseDataLines(chunks);
+    },
+    async getResearch(requestId) {
+      return await transport.get(`research/${encodeURIComponent(requestId)}`, {
+        timeoutSeconds: DEFAULT_HTTP_TIMEOUT
+      });
+    }
+  };
+}
+
+// src/core/client-factory.ts
+function buildClient(key, clientName, host) {
+  const humanId = getHumanId(host);
+  const ids = {
+    sessionId: getSessionId(host),
+    ...humanId ? { humanId } : {},
+    ...clientName ? { clientName } : {}
+  };
+  if (key && isOauthToken(key)) {
+    return createMcpClient({ token: key, ...ids, fetchImpl: host.fetch });
+  }
+  const apiBaseUrl = getApiBaseUrl(host);
+  const { TAVILY_PROJECT: projectId, TAVILY_ORG_ID: orgId } = host.env;
+  return createTavilyClient({
+    ...ids,
+    apiKey: key ?? void 0,
+    ...apiBaseUrl ? { apiBaseUrl } : {},
+    ...projectId ? { projectId } : {},
+    ...orgId ? { orgId } : {}
+  });
+}
+export {
+  buildClient
+};

package/dist/defaults-344GEHCS.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import {
+  resolveJson
+} from "./chunk-IRCF6F3S.js";
+import {
+  colors,
+  out
+} from "./chunk-E4N27QWM.js";
+import {
+  isObject
+} from "./chunk-5JXZZSLS.js";
+
+// src/commands/defaults.ts
+import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
+
+// src/core/agent-defaults.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { InvalidArgumentError } from "commander";
+var CLAUDE_DENIED_TOOLS = ["WebSearch", "WebFetch"];
+var CODEX_WEB_SEARCH_LINE = 'web_search = "disabled"';
+var TOML_TABLE_HEADER = /^\s*\[/;
+var TOML_WEB_SEARCH = /^\s*web_search\s*=/;
+var TOML_WEB_SEARCH_DISABLED = /^\s*web_search\s*=\s*["']disabled["']\s*(#.*)?$/;
+function expandUser(p, home) {
+  return p === "~" || p.startsWith("~/") ? join(home, p.slice(1)) : p;
+}
+function configRoot(envVar, dirName, { home, env }) {
+  const raw = env[envVar];
+  return raw ? resolve(expandUser(raw, home)) : join(home, dirName);
+}
+function claudeSettingsPath(ctx) {
+  if (ctx.project) return join(ctx.cwd, ".claude", "settings.local.json");
+  return join(configRoot("CLAUDE_CONFIG_DIR", ".claude", ctx), "settings.json");
+}
+function codexConfigPath(ctx) {
+  if (ctx.project) return join(ctx.cwd, ".codex", "config.toml");
+  return join(configRoot("CODEX_HOME", ".codex", ctx), "config.toml");
+}
+function loadClaudeSettings(path) {
+  if (!existsSync(path)) return {};
+  const text = readFileSync(path, "utf8");
+  if (!text.trim()) return {};
+  let settings;
+  try {
+    settings = JSON.parse(text);
+  } catch (e) {
+    throw new InvalidArgumentError(`${path} is not valid JSON: ${e.message}`);
+  }
+  if (!isObject(settings)) throw new InvalidArgumentError(`${path} must contain a JSON object.`);
+  return settings;
+}
+function denyList(settings, path) {
+  settings.permissions ??= {};
+  const permissions = settings.permissions;
+  if (!isObject(permissions))
+    throw new InvalidArgumentError(`"permissions" in ${path} must be an object.`);
+  permissions.deny ??= [];
+  const deny = permissions.deny;
+  if (!Array.isArray(deny))
+    throw new InvalidArgumentError(`"permissions.deny" in ${path} must be an array.`);
+  return deny;
+}
+function writeClaudeSettings(path, settings) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+}
+function setClaudeDefault(path) {
+  const settings = loadClaudeSettings(path);
+  const deny = denyList(settings, path);
+  const missing = CLAUDE_DENIED_TOOLS.filter((tool) => !deny.includes(tool));
+  if (missing.length === 0) return false;
+  deny.push(...missing);
+  writeClaudeSettings(path, settings);
+  return true;
+}
+function unsetClaudeDefault(path) {
+  const settings = loadClaudeSettings(path);
+  const permissions = settings.permissions;
+  if (!isObject(permissions) || !Array.isArray(permissions.deny)) return false;
+  const deny = permissions.deny;
+  const kept = deny.filter((tool) => !CLAUDE_DENIED_TOOLS.includes(tool));
+  if (kept.length === deny.length) return false;
+  if (kept.length > 0) {
+    permissions.deny = kept;
+  } else {
+    delete permissions.deny;
+    if (Object.keys(permissions).length === 0) delete settings.permissions;
+  }
+  writeClaudeSettings(path, settings);
+  return true;
+}
+var splitLines = (text) => text.match(/[^\n]*\n|[^\n]+/g) ?? [];
+var stripEol = (line) => line.replace(/\r?\n$/, "");
+function topLevelEnd(lines) {
+  const index = lines.findIndex((line) => TOML_TABLE_HEADER.test(line));
+  return index === -1 ? lines.length : index;
+}
+function setCodexDefault(path) {
+  const lines = splitLines(existsSync(path) ? readFileSync(path, "utf8") : "");
+  const end = topLevelEnd(lines);
+  const index = lines.slice(0, end).findIndex((line) => TOML_WEB_SEARCH.test(line));
+  if (index === -1) {
+    lines.unshift(`${CODEX_WEB_SEARCH_LINE}
+`);
+  } else if (TOML_WEB_SEARCH_DISABLED.test(stripEol(lines[index]))) {
+    return false;
+  } else {
+    lines[index] = `${CODEX_WEB_SEARCH_LINE}
+`;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, lines.join(""), "utf8");
+  return true;
+}
+function unsetCodexDefault(path) {
+  if (!existsSync(path)) return false;
+  const lines = splitLines(readFileSync(path, "utf8"));
+  const end = topLevelEnd(lines);
+  const kept = lines.filter(
+    (line, index) => index >= end || !TOML_WEB_SEARCH_DISABLED.test(stripEol(line))
+  );
+  if (kept.length === lines.length) return false;
+  writeFileSync(path, kept.join(""), "utf8");
+  return true;
+}
+
+// src/commands/defaults.ts
+var TARGETS = {
+  claude: { label: "Claude Code", path: claudeSettingsPath },
+  codex: { label: "Codex", path: codexConfigPath }
+};
+var SET = {
+  verb: "Make Tavily the default web tool",
+  actions: { claude: setClaudeDefault, codex: setCodexDefault },
+  changedMessage: "built-in web search disabled",
+  unchangedMessage: "built-in web search already disabled",
+  codexNote: "Codex only reads project config in projects you have marked as trusted."
+};
+var UNSET = {
+  verb: "Restore built-in web search",
+  actions: { claude: unsetClaudeDefault, codex: unsetCodexDefault },
+  changedMessage: "built-in web search restored",
+  unchangedMessage: "nothing to undo"
+};
+async function selectTargets(opts, mode, json, cmd, host) {
+  if (opts.claude || opts.codex) {
+    return ["claude", "codex"].filter((agent) => opts[agent]);
+  }
+  if (json || !host.stdinIsTTY) {
+    return cmd.error("error: Pass --claude and/or --codex in non-interactive runs.");
+  }
+  const selected = [];
+  for (const agent of ["claude", "codex"]) {
+    const scope = opts.project ? " in this project" : "";
+    if (await host.prompt.confirm(`${mode.verb} for ${TARGETS[agent].label}${scope}?`)) {
+      selected.push(agent);
+    }
+  }
+  return selected;
+}
+async function execute(opts, cmd, host, mode) {
+  const json = resolveJson(cmd);
+  const project = opts.project === true;
+  const targets = await selectTargets(opts, mode, json, cmd, host);
+  const results = [];
+  try {
+    for (const agent of targets) {
+      const { label, path: pathFor } = TARGETS[agent];
+      const path = pathFor({ ...host, project });
+      const changed = mode.actions[agent](path);
+      results.push({ agent, label, scope: project ? "project" : "global", path, changed });
+    }
+  } catch (e) {
+    if (e instanceof InvalidArgumentError2) cmd.error(`error: ${e.message}`);
+    throw e;
+  }
+  if (json) {
+    out(JSON.stringify({ ok: true, results }));
+    return;
+  }
+  if (results.length === 0) {
+    out(`  ${colors.dim("Nothing selected.")}`);
+    return;
+  }
+  for (const r of results) {
+    const message = r.changed ? mode.changedMessage : mode.unchangedMessage;
+    const mark = r.changed ? colors.green("\u2713") : colors.dim("\u2022");
+    out(`  ${mark} ${r.label}: ${message} ${colors.dim(`(${r.path})`)}`);
+  }
+  if (results.some((r) => r.changed)) {
+    out(`  ${colors.dim("Restart the agent for the change to take effect.")}`);
+  }
+  if (project && mode.codexNote && results.some((r) => r.agent === "codex" && r.changed)) {
+    out(`  ${colors.dim(mode.codexNote)}`);
+  }
+}
+var runSetDefault = (opts, cmd, host) => execute(opts, cmd, host, SET);
+var runUnsetDefault = (opts, cmd, host) => execute(opts, cmd, host, UNSET);
+export {
+  runSetDefault,
+  runUnsetDefault
+};

package/dist/extract-Q5VLDRON.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import {
+  definedSnake,
+  echoPages,
+  emitIfRequested,
+  footer,
+  invoke,
+  list,
+  resolveOutput
+} from "./chunk-KQFC5TMG.js";
+import "./chunk-U3B7BNFI.js";
+import "./chunk-K76OUMXM.js";
+import {
+  domainOf,
+  hostOf,
+  isTerminal,
+  plain,
+  renderMarkdown,
+  sanitizeControl
+} from "./chunk-QHWWSCVM.js";
+import "./chunk-AERAIFZU.js";
+import {
+  resolveJson
+} from "./chunk-IRCF6F3S.js";
+import {
+  colors,
+  out
+} from "./chunk-E4N27QWM.js";
+import "./chunk-5JXZZSLS.js";
+
+// src/ui/render/extract.ts
+async function printExtractResults(data, opts) {
+  if (emitIfRequested(data, opts)) return;
+  const results = list(data.results);
+  const failed = list(data.failed_results);
+  if (!isTerminal(process.stdout)) {
+    echoPages(results);
+    for (const f of failed) out(`Failed: ${plain(f.url)}: ${plain(f.error)}`);
+    return;
+  }
+  for (const r of results) {
+    const url = r.url ?? "";
+    const raw = r.raw_content ?? "";
+    out();
+    out(`  ${colors.bold(colors.aqua(sanitizeControl(url)))}`);
+    out(
+      colors.dim(`  ${sanitizeControl(hostOf(url))} (${raw.length.toLocaleString("en-US")} chars)`)
+    );
+    out();
+    out(raw ? await renderMarkdown(raw.slice(0, 3e3)) : `  ${colors.dim("No content")}`);
+    out();
+  }
+  if (failed.length > 0) {
+    out(colors.yellow("Failed extractions:"));
+    for (const f of failed) {
+      out(`  ${colors.pink("x ")}${sanitizeControl(f.url)}: ${sanitizeControl(f.error)}`);
+    }
+  }
+  footer(results.length, `extracted, ${failed.length} failed`, data.response_time);
+}
+
+// src/commands/extract.ts
+var MAX_URLS = 20;
+async function run(urls, opts, cmd, host) {
+  const json = resolveJson(cmd);
+  if (urls.length > MAX_URLS) cmd.error(`error: Maximum ${MAX_URLS} URLs per request.`);
+  const outputFile = resolveOutput(opts.output, "extract", domainOf(urls[0] ?? ""));
+  const body = {
+    urls,
+    ...definedSnake(opts, [
+      "query",
+      "chunksPerSource",
+      "extractDepth",
+      "format",
+      "includeImages",
+      "timeout"
+    ])
+  };
+  const label = `Extracting ${urls.length} URL${urls.length > 1 ? "s" : ""}...`;
+  const response = await invoke(
+    cmd,
+    host,
+    { label, keyed: false, clientName: opts.clientName },
+    (client) => client.extract(body)
+  );
+  await printExtractResults(response, { json, outputFile });
+}
+export {
+  run
+};