@tavily/cli 0.0.0-stage → 1.0.0

package/dist/init-6PKQ6UES.js

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+import {
+  MCP_AUTH_NOTE,
+  SKILLS_REPO,
+  WORKFLOWS_REPO,
+  detectAgents,
+  installAgentSkills,
+  installMcp
+} from "./chunk-ULNXDG4Q.js";
+import {
+  MANAGER_COMMANDS,
+  MANAGER_RUNNERS,
+  detectPackageManager,
+  globalBinDir
+} from "./chunk-V3OJFHHD.js";
+import {
+  VERSION
+} from "./chunk-SPBOEASO.js";
+import {
+  withSpinner
+} from "./chunk-K76OUMXM.js";
+import {
+  sanitizeControl
+} from "./chunk-QHWWSCVM.js";
+import {
+  authMethod,
+  getApiKey,
+  looksHeadless,
+  runBrowserLogin,
+  saveApiKey,
+  saveOauthSession
+} from "./chunk-AERAIFZU.js";
+import {
+  resolveJson
+} from "./chunk-IRCF6F3S.js";
+import {
+  colors,
+  err,
+  out
+} from "./chunk-E4N27QWM.js";
+import {
+  ExitError,
+  messageOf
+} from "./chunk-5JXZZSLS.js";
+
+// src/commands/init.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import path from "path";
+import { intro, log, outro } from "@clack/prompts";
+async function run(opts, cmd, host, hooks = {}) {
+  const json = resolveJson(cmd);
+  const requested = [...new Set((opts.agent ?? []).map((name) => name.toLowerCase()))];
+  if (opts.skipAuth && opts.apiKey) {
+    cmd.error("error: Use either --skip-auth or --api-key, not both.");
+  }
+  const interactive = host.stdinIsTTY && host.stderrIsTTY && !json && !opts.yes;
+  if (interactive) intro("tvly init", { output });
+  const cli = await installStep(opts, json, host);
+  const result = emptyResult();
+  result.install = cli.install;
+  let mcpSetup = null;
+  try {
+    const auth = await ensureAuth(opts, interactive, host, hooks);
+    result.auth = auth;
+    result.mode = auth.authenticated ? "authenticated" : "keyless";
+    result.verification.auth = auth.authenticated;
+  } catch (e) {
+    if (e instanceof ExitError) throw e;
+    return fail(result, "auth", messageOf(e), 3, json);
+  }
+  const picked = await plan(requested, opts, interactive, host);
+  const agents = picked.agents.join(", ");
+  for (const stage of ["skills", "workflows"]) {
+    if (!picked[stage]) continue;
+    const part = result[stage];
+    part.agents = picked.agents;
+    part.skipped = false;
+    const { label } = BUNDLES[stage];
+    try {
+      const installed = await step(
+        interactive,
+        `Installing ${label}`,
+        `${label} \u2192 ${agents}`,
+        () => installAgentSkills(part.source, picked.agents, host)
+      );
+      part.restart_required = installed.restartRequired;
+    } catch (e) {
+      return fail(result, stage, messageOf(e), 1, json);
+    }
+  }
+  if (picked.mcp) {
+    const { label } = BUNDLES.mcp;
+    try {
+      mcpSetup = await step(
+        interactive,
+        `Adding the ${label}`,
+        `${label} \u2192 ${agents}`,
+        () => installMcp(picked.agents, false, host)
+      );
+      result.mcp = { agents: mcpSetup.configured, skipped: mcpSetup.configured.length === 0 };
+    } catch (e) {
+      return fail(result, "mcp", messageOf(e), 1, json);
+    }
+  }
+  result.verification.cli = result.install.on_path || result.install.global;
+  if (!result.verification.cli && !opts.skipInstall && !cli.failed) {
+    return fail(result, "cli", "tvly is not available on PATH.", 1, json);
+  }
+  try {
+    await step(interactive, "Verifying live search", "Live search verified", async () => {
+      if (!await verifyLiveSearch(host)) {
+        throw new Error("Tavily search returned no result payload.");
+      }
+    });
+    result.verification.live_search = true;
+  } catch (e) {
+    return fail(result, "live_search", messageOf(e), 4, json);
+  }
+  if (cli.failed) {
+    return fail(result, "install", INSTALL_INCOMPLETE, 1, json, cli.pathNote);
+  }
+  result.ok = true;
+  if (interactive) outro("Setup complete", { output });
+  printResult(result, json, cli.pathNote, mcpSetup);
+}
+var output = process.stderr;
+var BUNDLES = {
+  skills: { value: "skills", label: "Tavily skills", hint: "search, extract, crawl, research" },
+  workflows: { value: "workflows", label: "Official workflows" },
+  mcp: { value: "mcp", label: "MCP server", hint: "hosted, signs in with OAuth" }
+};
+async function step(interactive, label, done, fn) {
+  const value = await withSpinner(label, interactive, fn);
+  if (interactive) log.success(done, { output });
+  return value;
+}
+async function plan(requested, opts, interactive, host) {
+  const none = { agents: [], skills: false, workflows: false, mcp: false };
+  if (opts.skipSkills) return none;
+  const candidates = requested.length ? requested : detectAgents(host);
+  if (!candidates.length) {
+    if (interactive) {
+      log.warn("No coding agents found. Skills and MCP need Claude Code, Cursor, or Codex.", {
+        output
+      });
+    }
+    return none;
+  }
+  const agents = interactive && !requested.length ? await host.prompt.multiselect(
+    "Which agents do you want to install to?",
+    candidates.map((a) => ({ value: a, label: a })),
+    candidates
+  ) : candidates;
+  if (!agents.length) return none;
+  const choices = [BUNDLES.skills, ...opts.skipWorkflows ? [] : [BUNDLES.workflows], BUNDLES.mcp];
+  const defaults = choices.map((c) => c.value).filter((v) => v !== "workflows");
+  const bundles = interactive ? await host.prompt.multiselect("What should I install?", choices, defaults) : defaults;
+  return {
+    agents,
+    skills: bundles.includes("skills"),
+    workflows: bundles.includes("workflows"),
+    mcp: bundles.includes("mcp")
+  };
+}
+var INSTALL_INCOMPLETE = "Setup incomplete: global CLI installation failed. Other completed steps are preserved.";
+async function installStep(opts, json, host) {
+  const onPath = () => host.exec.which("tvly") !== null;
+  const step2 = {
+    install: { global: false, manager: null, on_path: onPath(), path_updated: false },
+    failed: false,
+    pathNote: null
+  };
+  if (opts.skipInstall || step2.install.on_path) return step2;
+  const interactive = !json && !opts.yes && host.stdinIsTTY && host.stderrIsTTY;
+  if (interactive && !await host.prompt.confirm("Install tvly globally?")) return step2;
+  const manager = detectPackageManager(host);
+  step2.install.manager = manager;
+  const [name, ...args] = MANAGER_COMMANDS[manager];
+  const bin = host.exec.which(name);
+  if (!bin || !host.exec.run(bin, args, { inherit: json ? "stderr" : true }).ok) {
+    err(`Failed to install @tavily/cli globally using ${manager}.`);
+    err(`Retry: ${MANAGER_COMMANDS[manager].join(" ")}`);
+    err(`You can run without a global install: ${MANAGER_RUNNERS[manager]} <command>`);
+    step2.failed = true;
+    return step2;
+  }
+  step2.install.global = true;
+  step2.install.on_path = onPath();
+  if (!step2.install.on_path) {
+    step2.pathNote = await fixPath(manager, interactive, host);
+    step2.install.path_updated = step2.pathNote !== null;
+  }
+  return step2;
+}
+function rcFileForShell(shell, platform) {
+  if (shell.includes("zsh")) return "~/.zshrc";
+  if (shell.includes("fish")) return "~/.config/fish/config.fish";
+  if (shell.includes("bash")) return platform === "darwin" ? "~/.bash_profile" : "~/.bashrc";
+  return "~/.profile";
+}
+async function fixPath(manager, interactive, host) {
+  const bin = globalBinDir(manager, host);
+  err("");
+  err(`tvly was installed but isn't on your PATH yet.`);
+  if (bin && host.platform === "win32") {
+    err("Add this directory to your PATH, then open a new terminal:");
+    err(`  ${bin}`);
+  } else if (bin) {
+    const rc = rcFileForShell(host.env.SHELL ?? "", host.platform);
+    const line = rc.includes("fish") ? `fish_add_path ${bin}` : `export PATH="${bin}:$PATH"`;
+    const question = `Add ${bin} to PATH in ${rc}?`;
+    if (interactive && await host.prompt.confirm(question)) {
+      const file = path.join(host.home, rc.slice(2));
+      if (!existsSync(file) || !readFileSync(file, "utf8").includes(line)) {
+        mkdirSync(path.dirname(file), { recursive: true });
+        appendFileSync(file, `
+# Added by tvly init
+${line}
+`);
+      }
+      err("Restart your terminal, then run tvly.");
+      return `Added ${bin} to PATH in ${rc}`;
+    }
+    err("Add it to your shell, then restart your terminal:");
+    err(`  echo '${line}' >> ${rc}`);
+  } else {
+    err(`Add your ${manager} global bin directory to PATH.`);
+  }
+  err(`Until then you can still run: ${MANAGER_RUNNERS[manager]} <command>`);
+  return null;
+}
+async function ensureAuth(opts, interactive, host, hooks) {
+  if (opts.apiKey) await saveApiKey(opts.apiKey, host);
+  const key = await getApiKey(host);
+  if (key) return { authenticated: true, method: authMethod(key, host) };
+  if (opts.skipAuth) return { authenticated: false, method: "none" };
+  if (interactive && opts.browser === void 0) {
+    const method = await host.prompt.select(
+      "How do you want to sign in?",
+      [
+        { value: "browser", label: "Browser login", hint: "recommended" },
+        { value: "key", label: "Paste an API key" },
+        { value: "keyless", label: "Continue without a key", hint: "rate-limited" }
+      ],
+      "browser"
+    );
+    if (method === "key") {
+      await saveApiKey((await host.prompt.password("API key")).trim(), host);
+      return { authenticated: true, method: "api_key" };
+    }
+    if (method === "keyless") return { authenticated: false, method: "none" };
+  }
+  if (opts.browser === void 0 && !host.stdinIsTTY) {
+    throw new Error(
+      "No Tavily credential found. Use --api-key, --browser, --no-browser, or --skip-auth in non-interactive runs."
+    );
+  }
+  const openBrowser = opts.browser ?? !looksHeadless(host.env, host.platform);
+  const session = await (hooks.login ?? runBrowserLogin)({
+    openBrowser,
+    onStatus: (url) => err(`Open this URL to authenticate: ${sanitizeControl(url)}`),
+    fetchImpl: host.fetch,
+    openImpl: host.openUrl
+  });
+  await saveOauthSession(session, host);
+  return { authenticated: true, method: "oauth" };
+}
+async function verifyLiveSearch(host) {
+  const client = await host.resolveClient(await getApiKey(host), "tavily-cli-init");
+  const response = await client.search({ query: "Tavily Search API", max_results: 1 });
+  return Array.isArray(response?.results);
+}
+function emptyResult() {
+  return {
+    ok: false,
+    version: VERSION,
+    mode: "unknown",
+    auth: { authenticated: false, method: "none" },
+    skills: { source: SKILLS_REPO, agents: [], restart_required: false, skipped: true },
+    workflows: { source: WORKFLOWS_REPO, agents: [], restart_required: false, skipped: true },
+    mcp: { agents: [], skipped: true },
+    verification: { cli: false, auth: false, live_search: false },
+    install: { global: false, manager: null, on_path: false, path_updated: false }
+  };
+}
+function fail(result, stage, message, code, json, pathNote = null) {
+  result.error = { stage, message };
+  printResult(result, json, pathNote);
+  throw new ExitError(code);
+}
+function printResult(result, json, pathNote = null, mcp = null) {
+  if (json) {
+    out(JSON.stringify(result));
+    return;
+  }
+  out();
+  if (!result.ok) {
+    const message = sanitizeControl(result.error?.message ?? "Initialization failed.");
+    out(`  ${colors.pink("> Setup failed:")} ${message}`);
+    out();
+    return;
+  }
+  out(`  ${colors.green("> Tavily is ready")}`);
+  const { auth, skills, workflows } = result;
+  if (auth.authenticated) out(`    ${colors.green("\u2713")} Authenticated via ${auth.method}`);
+  else out(`    ${colors.yellow("\u2022")} Keyless mode`);
+  if (skills.skipped) out(`    ${colors.dim("\u2022 Skills skipped")}`);
+  else out(`    ${colors.green("\u2713")} Tavily skills ready for ${skills.agents.join(", ")}`);
+  if (workflows.skipped) out(`    ${colors.dim("\u2022 Workflows skipped")}`);
+  else out(`    ${colors.green("\u2713")} Tavily workflows ready for ${workflows.agents.join(", ")}`);
+  if (mcp) {
+    if (mcp.configured.length) {
+      out(`    ${colors.green("\u2713")} Tavily MCP server ready for ${mcp.configured.join(", ")}`);
+    }
+    for (const { agent, reason } of mcp.skipped) {
+      out(`    ${colors.dim(`\u2022 MCP skipped for ${agent} (${sanitizeControl(reason)})`)}`);
+    }
+  }
+  out(`    ${colors.green("\u2713")} Live search verified`);
+  if (result.install.global) {
+    out(`    ${colors.green("\u2713")} tvly installed globally (${result.install.manager})`);
+  }
+  if (pathNote) out(`    ${colors.green("\u2713")} ${pathNote}`);
+  if (skills.restart_required || workflows.restart_required) {
+    const restart = skills.restart_required ? skills.agents : workflows.agents;
+    out();
+    out(`    ${colors.dim(`Restart ${restart.join(", ")} to load newly installed skills.`)}`);
+  }
+  if (mcp?.configured.length) {
+    out();
+    out(`    ${colors.dim(MCP_AUTH_NOTE[mcp.auth])}`);
+  }
+  out();
+  out("  Try:");
+  out(`    ${colors.green('tvly search "latest AI news"')}`);
+  out(`    ${colors.green("tvly extract https://example.com")}`);
+  out(`    ${colors.green('tvly research "your topic"')}`);
+  out(`    Or ask your agent: "search for the latest AI news"`);
+  if (result.mcp.skipped) {
+    out();
+    out("  Add the hosted Tavily MCP server to your agents:");
+    out(`    ${colors.green("tvly setup mcp")}`);
+  }
+  out();
+}
+export {
+  run
+};

package/dist/repl-IHHLWI3L.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+import {
+  buildProgram
+} from "./chunk-PZGMUDV2.js";
+import "./chunk-HQ7QBZ5H.js";
+import {
+  VERSION
+} from "./chunk-SPBOEASO.js";
+import {
+  getApiKeyOrExit
+} from "./chunk-U3B7BNFI.js";
+import {
+  sanitizeControl
+} from "./chunk-QHWWSCVM.js";
+import {
+  authSource
+} from "./chunk-AERAIFZU.js";
+import "./chunk-IRCF6F3S.js";
+import {
+  LOGO,
+  colorEnabled,
+  colors
+} from "./chunk-E4N27QWM.js";
+import {
+  ExitError,
+  messageOf
+} from "./chunk-5JXZZSLS.js";
+
+// src/repl.ts
+import { createInterface } from "readline/promises";
+import { CommanderError } from "commander";
+
+// src/util/shell-words.ts
+var DOUBLE_QUOTE_ESCAPABLE = /* @__PURE__ */ new Set(['"', "\\"]);
+function splitShellWords(line) {
+  const words = [];
+  let current = "";
+  let inWord = false;
+  let i = 0;
+  while (i < line.length) {
+    const ch = line.charAt(i);
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      if (inWord) {
+        words.push(current);
+        current = "";
+        inWord = false;
+      }
+      i++;
+    } else if (ch === "'") {
+      const end = line.indexOf("'", i + 1);
+      if (end === -1) throw new Error("No closing quotation");
+      current += line.slice(i + 1, end);
+      inWord = true;
+      i = end + 1;
+    } else if (ch === '"') {
+      inWord = true;
+      i++;
+      for (; ; ) {
+        if (i >= line.length) throw new Error("No closing quotation");
+        const c = line.charAt(i);
+        if (c === '"') {
+          i++;
+          break;
+        }
+        const next = line.charAt(i + 1);
+        if (c === "\\" && DOUBLE_QUOTE_ESCAPABLE.has(next)) {
+          current += next;
+          i += 2;
+        } else {
+          current += c;
+          i++;
+        }
+      }
+    } else if (ch === "\\") {
+      if (i + 1 >= line.length) throw new Error("No escaped character");
+      current += line.charAt(i + 1);
+      inWord = true;
+      i += 2;
+    } else {
+      current += ch;
+      inWord = true;
+      i++;
+    }
+  }
+  if (inWord) words.push(current);
+  return words;
+}
+
+// src/repl.ts
+var PROMPT = "\x1B[38;2;92;217;230m\u276F\x1B[0m  ";
+async function printBanner(say, host) {
+  const key = await getApiKeyOrExit(false, host);
+  say(LOGO);
+  say(`  ${colors.dim(`v${VERSION}`)}`);
+  say();
+  if (key) {
+    say(`  ${colors.green(">")} Authenticated via ${authSource(key, host.env)}`);
+  } else {
+    say(`  ${colors.pink(">")} Not authenticated`);
+    say(`    ${colors.dim("search and extract work without a key (with a rate-limit cap).")}`);
+    say(`    Type ${colors.green("init")} for guided setup and skill installation.`);
+    say(`    Type ${colors.green("login")} for browser authentication only.`);
+  }
+  say();
+  const sep = colors.dim("  |  ");
+  say(
+    [
+      `  ${colors.bold("Tips: ")}${colors.green("init")}`,
+      `${colors.green("search ")}${colors.dim('"query"')}`,
+      `${colors.green("extract ")}${colors.dim("<url>")}`,
+      `${colors.green("research ")}${colors.dim('"topic"')}`,
+      colors.green("update"),
+      colors.green("help"),
+      colors.green("exit")
+    ].join(sep)
+  );
+  say();
+}
+function printHelp(say) {
+  const row = (cmd, pad, text) => `    ${colors.green(cmd)}${" ".repeat(pad)}${text}`;
+  say();
+  say(`  ${colors.bold("Commands")}`);
+  say();
+  say(row('search "your query"', 12, "Web search"));
+  say(row("extract <url>", 18, "Extract content"));
+  say(row("crawl <url>", 20, "Crawl a website"));
+  say(row("map <url>", 22, "Discover URLs"));
+  say(row('research "topic"', 14, "Deep research"));
+  say(row("init", 26, "Guided setup and skill installation"));
+  say(row("login", 25, "Browser or API-key authentication"));
+  say(row("logout", 24, "Clear credentials"));
+  say(row("auth", 26, "Auth status"));
+  say(row("update", 24, "Check for or install CLI updates"));
+  say(row("exit / quit / Ctrl+C", 10, "Leave"));
+}
+function silenceErrors(cmd) {
+  cmd.configureOutput({ writeErr: () => {
+  } });
+  for (const sub of cmd.commands) silenceErrors(sub);
+}
+async function runRepl(host, opts = {}) {
+  const input = opts.input ?? process.stdin;
+  const output = opts.output ?? process.stderr;
+  const makeProgram = opts.program ?? (() => buildProgram(host));
+  const say = (line = "") => {
+    output.write(`${line}
+`);
+  };
+  const goodbye = () => {
+    say();
+    say(`  ${colors.dim("Goodbye!")}`);
+    say();
+  };
+  say();
+  await printBanner(say, host);
+  const queue = [];
+  let closed = false;
+  let detaching = false;
+  let interrupted = false;
+  let history = [];
+  let wake;
+  const notify = () => wake?.();
+  const open = () => {
+    const rl2 = createInterface({
+      input,
+      output,
+      terminal: input.isTTY === true,
+      history,
+      historySize: 100
+    });
+    rl2.setPrompt(colorEnabled() ? PROMPT : "\u276F  ");
+    rl2.on("history", (h) => {
+      history = h;
+    });
+    rl2.on("line", (l) => {
+      queue.push(l);
+      notify();
+    });
+    rl2.on("close", () => {
+      if (detaching) return;
+      closed = true;
+      notify();
+    });
+    rl2.on("SIGINT", () => {
+      interrupted = true;
+      notify();
+    });
+    return rl2;
+  };
+  let rl = open();
+  const nextLine = async () => {
+    const width = output.columns ?? 80;
+    say(colors.dim("\u2500".repeat(width)));
+    if (!closed) rl.prompt();
+    while (queue.length === 0 && !closed && !interrupted) {
+      await new Promise((resolve) => {
+        wake = resolve;
+      });
+    }
+    wake = void 0;
+    if (interrupted) return null;
+    return queue.shift() ?? "exit";
+  };
+  try {
+    for (; ; ) {
+      const raw = await nextLine();
+      if (raw === null) {
+        goodbye();
+        break;
+      }
+      const line = raw.trim();
+      if (!line) continue;
+      if (line === "exit" || line === "quit" || line === "q") {
+        goodbye();
+        break;
+      }
+      if (line === "help" || line === "?") {
+        printHelp(say);
+        continue;
+      }
+      let args;
+      try {
+        args = splitShellWords(line);
+      } catch (e) {
+        say(`  ${colors.pink("Parse error:")} ${sanitizeControl(messageOf(e))}`);
+        continue;
+      }
+      if (args[0] === "tvly") args = args.slice(1);
+      if (args.length === 0) continue;
+      say();
+      if (!closed) {
+        detaching = true;
+        rl.close();
+        detaching = false;
+      }
+      try {
+        const program = makeProgram();
+        silenceErrors(program);
+        await program.parseAsync(["node", "tvly", ...args]);
+      } catch (e) {
+        if (e instanceof ExitError) {
+        } else if (e instanceof CommanderError) {
+          if (e.exitCode !== 0) say(`  ${colors.pink(">")} ${sanitizeControl(e.message)}`);
+        } else {
+          say(`  ${colors.pink("> Error:")} ${sanitizeControl(messageOf(e))}`);
+        }
+      } finally {
+        if (input.readableEnded) closed = true;
+        if (!closed) rl = open();
+      }
+      say();
+    }
+  } finally {
+    rl.close();
+  }
+}
+export {
+  runRepl
+};