@tavily/cli 0.0.0-stage → 1.0.0

package/dist/chunk-ULNXDG4Q.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+// src/core/skills.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import path from "path";
+import { isDeepStrictEqual } from "util";
+var SKILLS_REPO = "tavily-ai/skills";
+var WORKFLOWS_REPO = "tavily-ai/official-workflows";
+var NPX_SKILLS_PACKAGE = "skills@1.7.4";
+var NPX_ADD_MCP_PACKAGE = "add-mcp@1.14.0";
+function agentRoots({ home: root, env }) {
+  return {
+    "claude-code": env.CLAUDE_CONFIG_DIR || path.join(root, ".claude"),
+    codex: env.CODEX_HOME || path.join(root, ".codex"),
+    cursor: path.join(root, ".cursor")
+  };
+}
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function detectAgents(host) {
+  return Object.entries(agentRoots(host)).filter(([, dir]) => isDir(dir)).map(([name]) => name);
+}
+async function runNpx(args, exec) {
+  const npx = exec.which("npx");
+  return npx ? exec.runAsync(npx, args, { timeoutMs: 3e5 }) : null;
+}
+async function installAgentSkills(repo, agents, host) {
+  const roots = agentRoots(host);
+  const skillDirs = [
+    path.join(host.home, ".agents", "skills"),
+    ...agents.flatMap((name) => roots[name] ? [path.join(roots[name], "skills")] : [])
+  ];
+  const before = snapshotSkills(skillDirs);
+  const args = [
+    "--yes",
+    NPX_SKILLS_PACKAGE,
+    "add",
+    repo,
+    "--skill",
+    "*",
+    "--global",
+    "--agent",
+    ...agents,
+    "--yes"
+  ];
+  const completed = await runNpx(args, host.exec);
+  if (!completed) {
+    throw new Error(
+      "Installing Tavily skills requires Node.js (npx). Install Node.js, or rerun with --skip-skills."
+    );
+  }
+  if (completed.failure) throw new Error(`npx skills failed: ${completed.failure}`);
+  return { agents, restartRequired: !isDeepStrictEqual(snapshotSkills(skillDirs), before) };
+}
+function snapshotSkills(skillDirs) {
+  const snapshot = /* @__PURE__ */ new Map();
+  const addFiles = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) addFiles(full);
+      else if (entry.isFile()) snapshot.set(full, readFileSync(full));
+    }
+  };
+  for (const skillDir of skillDirs.filter(isDir)) {
+    for (const name of readdirSync(skillDir)) {
+      const full = path.join(skillDir, name);
+      if (!isDir(full)) continue;
+      snapshot.set(full, null);
+      addFiles(full);
+    }
+  }
+  return snapshot;
+}
+
+// src/core/mcp-setup.ts
+var MCP_SERVER_URL = "https://mcp.tavily.com/mcp/";
+var SERVER_NAME = "tavily";
+var KEY_VAR = "TAVILY_API_KEY";
+var MCP_AUTH_NOTE = {
+  env: `Using ${KEY_VAR} from your environment; the key itself is not stored in any config.`,
+  oauth: "Your agent will open a browser to sign in to Tavily the first time it uses the server."
+};
+var HEADER_REF = {
+  "claude-code": `Bearer \${${KEY_VAR}}`,
+  cursor: `Bearer \${env:${KEY_VAR}}`
+};
+async function installMcp(agents, keyless, host) {
+  const auth = !keyless && host.env[KEY_VAR] ? "env" : "oauth";
+  const result = { configured: [], skipped: [], auth };
+  for (const agent of agents) {
+    const reason = auth === "env" && agent === "codex" ? await codexAdd(host.exec) : await addMcp(agent, auth === "env" ? HEADER_REF[agent] : void 0, host.exec);
+    if (reason) result.skipped.push({ agent, reason });
+    else result.configured.push(agent);
+  }
+  return result;
+}
+async function addMcp(agent, header, exec) {
+  const args = [
+    "--yes",
+    NPX_ADD_MCP_PACKAGE,
+    MCP_SERVER_URL,
+    "--name",
+    SERVER_NAME,
+    "--transport",
+    "http",
+    ...header ? ["--header", `Authorization: ${header}`] : [],
+    "--agent",
+    agent,
+    "--global",
+    "--yes"
+  ];
+  const completed = await runNpx(args, exec);
+  if (!completed) {
+    throw new Error(
+      "Adding the Tavily MCP server requires Node.js (npx). Install Node.js and rerun."
+    );
+  }
+  return completed.failure;
+}
+async function codexAdd(exec) {
+  const codex = exec.which("codex");
+  if (!codex) return "codex is not on PATH";
+  const args = [
+    "mcp",
+    "add",
+    SERVER_NAME,
+    "--url",
+    MCP_SERVER_URL,
+    "--bearer-token-env-var",
+    KEY_VAR
+  ];
+  return (await exec.runAsync(codex, args, { timeoutMs: 3e5 })).failure;
+}
+
+export {
+  SKILLS_REPO,
+  WORKFLOWS_REPO,
+  detectAgents,
+  installAgentSkills,
+  MCP_AUTH_NOTE,
+  installMcp
+};

package/dist/chunk-V3OJFHHD.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+// src/util/semver.ts
+var VERSION_RE = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
+var NUMERIC_RE = /^\d+$/;
+function parse(version) {
+  const m = VERSION_RE.exec(version.trim());
+  if (!m) throw new Error("The installed Tavily CLI version is invalid.");
+  return {
+    core: [Number(m[1]), Number(m[2]), Number(m[3])],
+    pre: m[4] ? m[4].split(".") : []
+  };
+}
+function sign(n) {
+  return n < 0 ? -1 : n > 0 ? 1 : 0;
+}
+function compareIdentifier(a, b) {
+  const aNum = NUMERIC_RE.test(a);
+  const bNum = NUMERIC_RE.test(b);
+  if (aNum && bNum) return sign(Number(a) - Number(b));
+  if (aNum) return -1;
+  if (bNum) return 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareVersions(a, b) {
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < 3; i++) {
+    const diff = sign((pa.core[i] ?? 0) - (pb.core[i] ?? 0));
+    if (diff !== 0) return diff;
+  }
+  if (pa.pre.length === 0 || pb.pre.length === 0) {
+    return sign(pb.pre.length - pa.pre.length);
+  }
+  const len = Math.min(pa.pre.length, pb.pre.length);
+  for (let i = 0; i < len; i++) {
+    const diff = compareIdentifier(pa.pre[i] ?? "", pb.pre[i] ?? "");
+    if (diff !== 0) return diff;
+  }
+  return sign(pa.pre.length - pb.pre.length);
+}
+function isNewer(candidate, current) {
+  return compareVersions(candidate, current) === 1;
+}
+
+// src/core/install-detect.ts
+import { existsSync, realpathSync } from "fs";
+import path from "path";
+var NPM_LATEST_URL = "https://registry.npmjs.org/@tavily/cli/latest";
+var PACKAGE_SPEC = "@tavily/cli@latest";
+var MANAGER_COMMANDS = {
+  npm: ["npm", "install", "-g", PACKAGE_SPEC],
+  pnpm: ["pnpm", "add", "-g", PACKAGE_SPEC],
+  yarn: ["yarn", "global", "add", PACKAGE_SPEC],
+  bun: ["bun", "add", "-g", PACKAGE_SPEC]
+};
+var MANAGER_RUNNERS = {
+  npm: "npx @tavily/cli",
+  pnpm: "pnpm dlx @tavily/cli",
+  yarn: "yarn dlx @tavily/cli",
+  bun: "bunx @tavily/cli"
+};
+var BIN_COMMANDS = {
+  npm: ["prefix", "-g"],
+  pnpm: ["bin", "-g"],
+  yarn: ["global", "bin"],
+  bun: ["pm", "bin", "-g"]
+};
+var SOURCE_REASON = "This is a source or direct-URL installation. Update it from its original source.";
+var NPX_REASON = "This CLI is running from an npx cache and cannot update itself in place. Exit and rerun `npx @tavily/cli@latest` instead.";
+var UNKNOWN_REASON = "Could not determine how Tavily CLI was installed. Update it with the original package manager.";
+var normalize = (p) => p.replace(/\\/g, "/").toLowerCase();
+function normalizeDir(p) {
+  const dir = normalize(p);
+  let end = dir.length;
+  while (end > 0 && dir[end - 1] === "/") end--;
+  return dir.slice(0, end);
+}
+var blocked = (method, reason) => ({
+  method,
+  command: null,
+  blockedReason: reason
+});
+function npmRootGlobalDefault(host) {
+  return managerOutput("npm", ["root", "-g"], host.exec);
+}
+function globalBinDir(manager, host) {
+  const out = managerOutput(manager, BIN_COMMANDS[manager], host.exec);
+  if (!out) return null;
+  return manager === "npm" && host.platform !== "win32" ? `${out}/bin` : out;
+}
+function managerOutput(manager, args, exec) {
+  const bin = exec.which(manager);
+  if (!bin) return null;
+  const r = exec.run(bin, args, { timeoutMs: 15e3 });
+  return r.ok ? r.stdout.trim() || null : null;
+}
+function packageDir(file) {
+  if (!path.isAbsolute(file)) return null;
+  for (let dir = path.dirname(file); ; dir = path.dirname(dir)) {
+    if (existsSync(path.join(dir, "package.json"))) return dir;
+    if (path.dirname(dir) === dir) return null;
+  }
+}
+function safeRealpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function detectPackageManager({ env, argv }, versions = process.versions) {
+  const entry = (argv[1] ?? "").replaceAll("\\", "/");
+  if (/bunx[-/]|\/\.bun\//.test(entry)) return "bun";
+  if (/\/pnpm\/(dlx|global)\//.test(entry)) return "pnpm";
+  const hint = `${env.npm_config_user_agent ?? ""} ${env.npm_execpath ?? ""}`;
+  if (/\bpnpm\b/i.test(hint)) return "pnpm";
+  if (/\byarn\b/i.test(hint)) return "yarn";
+  if (/\bbun\b/i.test(hint)) return "bun";
+  if (versions.bun) return "bun";
+  return "npm";
+}
+function detectInstall(host, npmRootGlobal = () => npmRootGlobalDefault(host)) {
+  const { env } = host;
+  const raw = host.argv[1] ?? "";
+  const real = safeRealpath(raw);
+  const normReal = normalize(real);
+  const normRaw = normalize(raw);
+  if (normReal.includes("/_npx/")) return blocked("npx", NPX_REASON);
+  const inNodeModules = (p) => p.split("/").includes("node_modules");
+  const linked = normRaw !== normReal && normRaw.includes("node_modules/@tavily/cli");
+  const pkgDir = packageDir(real);
+  if (linked || !inNodeModules(pkgDir === null ? normReal : normalize(pkgDir))) {
+    return blocked("source", SOURCE_REASON);
+  }
+  const pnpmHome = env.PNPM_HOME ? normalizeDir(env.PNPM_HOME) : null;
+  let method = "unknown";
+  if (normReal.includes("/pnpm/global/") || pnpmHome && normReal.startsWith(`${pnpmHome}/`)) {
+    method = "pnpm";
+  } else if (normReal.includes("/.yarn/global/") || normReal.includes("/yarn/global/")) {
+    method = "yarn";
+  } else if (normReal.includes("/.bun/install/global/")) {
+    method = "bun";
+  } else {
+    const root = npmRootGlobal();
+    if (root) {
+      const normRoot = normalizeDir(root);
+      if (normReal.startsWith(`${normRoot}/`)) method = "npm";
+    }
+  }
+  if (method === "unknown") return blocked("unknown", UNKNOWN_REASON);
+  const manager = host.exec.which(method);
+  if (!manager) {
+    return blocked(
+      method,
+      `This installation is managed by ${method}, but ${method} is not available on PATH.`
+    );
+  }
+  const [, ...args] = MANAGER_COMMANDS[method];
+  return { method, command: [manager, ...args], blockedReason: null };
+}
+async function fetchLatestVersion(fetchImpl, signal = AbortSignal.timeout(1e4)) {
+  let data;
+  try {
+    const response = await fetchImpl(NPM_LATEST_URL, { redirect: "manual", signal });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    data = await response.json();
+  } catch {
+    throw new Error("Could not check npm for Tavily CLI updates.");
+  }
+  const version = data?.version;
+  try {
+    if (typeof version !== "string") throw new Error();
+    compareVersions(version, version);
+  } catch {
+    throw new Error("npm returned an invalid Tavily CLI version.");
+  }
+  return version;
+}
+
+export {
+  compareVersions,
+  isNewer,
+  MANAGER_COMMANDS,
+  MANAGER_RUNNERS,
+  globalBinDir,
+  safeRealpath,
+  detectPackageManager,
+  detectInstall,
+  fetchLatestVersion
+};

package/dist/cli.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import {
+  buildProgram,
+  realHost
+} from "./chunk-PZGMUDV2.js";
+import "./chunk-HQ7QBZ5H.js";
+import {
+  detectInstall,
+  fetchLatestVersion,
+  isNewer
+} from "./chunk-V3OJFHHD.js";
+import {
+  VERSION
+} from "./chunk-SPBOEASO.js";
+import {
+  sanitizeControl
+} from "./chunk-QHWWSCVM.js";
+import "./chunk-IRCF6F3S.js";
+import {
+  colors,
+  err
+} from "./chunk-E4N27QWM.js";
+import {
+  ExitError,
+  messageOf
+} from "./chunk-5JXZZSLS.js";
+
+// src/cli.ts
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { CommanderError } from "commander";
+
+// src/core/update-notice.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import path from "path";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var RACE_MS = 1500;
+var SKIP_FLAGS = /* @__PURE__ */ new Set(["--version", "--help", "-V", "-h"]);
+var SKIP_COMMANDS = /* @__PURE__ */ new Set(["update", "init"]);
+var noop = async () => {
+};
+function readState(file) {
+  try {
+    const data = JSON.parse(readFileSync(file, "utf8"));
+    if (typeof data?.checked_at !== "number") return null;
+    return {
+      checked_at: data.checked_at,
+      latest: typeof data.latest === "string" ? data.latest : null
+    };
+  } catch {
+    return null;
+  }
+}
+function writeState(file, state) {
+  try {
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify(state)}
+`);
+  } catch {
+  }
+}
+function startUpdateCheck(host) {
+  try {
+    const { env, now } = host;
+    const args = host.argv.slice(2);
+    const command = args.find((a) => !a.startsWith("-")) ?? "";
+    if (env.CI || env.NO_UPDATE_NOTIFIER || !host.stderrIsTTY || args.includes("--json") || args.some((a) => SKIP_FLAGS.has(a)) || SKIP_COMMANDS.has(command) || // `/_npx/` is matched before any package-manager spawn, so skipping `npm root -g` keeps this cheap.
+    detectInstall(host, () => null).method === "npx") {
+      return noop;
+    }
+    const current = VERSION;
+    const file = path.join(host.home, ".tavily", "update-check.json");
+    const notify = (latest) => {
+      try {
+        if (latest === null || !isNewer(latest, current)) return;
+        err();
+        err(
+          colors.dim(`Tavily CLI update available: ${current} -> ${latest}. Run \`tvly update\`.`)
+        );
+      } catch {
+      }
+    };
+    const state = readState(file);
+    if (state && now() - state.checked_at < CHECK_INTERVAL_MS) {
+      return async () => notify(state.latest);
+    }
+    const controller = new AbortController();
+    const pending = fetchLatestVersion(host.fetch, controller.signal).catch(() => null);
+    return async () => {
+      let timer;
+      const latest = await Promise.race([
+        pending,
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, RACE_MS, null);
+        })
+      ]);
+      clearTimeout(timer);
+      controller.abort();
+      writeState(file, { checked_at: now(), latest });
+      notify(latest);
+    };
+  } catch {
+    return noop;
+  }
+}
+
+// src/cli.ts
+async function main(host) {
+  const finishUpdateCheck = startUpdateCheck(host);
+  try {
+    await buildProgram(host).parseAsync(host.argv);
+    return 0;
+  } catch (err2) {
+    if (err2 instanceof ExitError) return err2.code;
+    if (err2 instanceof CommanderError) return err2.exitCode === 0 ? 0 : 2;
+    console.error(`  > Error: ${sanitizeControl(messageOf(err2))}`);
+    return 1;
+  } finally {
+    await finishUpdateCheck();
+  }
+}
+var entry = process.argv[1];
+if (entry && realpathSync(entry) === fileURLToPath(import.meta.url)) {
+  process.stdout.on("error", (err2) => {
+    if (err2.code !== "EPIPE") throw err2;
+    process.exit(0);
+  });
+  process.exitCode = await main(realHost());
+}
+export {
+  main
+};