replicate-token-verification 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Duan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,147 @@
+# replicate-token-verification
+
+一个基于主流 CLI 库的 Node.js 中文命令行工具，用来快速判断给定的 Replicate API Token 当前能不能直接使用。
+
+支持两种使用方式：
+
+- 交互式启动后手动输入 Token
+- 一键执行，直接通过参数或环境变量传入 Token
+
+## 环境要求
+
+- Node.js 20.12+
+
+## 安装
+
+在当前目录下直接运行：
+
+```bash
+node ./bin/replicate-token-verification.js
+node ./bin/replicate-token-verification.js --token r8_xxx
+```
+
+或者安装为全局命令：
+
+```bash
+npm install -g .
+rtv
+```
+
+发布到 npm 后，也可以直接全局安装：
+
+```bash
+npm install -g replicate-token-verification
+rtv
+```
+
+## 基本用法
+
+```bash
+rtv
+rtv --token <token>
+rtv <token>
+REPLICATE_API_TOKEN=<token> rtv
+```
+
+## 可用选项
+
+```bash
+--json      输出 JSON，适合脚本调用
+--quiet     仅输出最终结果
+--no-loop   交互模式下只校验一次后退出
+--no-model-test   跳过调用测试，只检查认证状态和账号状态
+```
+
+## 交互模式
+
+直接运行：
+
+```bash
+rtv
+```
+
+CLI 会提示你输入 Token，输入后按回车即可开始校验。
+输入过程会明文显示 Token，每次校验完成后会询问是否继续校验下一个 Token。
+
+如果你只想交互校验一次：
+
+```bash
+rtv --no-loop
+```
+
+## 一键执行
+
+```bash
+rtv --token r8_xxx
+rtv r8_xxx
+REPLICATE_API_TOKEN=r8_xxx rtv
+rtv --token r8_xxx --quiet
+```
+
+## 脚本调用
+
+如果你希望给脚本或 CI 使用：
+
+```bash
+rtv --token r8_xxx --json
+```
+
+`--json` 模式下会输出这些核心字段：
+
+- `usabilityStatus`：当前 Token 是否可直接使用
+- `authStatus`：认证是否通过
+- `accountStatus`：账号状态
+- `modelStatus`：调用测试结果
+
+如果你更偏向直接执行，也可以这样：
+
+```bash
+npx replicate-token-verification --token r8_xxx
+```
+
+如果你只想检查认证状态和账号状态，不做调用测试：
+
+```bash
+rtv --token r8_xxx --no-model-test
+```
+
+## 返回码说明
+
+- 当前 Token 可直接使用：退出码 `0`
+- 当前 Token 不可直接使用：退出码 `1`
+- 请求失败、结果未知或缺少 Token：退出码 `1`
+
+## 校验原理
+
+CLI 默认会执行两段校验：
+
+1. 请求 `GET /v1/account` 判断认证是否通过，以及账号当前是否可用
+2. 使用 `replicate/hello-world` 做一次最小调用测试，判断这个 Token 是否具备实际调用模型的能力
+
+返回结果会区分：
+
+- `可直接使用`：可直接使用 / 不可直接使用 / 大概率可直接使用 / 未知
+- `认证状态`：已通过 / 未通过 / 未知
+- `账号状态`：可用 / 账单受限 / 未知
+- `调用测试`：可调用 / 已接受调用 / 因账号账单问题不可调用 / 无权限调用 / 未执行 / 未知
+
+说明：
+
+- 默认会进行真实调用测试，这可能触发一次实际的 Replicate 模型请求
+- 如果你不希望执行调用测试，可以加 `--no-model-test`
+- 普通终端输出会使用颜色高亮状态：通过/可用为绿色，未通过/不可用为红色，未知为黄色
+- 返回详情默认按原始返回内容展示；如果接口返回的是 JSON，会以格式化 JSON 形式展示
+
+## 发布到 npm
+
+这个项目已经具备标准 npm CLI 包结构：
+
+- `bin` 字段已配置全局命令 `rtv`
+- `files` 仅发布必要文件
+- `publishConfig.access` 已设为 `public`
+
+发布时直接执行：
+
+```bash
+npm publish
+```

package/bin/replicate-token-verification.js

@@ -0,0 +1,671 @@
+#!/usr/bin/env node
+
+import process from "node:process";
+import { confirm, input } from "@inquirer/prompts";
+import { Command } from "commander";
+
+const program = new Command();
+const PROBE_MODEL = "replicate/hello-world";
+const PROBE_INPUT = { text: "codex" };
+const COLOR = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  bold: "\x1b[1m"
+};
+
+program
+  .name("rtv")
+  .description("检查 Replicate API Token 当前是否可直接使用")
+  .argument("[token]", "要检查的 Replicate API Token")
+  .option("-t, --token <token>", "要检查的 Replicate API Token")
+  .option("--json", "输出 JSON 结果，便于脚本调用")
+  .option("-q, --quiet", "仅输出最终结果")
+  .option("--no-loop", "交互模式下只校验一次后退出")
+  .option("--no-model-test", "跳过调用测试，只检查认证状态和账号状态")
+  .helpOption("-h, --help", "显示帮助信息")
+  .showHelpAfterError("(提示：不传参数直接运行可进入交互模式。)")
+  .version("1.0.0", "-V, --version", "显示版本号");
+
+function supportsColor() {
+  return Boolean(process.stdout.isTTY && process.env.NO_COLOR === undefined);
+}
+
+function paint(text, color) {
+  if (!supportsColor()) {
+    return text;
+  }
+
+  return `${color}${text}${COLOR.reset}`;
+}
+
+function formatStatusLabel(status) {
+  if (status === "valid") {
+    return paint("有效", COLOR.green);
+  }
+
+  if (status === "invalid") {
+    return paint("无效", COLOR.red);
+  }
+
+  return paint("失败", COLOR.yellow);
+}
+
+function colorizeValue(value, tone) {
+  if (tone === "good") {
+    return paint(value, COLOR.green);
+  }
+
+  if (tone === "bad") {
+    return paint(value, COLOR.red);
+  }
+
+  if (tone === "warn") {
+    return paint(value, COLOR.yellow);
+  }
+
+  return value;
+}
+
+function formatUsabilitySummary(classification) {
+  if (classification.usabilityStatus === "usable" || classification.usabilityStatus === "probably_usable") {
+    return colorizeValue(classification.usabilitySummary, "good");
+  }
+
+  if (classification.usabilityStatus === "unusable") {
+    return colorizeValue(classification.usabilitySummary, "bad");
+  }
+
+  return colorizeValue(classification.usabilitySummary, "warn");
+}
+
+function formatAuthSummary(classification) {
+  if (classification.authStatus === "passed") {
+    return colorizeValue(classification.authSummary, "good");
+  }
+
+  if (classification.authStatus === "failed") {
+    return colorizeValue(classification.authSummary, "bad");
+  }
+
+  return colorizeValue(classification.authSummary, "warn");
+}
+
+function formatAccountSummary(classification) {
+  if (classification.accountStatus === "active") {
+    return colorizeValue(classification.accountSummary, "good");
+  }
+
+  if (classification.accountStatus === "billing_blocked") {
+    return colorizeValue(classification.accountSummary, "bad");
+  }
+
+  return colorizeValue(classification.accountSummary, "warn");
+}
+
+function formatModelSummary(classification) {
+  if (classification.modelStatus === "callable" || classification.modelStatus === "accepted") {
+    return colorizeValue(classification.modelSummary, "good");
+  }
+
+  if (classification.modelStatus === "unauthorized" || classification.modelStatus === "billing_blocked" || classification.modelStatus === "failed") {
+    return colorizeValue(classification.modelSummary, "bad");
+  }
+
+  return colorizeValue(classification.modelSummary, "warn");
+}
+
+async function verifyToken(token) {
+  const response = await fetch("https://api.replicate.com/v1/account", {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
+    },
+    signal: AbortSignal.timeout(10000)
+  });
+
+  const contentType = response.headers.get("content-type") || "";
+  let payload = null;
+
+  if (contentType.includes("application/json")) {
+    payload = await response.json().catch(() => null);
+  } else {
+    payload = await response.text().catch(() => "");
+  }
+
+  return {
+    ok: response.ok,
+    status: response.status,
+    payload
+  };
+}
+
+async function verifyModelInvocation(token) {
+  const response = await fetch(`https://api.replicate.com/v1/models/${PROBE_MODEL}/predictions`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      Prefer: "wait"
+    },
+    body: JSON.stringify({ input: PROBE_INPUT }),
+    signal: AbortSignal.timeout(20000)
+  });
+
+  const contentType = response.headers.get("content-type") || "";
+  let payload = null;
+
+  if (contentType.includes("application/json")) {
+    payload = await response.json().catch(() => null);
+  } else {
+    payload = await response.text().catch(() => "");
+  }
+
+  return {
+    ok: response.ok,
+    status: response.status,
+    payload
+  };
+}
+
+function extractErrorMessage(payload) {
+  const parsedPayload = parsePayload(payload);
+
+  if (!parsedPayload) return null;
+  if (typeof parsedPayload === "string" && parsedPayload.trim()) return parsedPayload.trim();
+  if (typeof parsedPayload === "object") {
+    if (typeof parsedPayload.detail === "string" && parsedPayload.detail.trim()) return parsedPayload.detail.trim();
+    if (typeof parsedPayload.error === "string" && parsedPayload.error.trim()) return parsedPayload.error.trim();
+    if (typeof parsedPayload.title === "string" && parsedPayload.title.trim()) return parsedPayload.title.trim();
+  }
+  return null;
+}
+
+function parsePayload(payload) {
+  if (typeof payload !== "string") {
+    return payload;
+  }
+
+  const trimmed = payload.trim();
+  if (!trimmed) {
+    return payload;
+  }
+
+  if ((trimmed.startsWith("{") && trimmed.endsWith("}")) || (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return payload;
+    }
+  }
+
+  return payload;
+}
+
+function normalizePayload(payload) {
+  const parsedPayload = parsePayload(payload);
+
+  if (!parsedPayload || typeof parsedPayload !== "object") {
+    return null;
+  }
+
+  return {
+    title: typeof parsedPayload.title === "string" ? parsedPayload.title.trim() : null,
+    detail: typeof parsedPayload.detail === "string" ? parsedPayload.detail.trim() : null,
+    status: typeof parsedPayload.status === "number" ? parsedPayload.status : null
+  };
+}
+
+function getPredictionStatus(payload) {
+  const parsedPayload = parsePayload(payload);
+
+  if (!parsedPayload || typeof parsedPayload !== "object") {
+    return null;
+  }
+
+  return typeof parsedPayload.status === "string" ? parsedPayload.status.trim() : null;
+}
+
+function getPredictionError(payload) {
+  const parsedPayload = parsePayload(payload);
+
+  if (!parsedPayload || typeof parsedPayload !== "object") {
+    return null;
+  }
+
+  return typeof parsedPayload.error === "string" && parsedPayload.error.trim() ? parsedPayload.error.trim() : null;
+}
+
+function formatPayloadForDisplay(payload) {
+  const parsedPayload = parsePayload(payload);
+
+  if (parsedPayload == null) {
+    return null;
+  }
+
+  if (typeof parsedPayload === "string") {
+    return parsedPayload.trim() || null;
+  }
+
+  try {
+    return JSON.stringify(parsedPayload, null, 2);
+  } catch {
+    return String(parsedPayload);
+  }
+}
+
+function classifyAccountResult(result) {
+  if (!result) {
+    return {
+      authStatus: "unknown",
+      authSummary: "未知",
+      accountStatus: "unknown",
+      accountSummary: "未知"
+    };
+  }
+
+  if (result.ok) {
+    return {
+      authStatus: "passed",
+      authSummary: "已通过",
+      accountStatus: "active",
+      accountSummary: "可用"
+    };
+  }
+
+  if (result.status === 401 || result.status === 403) {
+    return {
+      authStatus: "failed",
+      authSummary: "未通过",
+      accountStatus: "unknown",
+      accountSummary: "未知"
+    };
+  }
+
+  if (result.status === 402) {
+    return {
+      authStatus: "passed",
+      authSummary: "已通过",
+      accountStatus: "billing_blocked",
+      accountSummary: "账单受限"
+    };
+  }
+
+  return {
+    authStatus: "unknown",
+    authSummary: "未知",
+    accountStatus: "unknown",
+    accountSummary: "未知"
+  };
+}
+
+function classifyModelResult(result) {
+  if (!result) {
+    return {
+      modelStatus: "unknown",
+      modelSummary: "未知"
+    };
+  }
+
+  const predictionStatus = getPredictionStatus(result.payload);
+  const predictionError = getPredictionError(result.payload);
+
+  if (result.ok && (predictionStatus === "succeeded" || predictionStatus === "successful")) {
+    return {
+      modelStatus: "callable",
+      modelSummary: "可调用"
+    };
+  }
+
+  if (result.ok && (predictionStatus === "starting" || predictionStatus === "processing")) {
+    return {
+      modelStatus: "accepted",
+      modelSummary: "已接受调用"
+    };
+  }
+
+  if (result.status === 402) {
+    return {
+      modelStatus: "billing_blocked",
+      modelSummary: "因账号账单问题不可调用"
+    };
+  }
+
+  if (result.status === 401 || result.status === 403) {
+    return {
+      modelStatus: "unauthorized",
+      modelSummary: "无权限调用"
+    };
+  }
+
+  if (predictionError) {
+    return {
+      modelStatus: "failed",
+      modelSummary: "调用失败"
+    };
+  }
+
+  return {
+    modelStatus: "unknown",
+    modelSummary: "未知"
+  };
+}
+
+function classifyUsability(report) {
+  const accountClassification = classifyAccountResult(report.account);
+  const modelClassification = report.model ? classifyModelResult(report.model) : null;
+
+  if (report.accountError || report.modelError) {
+    return {
+      usabilityStatus: "unknown",
+      usabilitySummary: "未知"
+    };
+  }
+
+  if (accountClassification.authStatus === "failed") {
+    return {
+      usabilityStatus: "unusable",
+      usabilitySummary: "不可直接使用"
+    };
+  }
+
+  if (accountClassification.accountStatus === "billing_blocked") {
+    return {
+      usabilityStatus: "unusable",
+      usabilitySummary: "不可直接使用"
+    };
+  }
+
+  if (report.modelSkipped) {
+    if (accountClassification.authStatus === "passed" && accountClassification.accountStatus === "active") {
+      return {
+        usabilityStatus: "probably_usable",
+        usabilitySummary: "大概率可直接使用"
+      };
+    }
+
+    return {
+      usabilityStatus: "unknown",
+      usabilitySummary: "未知"
+    };
+  }
+
+  if (modelClassification && (modelClassification.modelStatus === "callable" || modelClassification.modelStatus === "accepted")) {
+    return {
+      usabilityStatus: "usable",
+      usabilitySummary: "可直接使用"
+    };
+  }
+
+  if (modelClassification && (modelClassification.modelStatus === "unauthorized" || modelClassification.modelStatus === "billing_blocked" || modelClassification.modelStatus === "failed")) {
+    return {
+      usabilityStatus: "unusable",
+      usabilitySummary: "不可直接使用"
+    };
+  }
+
+  return {
+    usabilityStatus: "unknown",
+    usabilitySummary: "未知"
+  };
+}
+
+function printStructuredPayload(payload, status) {
+  const formattedPayload = formatPayloadForDisplay(payload);
+
+  if (formattedPayload) {
+    console.log("  详情：");
+    console.log(paint(formattedPayload, COLOR.dim));
+  }
+}
+
+function printRequestError(label, error) {
+  console.log(`${label}：未知`);
+  console.log(`  请求异常：${paint(error instanceof Error ? error.message : String(error), COLOR.dim)}`);
+}
+
+function printAccountDetails(result, error) {
+  console.log("认证与账号");
+  if (error) {
+    printRequestError("认证状态", error);
+    console.log("账号状态：未知");
+    return;
+  }
+
+  const classification = classifyAccountResult(result);
+
+  console.log(`认证状态：${formatAuthSummary(classification)}`);
+  console.log(`账号状态：${formatAccountSummary(classification)}`);
+
+  if (!result.ok) {
+    printStructuredPayload(result.payload, result.status);
+  }
+}
+
+function printModelDetails(result, error) {
+  console.log("调用测试");
+  if (error) {
+    printRequestError("调用测试", error);
+    console.log(`探测模型：${PROBE_MODEL}`);
+    return;
+  }
+
+  const classification = classifyModelResult(result);
+  const message = extractErrorMessage(result.payload);
+  const predictionStatus = getPredictionStatus(result.payload);
+  const predictionError = getPredictionError(result.payload);
+
+  console.log(`调用测试：${formatModelSummary(classification)}`);
+  console.log(`探测模型：${PROBE_MODEL}`);
+
+  if (predictionStatus) {
+    console.log(`任务状态：${predictionStatus}`);
+  }
+
+  if (predictionError) {
+    console.log(`  模型错误：${paint(predictionError, COLOR.dim)}`);
+    return;
+  }
+
+  if (!result.ok || classification.modelStatus !== "callable") {
+    printStructuredPayload(result.payload, result.status);
+    return;
+  }
+
+  if (message && predictionStatus !== "succeeded" && predictionStatus !== "successful") {
+    console.log(`  返回：${paint(message, COLOR.dim)}`);
+  }
+}
+
+function printSummary(report, outputJson) {
+  const accountClassification = classifyAccountResult(report.account);
+  const modelClassification = report.model ? classifyModelResult(report.model) : null;
+  const usabilityClassification = classifyUsability(report);
+  const accountMessage = report.account ? extractErrorMessage(report.account.payload) : null;
+  const normalized = report.account ? normalizePayload(report.account.payload) : null;
+
+  if (outputJson) {
+    console.log(JSON.stringify({
+      usabilityStatus: usabilityClassification.usabilityStatus,
+      authStatus: accountClassification.authStatus,
+      accountStatus: accountClassification.accountStatus,
+      modelStatus: report.modelSkipped ? "skipped" : report.modelError ? "unknown" : modelClassification?.modelStatus || "not_run",
+      probeModel: report.modelSkipped ? null : PROBE_MODEL,
+      accountHttpStatus: report.account?.status || null,
+      modelHttpStatus: report.model?.status || null,
+      accountRequestError: report.accountError ? (report.accountError instanceof Error ? report.accountError.message : String(report.accountError)) : null,
+      modelRequestError: report.modelError ? (report.modelError instanceof Error ? report.modelError.message : String(report.modelError)) : null,
+      accountMessage,
+      accountTitle: normalized?.title || null,
+      accountDetail: normalized?.detail || null,
+      modelPredictionStatus: report.model ? getPredictionStatus(report.model.payload) : null,
+      modelError: report.model ? getPredictionError(report.model.payload) : null
+    }, null, 2));
+    return;
+  }
+
+  console.log(paint("校验摘要", COLOR.bold));
+  console.log(`${formatStatusLabel(usabilityClassification.usabilityStatus === "usable" || usabilityClassification.usabilityStatus === "probably_usable" ? "valid" : usabilityClassification.usabilityStatus === "unusable" ? "invalid" : "unknown")}：当前 Token ${formatUsabilitySummary(usabilityClassification)}`);
+  console.log("");
+  printAccountDetails(report.account, report.accountError);
+
+  if (report.modelSkipped) {
+    console.log("");
+    console.log("调用测试：未执行");
+  } else if (report.model) {
+    console.log("");
+    printModelDetails(report.model, report.modelError);
+  } else if (report.modelError) {
+    console.log("");
+    printModelDetails(null, report.modelError);
+  }
+}
+
+function resolveToken(positionalToken, optionsToken) {
+  return optionsToken || positionalToken || process.env.REPLICATE_API_TOKEN || null;
+}
+
+function exitCodeForReport(report) {
+  const accountClassification = classifyAccountResult(report.account);
+  const modelClassification = report.model ? classifyModelResult(report.model) : null;
+
+  if (report.accountError || report.modelError) {
+    return 1;
+  }
+
+  if (accountClassification.authStatus !== "passed") {
+    return 1;
+  }
+
+  if (accountClassification.accountStatus !== "active") {
+    return 1;
+  }
+
+  if (!report.modelSkipped && modelClassification && modelClassification.modelStatus !== "callable" && modelClassification.modelStatus !== "accepted") {
+    return 1;
+  }
+
+  if (report.modelSkipped || !report.model) {
+    return 0;
+  }
+
+  return 0;
+}
+
+async function runVerification(token, options) {
+  try {
+    const modelSkipped = Boolean(options.modelTest === false);
+    const accountPromise = verifyToken(token);
+    const modelPromise = modelSkipped ? Promise.resolve(null) : verifyModelInvocation(token);
+    const [accountResult, modelResult] = await Promise.allSettled([accountPromise, modelPromise]);
+    const report = {
+      account: accountResult.status === "fulfilled" ? accountResult.value : null,
+      accountError: accountResult.status === "rejected" ? accountResult.reason : null,
+      model: modelResult.status === "fulfilled" ? modelResult.value : null,
+      modelError: modelResult.status === "rejected" ? modelResult.reason : null,
+      modelSkipped
+    };
+    printSummary(report, options.json);
+    return exitCodeForReport(report);
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        status: "failed",
+        message: error instanceof Error ? error.message : String(error)
+      }, null, 2));
+    } else {
+      console.error(`${formatStatusLabel("unknown")}：无法完成 Token 校验。`);
+      console.error(paint(error instanceof Error ? error.message : String(error), COLOR.dim));
+    }
+    return 1;
+  }
+}
+
+async function promptForToken() {
+  return input({
+    message: "请输入你的 Replicate API Token",
+    validate(value) {
+      return value.trim() ? true : "Token 不能为空。";
+    }
+  });
+}
+
+async function runInteractive(options) {
+  if (!options.quiet) {
+    console.log(paint("Replicate Token 校验工具", COLOR.bold));
+    console.log(paint("已进入交互模式。", COLOR.cyan));
+  }
+
+  while (true) {
+    const token = (await promptForToken()).trim();
+    if (!options.json && !options.quiet) {
+      console.log(paint("正在校验 Token...", COLOR.dim));
+      if (options.modelTest !== false) {
+        console.log(paint(`将附带执行 ${PROBE_MODEL} 调用测试。`, COLOR.dim));
+      }
+    }
+
+    const exitCode = await runVerification(token, options);
+
+    if (exitCode === 0) {
+      process.exitCode = 0;
+    }
+
+    if (options.loop === false) {
+      return exitCode;
+    }
+
+    const shouldContinue = await confirm({
+      message: "是否继续校验下一个 Token？",
+      default: false
+    });
+
+    if (!shouldContinue) {
+      return exitCode;
+    }
+  }
+}
+
+async function main() {
+  program.parse(process.argv);
+
+  const options = program.opts();
+  const positionalToken = program.args[0];
+  const token = resolveToken(positionalToken, options.token);
+
+  if (token) {
+    if (!options.json && !options.quiet) {
+      console.log(paint("正在校验 Token...", COLOR.dim));
+      if (options.modelTest !== false) {
+        console.log(paint(`将附带执行 ${PROBE_MODEL} 调用测试。`, COLOR.dim));
+      }
+    }
+    process.exitCode = await runVerification(token, options);
+    return;
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.error("缺少 Replicate API Token。请通过参数、选项或 REPLICATE_API_TOKEN 环境变量传入。");
+    process.exitCode = 1;
+    return;
+  }
+
+  try {
+    process.exitCode = await runInteractive(options);
+  } catch (error) {
+    if (error && typeof error === "object" && "name" in error && error.name === "ExitPromptError") {
+      console.error("\n已取消。");
+      process.exitCode = 130;
+      return;
+    }
+
+    throw error;
+  }
+}
+
+await main();

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "replicate-token-verification",
+  "version": "1.0.0",
+  "description": "CLI to check whether a Replicate API token can be directly used",
+  "type": "module",
+  "author": "Duan <hello@duanjun.net>",
+  "homepage": "https://github.com/lenuxo/replicate-token-verification#readme",
+  "bugs": {
+    "url": "https://github.com/lenuxo/replicate-token-verification/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lenuxo/replicate-token-verification.git"
+  },
+  "bin": {
+    "replicate-token-verification": "./bin/replicate-token-verification.js",
+    "rtv": "./bin/replicate-token-verification.js"
+  },
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node ./bin/replicate-token-verification.js",
+    "check": "node ./bin/replicate-token-verification.js --help",
+    "prepublishOnly": "npm run check"
+  },
+  "keywords": [
+    "replicate",
+    "cli",
+    "token",
+    "verification",
+    "api",
+    "npm",
+    "terminal"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.12"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.3.2",
+    "commander": "^14.0.3"
+  }
+}