@tavily/cli 0.0.0-stage → 1.0.0

package/dist/research-PU3YJMQM.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+import {
+  emit,
+  emitIfRequested,
+  footer,
+  invoke,
+  list,
+  readQueryArg,
+  resolveOutput
+} from "./chunk-KQFC5TMG.js";
+import "./chunk-U3B7BNFI.js";
+import {
+  spinner,
+  withSpinner
+} from "./chunk-K76OUMXM.js";
+import {
+  isTerminal,
+  plain,
+  renderMarkdown,
+  sanitizeControl,
+  table
+} from "./chunk-QHWWSCVM.js";
+import "./chunk-AERAIFZU.js";
+import {
+  resolveJson
+} from "./chunk-IRCF6F3S.js";
+import {
+  colors,
+  err,
+  out
+} from "./chunk-E4N27QWM.js";
+import {
+  messageOf
+} from "./chunk-5JXZZSLS.js";
+
+// src/commands/research.ts
+import { readFileSync } from "fs";
+
+// src/ui/render/research.ts
+async function printResearchResult(data, opts) {
+  if (emitIfRequested(data, opts)) return;
+  const terminal = isTerminal(process.stdout);
+  const style = (paint, s) => terminal ? paint(s) : s;
+  const status2 = data.status ?? "unknown";
+  const content = data.content;
+  const sources = list(data.sources);
+  if (status2 !== "completed") {
+    out(`${style(colors.bold, "Status: ")}${sanitizeControl(status2)}`);
+    if (data.error) out(`${style(colors.pink, "Error: ")}${sanitizeControl(data.error)}`);
+    return;
+  }
+  if (!terminal) {
+    if (content) out(`${plain(content)}
+`);
+    if (sources.length > 0) {
+      out("Sources:");
+      sources.forEach((s, i) => {
+        out(`${i + 1}. ${plain(s.title ?? "")} ${plain(s.url ?? "")}`);
+      });
+    }
+    return;
+  }
+  if (content) {
+    out();
+    out(`  ${colors.bold(colors.aqua("Research Report"))}`);
+    out();
+    out(await renderMarkdown(String(content)));
+  }
+  if (sources.length > 0) {
+    out();
+    out(colors.bold(`Sources (${sources.length})`));
+    const rows = sources.map((s, i) => [
+      String(i + 1),
+      sanitizeControl(s.title ?? ""),
+      sanitizeControl(s.url ?? "")
+    ]);
+    out(table(["#", "Title", "URL"], rows));
+  }
+  footer(sources.length, "sources", data.response_time);
+}
+
+// src/commands/research.ts
+var SUBCOMMANDS = /* @__PURE__ */ new Set(["run", "status", "poll"]);
+var NEED_ID = /* @__PURE__ */ new Set(["status", "poll"]);
+function normalizeResearchArgs(args) {
+  const [first, next] = args;
+  if (first === void 0) return ["--help"];
+  if (first.startsWith("-")) return args;
+  if (!SUBCOMMANDS.has(first)) return ["run", ...args];
+  if (NEED_ID.has(first)) {
+    const hasPositional = next !== void 0 && !next.startsWith("-");
+    const hasHelp = args.includes("--help") || args.includes("-h");
+    if (!hasPositional && !hasHelp) return ["run", ...args];
+  }
+  return args;
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var isDone = (r) => r.status === "completed" || r.status === "failed";
+async function waitForResult(client, requestId, opts) {
+  const start = Date.now();
+  const deadline = start + opts.timeout * 1e3;
+  const message = () => colors.aqua(`${opts.label}... ${Math.floor((Date.now() - start) / 1e3)}s elapsed`);
+  const live = spinner(message(), !opts.json);
+  try {
+    let nextPoll = start;
+    while (Date.now() < deadline) {
+      live.update(message());
+      if (Date.now() >= nextPoll) {
+        const response = await client.getResearch(requestId);
+        if (isDone(response)) return response;
+        nextPoll = Date.now() + Math.max(1, opts.pollInterval) * 1e3;
+      }
+      await sleep(1e3);
+    }
+    return void 0;
+  } finally {
+    live.stop();
+  }
+}
+async function finishWait(response, requestId, opts, hint = "") {
+  const { json, outputFile } = opts;
+  if (response) return printResearchResult(response, { json, outputFile });
+  if (json) emit({ request_id: requestId, status: "timeout" }, { outputFile, pretty: false });
+  else err(colors.yellow(`Timed out after ${opts.timeout}s.${hint}`));
+}
+async function* streamEvents(payloads) {
+  for await (const payload of payloads) {
+    if (!payload.trim()) continue;
+    try {
+      yield JSON.parse(payload);
+    } catch {
+    }
+  }
+}
+async function renderStream(events, outputFile) {
+  const parts = [];
+  let sources = [];
+  let currentStep;
+  for await (const event of events) {
+    const delta = event?.choices?.[0]?.delta ?? {};
+    const toolCalls = delta.tool_calls ?? {};
+    if (toolCalls.type === "tool_call") {
+      for (const tc of toolCalls.tool_call ?? []) {
+        const name = tc.name ?? "";
+        const step = tc.arguments ? `${name}: ${tc.arguments}` : name;
+        if (step !== currentStep) {
+          currentStep = step;
+          err(`  ${colors.dim(sanitizeControl(step))}`);
+        }
+      }
+    }
+    if (toolCalls.type === "tool_response") {
+      for (const tr of toolCalls.tool_response ?? []) {
+        const count = tr.sources?.length ?? 0;
+        if (tr.name === "WebSearch" && count) err(`  ${colors.dim(`Found ${count} sources`)}`);
+      }
+    }
+    if (delta.content) parts.push(delta.content);
+    if (delta.sources?.length) sources = delta.sources;
+  }
+  await printResearchResult(
+    { status: "completed", content: parts.join(""), sources },
+    { json: false, outputFile }
+  );
+}
+async function run(query, opts, cmd, host) {
+  const json = resolveJson(cmd);
+  const input = readQueryArg(query, cmd);
+  const outputFile = resolveOutput(opts.output, "research", input);
+  const body = { input };
+  if (opts.model !== void 0) body.model = opts.model;
+  if (opts.outputSchema !== void 0) {
+    try {
+      body.output_schema = JSON.parse(readFileSync(opts.outputSchema, "utf8"));
+    } catch (e) {
+      cmd.error(`error: --output-schema must be a path to a JSON file: ${messageOf(e)}`);
+    }
+  }
+  if (opts.citationFormat !== void 0) body.citation_format = opts.citationFormat;
+  const call = { keyed: "research", clientName: opts.clientName };
+  if (opts.stream) {
+    await invoke(cmd, host, call, async (client) => {
+      const events = streamEvents(await client.researchStream(body));
+      if (!json) return renderStream(events, outputFile);
+      for await (const event of events) out(JSON.stringify(event));
+    });
+    return;
+  }
+  const render = await invoke(cmd, host, call, async (client) => {
+    const result = await withSpinner("Starting research...", !json, () => client.research(body));
+    if (isDone(result) || result.content) {
+      return () => printResearchResult(result, { json, outputFile });
+    }
+    const requestId = result.request_id;
+    if (typeof requestId !== "string" || !requestId) {
+      throw new Error(`Unexpected API response: ${JSON.stringify(result)}`);
+    }
+    if (opts.wait === false) {
+      const pending = { request_id: requestId, status: result.status ?? "pending" };
+      return () => emit(pending, { outputFile, pretty: false });
+    }
+    const response = await waitForResult(client, requestId, {
+      json,
+      pollInterval: opts.pollInterval,
+      timeout: opts.timeout,
+      label: "Researching"
+    });
+    const hint = ` Resume with: tvly research poll ${sanitizeControl(requestId)}`;
+    return () => finishWait(response, requestId, { json, outputFile, timeout: opts.timeout }, hint);
+  });
+  await render();
+}
+var STATUS_COLORS = {
+  completed: colors.green,
+  failed: colors.pink
+};
+async function status(requestId, opts, cmd, host) {
+  const json = resolveJson(cmd);
+  const response = await invoke(
+    cmd,
+    host,
+    { keyed: "research status", clientName: opts.clientName },
+    (client) => client.getResearch(requestId)
+  );
+  if (json) {
+    emit(response, { pretty: false });
+    return;
+  }
+  const s = String(response.status ?? "unknown");
+  const paint = STATUS_COLORS[s] ?? colors.yellow;
+  const safeId = sanitizeControl(requestId);
+  out(`  ${colors.bold("Request:")}  ${safeId}`);
+  out(`  ${colors.bold("Status:")}   ${paint(sanitizeControl(s))}`);
+  if (s === "completed")
+    out(`  ${colors.dim(`Run 'tvly research poll ${safeId}' to view results.`)}`);
+  else if (s === "failed") {
+    out(`  ${colors.pink("Error:")} ${sanitizeControl(response.error ?? "Unknown error")}`);
+  }
+}
+async function poll(requestId, opts, cmd, host) {
+  const json = resolveJson(cmd);
+  const outputFile = resolveOutput(opts.output, "research", requestId);
+  const label = `Polling research ${sanitizeControl(requestId.slice(0, 8))}`;
+  const response = await invoke(
+    cmd,
+    host,
+    { keyed: "research poll", clientName: opts.clientName },
+    (client) => waitForResult(client, requestId, {
+      json,
+      pollInterval: opts.pollInterval,
+      timeout: opts.timeout,
+      label
+    })
+  );
+  await finishWait(response, requestId, { json, outputFile, timeout: opts.timeout });
+}
+export {
+  normalizeResearchArgs,
+  poll,
+  run,
+  status
+};

package/dist/search-XTAH2SDD.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+import {
+  LIMIT_STATUSES,
+  QUERY_REQUIRED,
+  applySearchFlags,
+  emit,
+  footer,
+  invoke,
+  keylessCapError,
+  list,
+  printKeylessCapHit,
+  readQueryArg,
+  resolveOutput,
+  searchBodyFromOptions
+} from "./chunk-KQFC5TMG.js";
+import "./chunk-U3B7BNFI.js";
+import "./chunk-K76OUMXM.js";
+import {
+  isTerminal,
+  plain,
+  renderMarkdown,
+  safeLink,
+  sanitizeControl,
+  snippet
+} from "./chunk-QHWWSCVM.js";
+import "./chunk-AERAIFZU.js";
+import {
+  addCommonOptions,
+  parseNumberArg,
+  resolveJson
+} from "./chunk-IRCF6F3S.js";
+import {
+  colors,
+  out
+} from "./chunk-E4N27QWM.js";
+import {
+  ExitError,
+  messageOf
+} from "./chunk-5JXZZSLS.js";
+
+// src/commands/search.ts
+import { TavilyKeylessLimitError, TavilyRequestError } from "@tavily/core";
+import { Option } from "commander";
+
+// src/ui/render/search.ts
+var imageUrl = (img) => typeof img === "object" && img !== null ? img.url ?? JSON.stringify(img) : img;
+async function printSearchResults(data, opts) {
+  const maxChars = opts.maxChars ?? 600;
+  if (opts.json || opts.outputFile) {
+    emit(data, { outputFile: opts.outputFile, pretty: true });
+    if (opts.json || isTerminal(process.stdout)) return;
+  }
+  const results = list(data.results);
+  const images = list(data.images);
+  const answer = data.answer;
+  if (!isTerminal(process.stdout)) {
+    if (answer) out(`Answer: ${plain(answer)}
+`);
+    results.forEach((r, i) => {
+      out(`${i + 1}. ${plain(r.title || "Untitled")}`);
+      out(plain(r.url ?? ""));
+      if (r.content) out(snippet(r.content, maxChars));
+      out();
+    });
+    if (results.length === 0) out("No results found.");
+    for (const img of images) out(`Image: ${plain(imageUrl(img))}`);
+    return;
+  }
+  if (answer) {
+    out();
+    out(`  ${colors.bold(colors.aqua("Answer"))}`);
+    out();
+    out(await renderMarkdown(String(answer)));
+    out();
+  }
+  if (results.length === 0) {
+    out(colors.dim("No results found."));
+    return;
+  }
+  results.forEach((r, i) => {
+    const score = typeof r.score === "number" ? colors.dim(` score: ${r.score.toFixed(2)}`) : "";
+    out(
+      `${colors.bold(colors.purple(`${i + 1}. `))}${colors.bold(sanitizeControl(r.title ?? "Untitled"))}  ${score}`
+    );
+    out(`   ${colors.pink(safeLink(r.url ?? "", void 0, { stream: process.stdout }))}`);
+    if (r.content) out(`   ${colors.dim(snippet(r.content, maxChars))}`);
+    out();
+  });
+  footer(results.length, "results", data.response_time);
+  if (images.length > 0) {
+    out();
+    out(colors.bold(`Images (${images.length}):`));
+    for (const img of images) out(`  ${sanitizeControl(imageUrl(img))}`);
+  }
+}
+async function printMultiSearchResults(responses, opts) {
+  if (opts.json || opts.outputFile) {
+    emit(responses, { outputFile: opts.outputFile, pretty: true });
+    if (opts.json || isTerminal(process.stdout)) return;
+  }
+  const terminal = isTerminal(process.stdout);
+  for (const [i, r] of responses.entries()) {
+    const header = `=== [${i + 1}/${responses.length}] ${plain(r.query ?? "")}`;
+    out(terminal ? colors.bold(header) : header);
+    if ("error" in r) {
+      const error = r.error;
+      const text = typeof error === "object" && error !== null ? error.message : error;
+      out(`error: ${plain(text)}
+`);
+    } else {
+      await printSearchResults(r, {
+        json: false,
+        ...opts.maxChars !== void 0 ? { maxChars: opts.maxChars } : {}
+      });
+    }
+  }
+}
+
+// src/commands/search.ts
+var MAX_QUERIES = 5;
+var DEFAULT_CHARS = 600;
+function configure(cmd) {
+  applySearchFlags(cmd);
+  cmd.addOption(
+    new Option(
+      "--max-chars <n>",
+      "Characters of each result's content to print (default 600, shared across queries: 300 each for 2, 200 for 3); 0 prints it whole. --json and -o files keep it whole."
+    ).argParser((raw) => parseNumberArg(raw, { integer: true, minimum: 0 }))
+  );
+  addCommonOptions(cmd);
+}
+function readQueries(args, cmd) {
+  const queries = args.length === 1 && args[0] === "-" ? [readQueryArg("-", cmd)] : args.filter((q) => q.trim());
+  if (queries.length === 0) cmd.error(QUERY_REQUIRED);
+  if (queries.length > MAX_QUERIES) {
+    cmd.error(`error: At most ${MAX_QUERIES} queries per command, got ${queries.length}.`);
+  }
+  return queries;
+}
+async function run(args, opts, cmd, host) {
+  const json = resolveJson(cmd);
+  const queries = readQueries(args, cmd);
+  const outputFile = resolveOutput(opts.output, "search", queries[0]);
+  const maxChars = opts.maxChars ?? Math.floor(DEFAULT_CHARS / queries.length);
+  const body = searchBodyFromOptions(opts);
+  const call = { label: "Searching...", keyed: false, clientName: opts.clientName };
+  if (queries.length === 1) {
+    const response = await invoke(
+      cmd,
+      host,
+      call,
+      (client) => client.search({ query: queries[0], ...body })
+    );
+    await printSearchResults(response, { json, outputFile, maxChars });
+    return;
+  }
+  const capHits = [];
+  let limitHit = false;
+  const responses = await invoke(
+    cmd,
+    host,
+    call,
+    (client) => Promise.all(
+      queries.map(async (query) => {
+        try {
+          return await client.search({ query, ...body });
+        } catch (e) {
+          if (e instanceof TavilyKeylessLimitError) {
+            capHits.push(e);
+            return { query, error: keylessCapError(e) };
+          }
+          if (e instanceof TavilyRequestError && LIMIT_STATUSES.has(e.status)) limitHit = true;
+          return { query, error: messageOf(e) };
+        }
+      })
+    )
+  );
+  const [firstCap] = capHits;
+  if (firstCap && !json) {
+    printKeylessCapHit(firstCap);
+    throw new ExitError(3);
+  }
+  await printMultiSearchResults(responses, { json, outputFile, maxChars });
+  if (responses.every((r) => "error" in r)) {
+    throw new ExitError(capHits.length > 0 || limitHit ? 3 : 4);
+  }
+}
+export {
+  configure,
+  run
+};

package/dist/setup-JNKIKMOX.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import {
+  AGENT_NAMES
+} from "./chunk-HQ7QBZ5H.js";
+import {
+  MCP_AUTH_NOTE,
+  detectAgents,
+  installMcp
+} from "./chunk-ULNXDG4Q.js";
+import {
+  sanitizeControl
+} from "./chunk-QHWWSCVM.js";
+import {
+  resolveJson
+} from "./chunk-IRCF6F3S.js";
+import {
+  colors,
+  out
+} from "./chunk-E4N27QWM.js";
+import {
+  ExitError
+} from "./chunk-5JXZZSLS.js";
+
+// src/commands/setup.ts
+async function runMcp(opts, cmd, host) {
+  const json = resolveJson(cmd);
+  const requested = opts.agent ?? [];
+  const agents = requested.includes("all") ? [...AGENT_NAMES] : requested.length ? [...new Set(requested)] : detectAgents(host);
+  const result = await installMcp(agents, opts.keyless === true, host);
+  const ok = agents.length === 0 || result.configured.length > 0;
+  printMcp(result, ok, json);
+  if (!ok) throw new ExitError(1);
+}
+function printMcp(result, ok, json) {
+  if (json) {
+    out(JSON.stringify({ ok, ...result }));
+    return;
+  }
+  for (const agent of result.configured) {
+    out(`  ${colors.green("\u2713")} ${agent}: Tavily MCP server added`);
+  }
+  for (const { agent, reason } of result.skipped) {
+    out(`  ${colors.dim("\u2022")} ${agent}: skipped (${sanitizeControl(reason)})`);
+  }
+  if (result.configured.length) out(`  ${colors.dim(MCP_AUTH_NOTE[result.auth])}`);
+  else if (!result.skipped.length) {
+    out(`  ${colors.dim("No supported agents detected. Use --agent <name> or --agent all.")}`);
+  }
+}
+export {
+  runMcp
+};

package/dist/site-ZG42IEW7.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import {
+  definedSnake,
+  echoPages,
+  emitIfRequested,
+  footer,
+  invoke,
+  list,
+  resolveOutput,
+  splitCsv
+} from "./chunk-KQFC5TMG.js";
+import "./chunk-U3B7BNFI.js";
+import "./chunk-K76OUMXM.js";
+import {
+  hostOf,
+  isTerminal,
+  plain,
+  safeLink,
+  sanitizeControl,
+  tree
+} from "./chunk-QHWWSCVM.js";
+import "./chunk-AERAIFZU.js";
+import {
+  resolveJson
+} from "./chunk-IRCF6F3S.js";
+import {
+  colors,
+  err,
+  out
+} from "./chunk-E4N27QWM.js";
+import "./chunk-5JXZZSLS.js";
+
+// src/ui/render/crawl.ts
+import { mkdirSync, writeFileSync } from "fs";
+import path from "path";
+function slugOf(url) {
+  let location = url;
+  try {
+    const parsed = new URL(url);
+    location = parsed.host + parsed.pathname.replace(/\/+$/, "") + parsed.search;
+  } catch {
+  }
+  return location.replace(/[^\p{L}\p{N}_\-.]/gu, "_").replace(/^_+|_+$/g, "") || "index";
+}
+function saveCrawlToDir(data, dir) {
+  mkdirSync(dir, { recursive: true });
+  const used = /* @__PURE__ */ new Set();
+  for (const page of list(data.results)) {
+    if (!page.raw_content) continue;
+    const url = page.url ?? "";
+    const slug = slugOf(url);
+    let name = slug;
+    for (let n = 2; used.has(name.toLowerCase()); n++) name = `${slug}-${n}`;
+    used.add(name.toLowerCase());
+    writeFileSync(path.join(dir, `${name}.md`), `# ${url}
+
+${page.raw_content}
+`);
+  }
+  err(`Saved ${used.size} pages to ${dir}/`);
+}
+function printCrawlResults(data, opts) {
+  if (opts.outputDir) {
+    saveCrawlToDir(data, opts.outputDir);
+    emitIfRequested(data, opts);
+    return;
+  }
+  if (emitIfRequested(data, opts)) return;
+  const pages = list(data.results);
+  if (!isTerminal(process.stdout)) {
+    echoPages(pages);
+    return;
+  }
+  const nodes = pages.map((page) => {
+    const url = page.url ?? "";
+    const raw = page.raw_content ?? "";
+    let pathname = url;
+    try {
+      pathname = new URL(url).pathname || "/";
+    } catch {
+    }
+    const label = `${colors.aqua(sanitizeControl(pathname))}${colors.dim(`  (${raw.length.toLocaleString("en-US")} chars)`)}`;
+    const preview = raw.trim().split("\n")[0]?.slice(0, 120);
+    return { label, children: preview ? [colors.dim(sanitizeControl(preview))] : [] };
+  });
+  out(tree(colors.bold(sanitizeControl(data.base_url ?? "")), nodes));
+  footer(pages.length, "pages", data.response_time);
+}
+function printMapResults(data, opts) {
+  if (emitIfRequested(data, opts)) return;
+  const urls = list(data.results);
+  if (!isTerminal(process.stdout)) {
+    for (const url of urls) out(plain(url));
+    return;
+  }
+  out(
+    tree(
+      colors.bold(sanitizeControl(data.base_url ?? "")),
+      urls.map((url) => ({ label: safeLink(url, void 0, { stream: process.stdout }) }))
+    )
+  );
+  footer(urls.length, "URLs", data.response_time);
+}
+
+// src/commands/site.ts
+function siteBody(url, opts) {
+  const body = {
+    url,
+    ...definedSnake(opts, ["maxDepth", "maxBreadth", "limit", "instructions"])
+  };
+  const lists = {
+    select_paths: splitCsv(opts.selectPaths),
+    exclude_paths: splitCsv(opts.excludePaths),
+    select_domains: splitCsv(opts.selectDomains),
+    exclude_domains: splitCsv(opts.excludeDomains)
+  };
+  for (const [key, value] of Object.entries(lists)) if (value) body[key] = value;
+  const allowExternal = opts.external === false ? false : opts.allowExternal;
+  if (allowExternal !== void 0) body.allow_external = allowExternal;
+  return { ...body, ...definedSnake(opts, ["timeout"]) };
+}
+async function runCrawl(url, opts, cmd, host) {
+  const json = resolveJson(cmd);
+  const outputFile = resolveOutput(opts.output, "crawl", hostOf(url));
+  const body = {
+    ...siteBody(url, opts),
+    ...definedSnake(opts, ["chunksPerSource", "extractDepth", "format", "includeImages"])
+  };
+  const response = await invoke(
+    cmd,
+    host,
+    { label: `Crawling ${url}...`, keyed: "crawl", clientName: opts.clientName },
+    (client) => client.crawl(body)
+  );
+  await printCrawlResults(response, { json, outputFile, outputDir: opts.outputDir });
+}
+async function runMap(url, opts, cmd, host) {
+  const json = resolveJson(cmd);
+  const outputFile = resolveOutput(opts.output, "map", hostOf(url));
+  const response = await invoke(
+    cmd,
+    host,
+    { label: `Mapping ${url}...`, keyed: "map", clientName: opts.clientName },
+    (client) => client.map(siteBody(url, opts))
+  );
+  await printMapResults(response, { json, outputFile });
+}
+export {
+  runCrawl,
+  runMap
+};

package/dist/status-UAAZ7CBV.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import {
+  VERSION
+} from "./chunk-SPBOEASO.js";
+import {
+  getApiKeyOrExit
+} from "./chunk-U3B7BNFI.js";
+import "./chunk-QHWWSCVM.js";
+import {
+  authSource
+} from "./chunk-AERAIFZU.js";
+import {
+  colors,
+  out
+} from "./chunk-E4N27QWM.js";
+import "./chunk-5JXZZSLS.js";
+
+// src/commands/status.ts
+async function printStatus(json, host) {
+  const key = await getApiKeyOrExit(json, host);
+  if (json) {
+    out(JSON.stringify({ version: VERSION, authenticated: key !== null }));
+    return;
+  }
+  out(`  ${colors.bold(colors.green("tavily"))} v${VERSION}`);
+  out();
+  if (key !== null) {
+    out(`  ${colors.green(">")} Authenticated via ${authSource(key, host.env)}`);
+  } else {
+    out(`  ${colors.pink(">")} Not authenticated`);
+    out("    Run: tvly login");
+  }
+}
+export {
+  printStatus
+};