@tavily/cli 0.0.0-stage → 1.0.0

package/dist/chunk-PZGMUDV2.js

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+import {
+  AGENT_NAMES
+} from "./chunk-HQ7QBZ5H.js";
+import {
+  VERSION
+} from "./chunk-SPBOEASO.js";
+import {
+  addClientNameOption,
+  addCommonOptions,
+  addOutputOption,
+  parseNumberArg,
+  resolveJson
+} from "./chunk-IRCF6F3S.js";
+import {
+  out
+} from "./chunk-E4N27QWM.js";
+import {
+  ExitError
+} from "./chunk-5JXZZSLS.js";
+
+// src/host.ts
+import { spawn } from "child_process";
+import { homedir } from "os";
+
+// src/ui/prompts.ts
+import * as clack from "@clack/prompts";
+var output = process.stderr;
+function answered(value) {
+  if (clack.isCancel(value)) {
+    clack.cancel("Setup cancelled.", { output });
+    throw new ExitError(1);
+  }
+  return value;
+}
+var options = (choices) => choices;
+var clackPrompter = {
+  confirm: async (message, initial = true) => answered(await clack.confirm({ message, initialValue: initial, output })),
+  select: async (message, choices, initial) => answered(
+    await clack.select({
+      message,
+      options: options(choices),
+      ...initial !== void 0 && { initialValue: initial },
+      output
+    })
+  ),
+  multiselect: async (message, choices, initial) => answered(
+    await clack.multiselect({
+      message,
+      options: options(choices),
+      initialValues: initial,
+      required: false,
+      output
+    })
+  ),
+  password: async (message) => answered(
+    await clack.password({
+      message,
+      validate: (value) => value?.trim() ? void 0 : "Enter a key",
+      output
+    })
+  ).trim()
+};
+
+// src/util/exec.ts
+import {
+  execFile,
+  spawnSync
+} from "child_process";
+import { accessSync, constants, existsSync, statSync } from "fs";
+import path from "path";
+var MAX_BUFFER = 16 * 1024 * 1024;
+var SHIM = /\.(cmd|bat)$/i;
+function whichOnPath(name, env, win) {
+  const exts = win ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";") : [""];
+  for (const dir of (env.PATH ?? "").split(path.delimiter).filter(Boolean)) {
+    if (dir.replace(/\\/g, "/").includes("/_npx/")) continue;
+    for (const ext of exts) {
+      const candidate = path.join(dir, name + ext);
+      try {
+        if (!statSync(candidate).isFile()) continue;
+        accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function fromSync(r) {
+  return {
+    status: r.status,
+    signal: r.signal,
+    error: r.error,
+    timedOut: r.error?.code === "ETIMEDOUT",
+    stdout: r.stdout ?? "",
+    stderr: r.stderr ?? ""
+  };
+}
+function fromAsync(e, stdout, stderr) {
+  const code = e?.code;
+  return {
+    status: !e ? 0 : typeof code === "number" ? code : null,
+    signal: e?.signal ?? null,
+    error: typeof code === "string" ? e : void 0,
+    timedOut: e?.killed === true && typeof code !== "string",
+    stdout: stdout ?? "",
+    stderr: stderr ?? ""
+  };
+}
+function result(o) {
+  const failure = failureOf(o);
+  return { ok: failure === null, stdout: o.stdout, stderr: o.stderr, failure };
+}
+function failureOf(o) {
+  if (o.timedOut) return "timed out";
+  if (o.error) return o.error.message;
+  if (o.status === 0) return null;
+  const last = (o.stderr || o.stdout).split(/\r?\n/).filter((line) => line.trim()).pop();
+  return last ?? (o.status === null ? `signal ${o.signal}` : `exit code ${o.status}`);
+}
+function createExec(deps) {
+  const win = deps.platform === "win32";
+  function resolve(bin, args) {
+    if (!win || !SHIM.test(bin)) return { file: bin, argv: args, shell: false };
+    const name = path.win32.basename(bin).replace(SHIM, "").toLowerCase();
+    const cli = path.win32.join(
+      path.win32.dirname(deps.execPath),
+      "node_modules",
+      "npm",
+      "bin",
+      `${name}-cli.js`
+    );
+    if ((name === "npm" || name === "npx") && deps.exists(cli)) {
+      return { file: deps.execPath, argv: [cli, ...args], shell: false };
+    }
+    return { file: `"${bin}"`, argv: args, shell: true };
+  }
+  return {
+    which: (name) => whichOnPath(name, deps.env, win),
+    run(bin, args, opts) {
+      const { file, argv, shell } = resolve(bin, args);
+      const r = deps.spawn(file, argv, {
+        stdio: opts.inherit === "stderr" ? ["ignore", 2, 2] : opts.inherit ? "inherit" : ["ignore", "pipe", "pipe"],
+        encoding: "utf8",
+        timeout: opts.timeoutMs,
+        maxBuffer: MAX_BUFFER,
+        windowsHide: true,
+        shell
+      });
+      return result(fromSync(r));
+    },
+    runAsync(bin, args, opts) {
+      const { file, argv, shell } = resolve(bin, args);
+      return new Promise((done) => {
+        const child = deps.execFile(
+          file,
+          argv,
+          {
+            encoding: "utf8",
+            timeout: opts.timeoutMs,
+            maxBuffer: MAX_BUFFER,
+            windowsHide: true,
+            shell
+          },
+          (e, stdout, stderr) => done(result(fromAsync(e, stdout, stderr)))
+        );
+        child.stdin?.end();
+      });
+    }
+  };
+}
+var exec = createExec({
+  spawn: spawnSync,
+  execFile,
+  exists: existsSync,
+  env: process.env,
+  platform: process.platform,
+  execPath: process.execPath
+});
+
+// src/host.ts
+function openBrowser(url, platform, spawnImpl = spawn) {
+  const [cmd, args] = platform === "darwin" ? ["open", [url]] : platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+  try {
+    const child = spawnImpl(cmd, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function realHost() {
+  const host = {
+    home: homedir(),
+    cwd: process.cwd(),
+    argv: process.argv,
+    env: process.env,
+    platform: process.platform,
+    stdinIsTTY: process.stdin.isTTY === true,
+    stderrIsTTY: process.stderr.isTTY === true,
+    now: Date.now,
+    fetch: globalThis.fetch,
+    exec,
+    prompt: clackPrompter,
+    openUrl: (url) => openBrowser(url, process.platform),
+    resolveClient: async (key, clientName) => (await import("./client-factory-LWJMZVKT.js")).buildClient(key, clientName, host)
+  };
+  return host;
+}
+
+// src/program.ts
+import { Command, InvalidArgumentError, Option } from "commander";
+var HELP_AFTER = `
+First-time setup: tvly init
+
+Browser authentication: tvly login
+
+API-key authentication: tvly login --api-key tvly-YOUR_KEY
+
+Or set TAVILY_API_KEY environment variable.
+`;
+var KEYLESS_HELP = "\nWorks without an API key (subject to a rate-limit cap). Run `tvly login` to authenticate and remove the cap.";
+var int = (raw) => parseNumberArg(raw, { integer: true });
+var seconds = (raw) => parseNumberArg(raw);
+function addExtractOptions(cmd) {
+  return cmd.addOption(
+    new Option("--extract-depth <depth>", "Extraction depth.").choices(["basic", "advanced"])
+  ).addOption(new Option("--format <format>", "Output format.").choices(["markdown", "text"]));
+}
+function buildProgram(host = realHost()) {
+  const program = new Command("tvly").description("Tavily CLI \u2014 search, extract, crawl, map, and research from the command line.").addHelpText("after", HELP_AFTER).option("--version", "Show version and exit").option("--status", "Show version and auth status").option("--json", "Output as JSON (for agents and scripts)").configureHelp({ showGlobalOptions: true }).exitOverride();
+  const defaults = () => import("./defaults-344GEHCS.js");
+  const research = () => import("./research-PU3YJMQM.js");
+  const agentOption = (description, choices) => new Option("--agent <name>", description).choices(choices).argParser((value, previous) => {
+    const name = value.toLowerCase();
+    if (!choices.includes(name)) {
+      throw new InvalidArgumentError(`Allowed choices are ${choices.join(", ")}.`);
+    }
+    return [...previous ?? [], name];
+  });
+  program.command("init").description("Authenticate, install Tavily skills, and verify a working CLI.").addOption(
+    agentOption("Install skills for an agent. Repeat to select more than one.", AGENT_NAMES)
+  ).option(
+    "--yes",
+    "Accept every default without prompting (all detected agents; skills and MCP)."
+  ).option("--skip-auth", "Keep keyless mode when no credential is configured.").option(
+    "--skip-skills",
+    "Leave coding agents alone: no skills, workflows, or MCP server (no npx needed)."
+  ).option("--skip-workflows", "Do not install or update the Tavily official workflows.").option("--skip-install", "Do not install tvly globally.").option("--api-key <key>", "Authenticate with a Tavily API key instead of OAuth.").option("--browser", "Open OAuth in a browser.").option("--no-browser", "Print the OAuth URL and wait for its local callback.").action(async (opts, cmd) => {
+    await (await import("./init-6PKQ6UES.js")).run(opts, cmd, host);
+  });
+  const authModule = () => import("./auth-EQZRRVIV.js");
+  program.command("login").description("Authenticate with Tavily. Stores credentials for future use.").option("--api-key <key>", "Tavily API key (tvly-...). If omitted, opens browser for OAuth.").option("--no-browser", "Print the login URL instead of opening a browser (SSH / headless).").action(async (opts, cmd) => {
+    await (await authModule()).runLogin(opts, cmd, host);
+  });
+  program.command("logout").description("Clear stored Tavily credentials.").action(async (opts, cmd) => {
+    await (await authModule()).runLogout(opts, cmd, host);
+  });
+  program.command("auth").description("Check authentication status.").action(async (opts, cmd) => {
+    await (await authModule()).runAuth(opts, cmd, host);
+  });
+  const searchModule = () => import("./search-XTAH2SDD.js");
+  const search = program.command("search").description("Search the web using Tavily.").argument(
+    "[queries...]",
+    "One or more search queries (up to 5), run in parallel with the same options. Use - to read a single query from stdin."
+  ).addHelpText("after", KEYLESS_HELP).action(async (queries, opts, cmd) => {
+    await (await searchModule()).run(queries, opts, cmd, host);
+  });
+  let searchConfigured = false;
+  const configure = async (cmd) => {
+    if (cmd !== search || searchConfigured) return;
+    searchConfigured = true;
+    (await searchModule()).configure(search);
+  };
+  program.hook("preSubcommand", (_program, sub) => configure(sub));
+  const extract = program.command("extract").description("Extract content from one or more URLs.").argument("<urls...>", "URLs to extract (max 20).").option("--query <query>", "Rerank chunks by relevance to this query.").option("--chunks-per-source <n>", "Chunks per source (1-5, requires --query).", int);
+  addExtractOptions(extract).option("--include-images", "Include image URLs.").option("--timeout <seconds>", "Max wait time in seconds (1-60).", seconds).addHelpText("after", KEYLESS_HELP).action(async (urls, opts, cmd) => {
+    await (await import("./extract-Q5VLDRON.js")).run(urls, opts, cmd, host);
+  });
+  addCommonOptions(extract);
+  const addSiteOptions = (cmd, verb, limitHelp) => {
+    cmd.option("--max-depth <n>", `Levels deep to ${verb} (1-5, default: 1).`, int).option("--max-breadth <n>", "Links per page (default: 20).", int).option("--limit <n>", limitHelp, int).option(
+      "--instructions <text>",
+      `Natural language guidance for ${verb === "crawl" ? "the crawler" : "URL discovery"}.`
+    );
+  };
+  const addSiteFilters = (cmd) => {
+    cmd.option("--select-paths <patterns>", "Comma-separated regex patterns for paths to include.").option("--exclude-paths <patterns>", "Comma-separated regex patterns for paths to exclude.").option(
+      "--select-domains <patterns>",
+      "Comma-separated regex patterns for domains to include."
+    ).option(
+      "--exclude-domains <patterns>",
+      "Comma-separated regex patterns for domains to exclude."
+    ).option("--allow-external", "Include external domain links.").option("--no-external", "Leave out external domain links.").option("--timeout <seconds>", "Max wait time in seconds (10-150).", seconds);
+  };
+  const needsKey = "\nRequires a Tavily API key. Sign up at https://tavily.com";
+  const crawl = program.command("crawl").description("Crawl a website starting from URL.").argument("<url>", "Where to start; returns full content for each discovered page.");
+  addSiteOptions(crawl, "crawl", "Total pages cap (default: 50).");
+  crawl.option("--chunks-per-source <n>", "Chunks per page (1-5, requires --instructions).", int);
+  addExtractOptions(crawl);
+  addSiteFilters(crawl);
+  crawl.option("--include-images", "Include images.").option("--output-dir <dir>", "Save each page as a .md file in this directory.").addHelpText("after", needsKey).action(async (url, opts, cmd) => {
+    await (await import("./site-ZG42IEW7.js")).runCrawl(url, opts, cmd, host);
+  });
+  addCommonOptions(crawl);
+  const map = program.command("map").description("Discover all URLs on a website (no content extraction).").argument("<url>", "Where to start; returns the URLs found.");
+  addSiteOptions(map, "map", "Maximum URLs to discover (default: 50).");
+  addSiteFilters(map);
+  map.addHelpText("after", needsKey).action(async (url, opts, cmd) => {
+    await (await import("./site-ZG42IEW7.js")).runMap(url, opts, cmd, host);
+  });
+  addCommonOptions(map);
+  const group = program.command("research").description("Deep research commands (run, status, poll).").addHelpText(
+    "after",
+    '\nYou can run research directly: tvly research "your query"\nOr use subcommands: tvly research status <id>'
+  );
+  const addWaitOptions = (cmd) => {
+    cmd.option("--poll-interval <n>", "Seconds between status checks.", int, 10).option("--timeout <n>", "Max seconds to wait.", int, 600);
+  };
+  const researchRun = group.command("run", { isDefault: true }).description("Start a research task.").argument("[query]", 'The research topic. Use "-" to read from stdin.').addOption(
+    new Option("--model <model>", "Research model (default: auto).").choices([
+      "mini",
+      "pro",
+      "auto"
+    ])
+  ).option("--no-wait", "Return request_id immediately without waiting.").option("--stream", "Stream results in real-time.").option("--output-schema <file>", "Path to JSON schema file for structured output.").addOption(
+    new Option("--citation-format <format>", "Citation format.").choices([
+      "numbered",
+      "mla",
+      "apa",
+      "chicago"
+    ])
+  );
+  addOutputOption(researchRun);
+  addWaitOptions(researchRun);
+  addClientNameOption(researchRun);
+  researchRun.addHelpText("after", `
+You can also run directly: tvly research "your query"
+${needsKey}`).action(async (query, opts, cmd) => {
+    await (await research()).run(query, opts, cmd, host);
+  });
+  const researchStatus = group.command("status").description("Check the status of a research task.").argument("<request_id>", "The research request ID.").action(async (requestId, opts, cmd) => {
+    await (await research()).status(requestId, opts, cmd, host);
+  });
+  addClientNameOption(researchStatus);
+  const researchPoll = group.command("poll").description("Poll a research task until completion and return results.").argument("<request_id>", "The research request ID.").action(async (requestId, opts, cmd) => {
+    await (await research()).poll(requestId, opts, cmd, host);
+  });
+  addWaitOptions(researchPoll);
+  addCommonOptions(researchPoll);
+  program.command("update").description("Check for or install the latest Tavily CLI release.").option("--check", "Check for an update without installing it.").action(async (opts, cmd) => {
+    await (await import("./update-CWPZZE4P.js")).run(opts, cmd, host);
+  });
+  const addDefaultOptions = (cmd, claudeHelp, codexHelp, scope) => {
+    cmd.option("--claude", claudeHelp).option("--codex", codexHelp).option(
+      "--project",
+      `${scope} the current project (.claude/settings.local.json, .codex/config.toml) instead of globally.`
+    );
+  };
+  const setDefault = program.command("set-default").description("Make Tavily the default web tool by disabling agents' built-in web search.");
+  addDefaultOptions(
+    setDefault,
+    "Deny Claude Code's built-in WebSearch and WebFetch tools.",
+    "Disable Codex's built-in web search.",
+    "Apply to"
+  );
+  setDefault.action(async (opts, cmd) => {
+    await (await defaults()).runSetDefault(opts, cmd, host);
+  });
+  const unsetDefault = program.command("unset-default").description("Undo set-default and restore agents' built-in web search.");
+  addDefaultOptions(
+    unsetDefault,
+    "Re-allow Claude Code's built-in WebSearch and WebFetch tools.",
+    "Re-enable Codex's built-in web search.",
+    "Undo in"
+  );
+  unsetDefault.action(async (opts, cmd) => {
+    await (await defaults()).runUnsetDefault(opts, cmd, host);
+  });
+  program.command("setup").description("Configure coding agents to use Tavily (mcp).").command("mcp").description("Add the hosted Tavily MCP server to Claude Code, Codex, or Cursor.").addOption(
+    agentOption("Configure an agent, or all. Repeat to select more than one.", [
+      ...AGENT_NAMES,
+      "all"
+    ])
+  ).option("--keyless", "Sign in with OAuth even when TAVILY_API_KEY is set.").action(async (opts, cmd) => {
+    await (await import("./setup-JNKIKMOX.js")).runMcp(opts, cmd, host);
+  });
+  program.helpCommand(false);
+  program.command("help [command]").description("display help for command").action(async (name) => {
+    if (name === void 0) return program.help();
+    const sub = program.commands.find((c) => c.name() === name || c.aliases().includes(name));
+    if (!sub) return program.help({ error: true });
+    await configure(sub);
+    sub.help();
+  });
+  program.action(async (opts, cmd) => {
+    const json = resolveJson(cmd);
+    if (opts.version) {
+      out(json ? JSON.stringify({ version: VERSION }) : `tavily-cli ${VERSION}`);
+      return;
+    }
+    if (opts.status) {
+      await (await import("./status-UAAZ7CBV.js")).printStatus(json, host);
+      return;
+    }
+    const { runRepl } = await import("./repl-IHHLWI3L.js");
+    await runRepl(host);
+  });
+  const parseAsync = program.parseAsync.bind(program);
+  program.parseAsync = async (argv = host.argv, parseOptions) => {
+    const args = [...argv];
+    const start = parseOptions?.from === "user" ? 0 : 2;
+    const at = args.findIndex((arg, i) => i >= start && !arg.startsWith("-"));
+    if (args[at] === "research") {
+      const { normalizeResearchArgs } = await research();
+      args.splice(at + 1, Infinity, ...normalizeResearchArgs(args.slice(at + 1)));
+    }
+    return parseAsync(args, parseOptions);
+  };
+  return program;
+}
+
+export {
+  realHost,
+  buildProgram
+};

package/dist/chunk-QHWWSCVM.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+// src/ui/text.ts
+var CONTROL_CHARS = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
+var BLANK_RUNS = /\n(?:[ \t]*\n){2,}/g;
+function sanitizeControl(value) {
+  return String(value).replace(CONTROL_CHARS, "");
+}
+function plain(value) {
+  return sanitizeControl(value).replace(BLANK_RUNS, "\n\n").trim();
+}
+function snippet(content, maxChars) {
+  const text = sanitizeControl(content).split(/\s+/).filter(Boolean).join(" ");
+  return maxChars && text.length > maxChars ? `${text.slice(0, maxChars)}...` : text;
+}
+var terminalOverride = null;
+function isTerminal(stream = process.stdout) {
+  return terminalOverride ?? Boolean(stream.isTTY);
+}
+function safeLink(url, label, opts = {}) {
+  const cleanUrl = sanitizeControl(url);
+  const display = label === void 0 ? cleanUrl : sanitizeControl(label);
+  let protocol = "";
+  try {
+    protocol = new URL(cleanUrl).protocol;
+  } catch {
+  }
+  const linkable = protocol === "http:" || protocol === "https:";
+  if (!linkable || !isTerminal(opts.stream ?? process.stderr)) return display;
+  return `\x1B]8;;${cleanUrl}\x1B\\${display}\x1B]8;;\x1B\\`;
+}
+function domainOf(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+function tree(root, nodes) {
+  const lines = [root];
+  nodes.forEach((node, i) => {
+    const last = i === nodes.length - 1;
+    lines.push(`${last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}${node.label}`);
+    const kids = node.children ?? [];
+    kids.forEach((kid, j) => {
+      lines.push(`${last ? "    " : "\u2502   "}${j === kids.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}${kid}`);
+    });
+  });
+  return lines.join("\n");
+}
+function table(headers, rows) {
+  const widths = headers.map((h, c) => Math.max(h.length, ...rows.map((r) => (r[c] ?? "").length)));
+  const fmt = (cells) => cells.map((cell, c) => cell.padEnd(widths[c] ?? 0)).join(" ");
+  return [fmt(headers), widths.map((w) => "\u2500".repeat(w)).join(" "), ...rows.map(fmt)].join("\n");
+}
+async function renderMarkdown(markdown) {
+  const input = sanitizeControl(markdown);
+  const [{ Marked }, { markedTerminal }] = await Promise.all([
+    import("marked"),
+    import("marked-terminal")
+  ]);
+  const width = Math.min(process.stdout.columns ?? 80, 100);
+  const marked = new Marked(markedTerminal({ width, reflowText: true }));
+  return (await marked.parse(input)).trimEnd();
+}
+
+export {
+  sanitizeControl,
+  plain,
+  snippet,
+  isTerminal,
+  safeLink,
+  domainOf,
+  hostOf,
+  tree,
+  table,
+  renderMarkdown
+};

package/dist/chunk-SPBOEASO.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+// src/version.ts
+import "fs";
+var VERSION = true ? "1.0.0" : JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+
+export {
+  VERSION
+};

package/dist/chunk-U3B7BNFI.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import {
+  sanitizeControl
+} from "./chunk-QHWWSCVM.js";
+import {
+  getApiKey
+} from "./chunk-AERAIFZU.js";
+import {
+  colors,
+  err,
+  out
+} from "./chunk-E4N27QWM.js";
+import {
+  ExitError,
+  OAuthError,
+  messageOf
+} from "./chunk-5JXZZSLS.js";
+
+// src/commands/credential.ts
+function handleOauthRefreshError(e, json) {
+  const text = sanitizeControl(messageOf(e));
+  if (json) {
+    out(JSON.stringify({ error: { code: "oauth_refresh_failed", message: text } }));
+  } else {
+    err(`  ${colors.pink("> OAuth refresh failed:")} ${text}`);
+  }
+  throw new ExitError(3);
+}
+async function getApiKeyOrExit(json, host) {
+  try {
+    return await getApiKey(host);
+  } catch (e) {
+    if (e instanceof OAuthError) handleOauthRefreshError(e, json);
+    throw e;
+  }
+}
+
+export {
+  getApiKeyOrExit
+};