tokentracker-cli 0.2.23

package/src/commands/uninstall.js

@@ -0,0 +1,167 @@
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs/promises");
+
+const { restoreCodexNotify, restoreEveryCodeNotify } = require("../lib/codex-config");
+const { removeClaudeHook, buildClaudeHookCommand } = require("../lib/claude-config");
+const {
+  resolveGeminiConfigDir,
+  resolveGeminiSettingsPath,
+  buildGeminiHookCommand,
+  removeGeminiHook,
+} = require("../lib/gemini-config");
+const { resolveOpencodeConfigDir, removeOpencodePlugin } = require("../lib/opencode-config");
+const { removeOpenclawHookConfig } = require("../lib/openclaw-hook");
+const { removeOpenclawSessionPluginConfig } = require("../lib/openclaw-session-plugin");
+const { resolveTrackerPaths } = require("../lib/tracker-paths");
+
+async function cmdUninstall(argv) {
+  const opts = parseArgs(argv);
+  const home = os.homedir();
+  const { trackerDir, binDir } = await resolveTrackerPaths({ home });
+  const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
+  const codexConfigPath = path.join(codexHome, "config.toml");
+  const codeHome = process.env.CODE_HOME || path.join(home, ".code");
+  const codeConfigPath = path.join(codeHome, "config.toml");
+  const claudeSettingsPath = path.join(home, ".claude", "settings.json");
+  const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
+  const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
+  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
+  const notifyPath = path.join(binDir, "notify.cjs");
+  const notifyOriginalPath = path.join(trackerDir, "codex_notify_original.json");
+  const codeNotifyOriginalPath = path.join(trackerDir, "code_notify_original.json");
+  const codexNotifyCmd = ["/usr/bin/env", "node", notifyPath];
+  const codeNotifyCmd = ["/usr/bin/env", "node", notifyPath, "--source=every-code"];
+  const claudeHookCommand = buildClaudeHookCommand(notifyPath);
+  const geminiHookCommand = buildGeminiHookCommand(notifyPath);
+
+  const codexConfigExists = await isFile(codexConfigPath);
+  const codeConfigExists = await isFile(codeConfigPath);
+  const claudeConfigExists = await isFile(claudeSettingsPath);
+  const geminiConfigExists = await isDir(geminiConfigDir);
+  const opencodeConfigExists = await isDir(opencodeConfigDir);
+  const codexRestore = codexConfigExists
+    ? await restoreCodexNotify({
+        codexConfigPath,
+        notifyOriginalPath,
+        notifyCmd: codexNotifyCmd,
+      })
+    : { restored: false, skippedReason: "config-missing" };
+  const codeRestore = codeConfigExists
+    ? await restoreEveryCodeNotify({
+        codeConfigPath,
+        notifyOriginalPath: codeNotifyOriginalPath,
+        notifyCmd: codeNotifyCmd,
+      })
+    : { restored: false, skippedReason: "config-missing" };
+  const claudeRemove = claudeConfigExists
+    ? await removeClaudeHook({ settingsPath: claudeSettingsPath, hookCommand: claudeHookCommand })
+    : { removed: false, skippedReason: "config-missing" };
+  const geminiRemove = geminiConfigExists
+    ? await removeGeminiHook({ settingsPath: geminiSettingsPath, hookCommand: geminiHookCommand })
+    : { removed: false, skippedReason: "config-missing" };
+  const opencodeRemove = opencodeConfigExists
+    ? await removeOpencodePlugin({ configDir: opencodeConfigDir })
+    : { removed: false, skippedReason: "config-missing" };
+  const openclawSessionPluginRemove = await removeOpenclawSessionPluginConfig({
+    home,
+    trackerDir,
+    env: process.env,
+  });
+  const openclawHookRemove = await removeOpenclawHookConfig({ home, trackerDir, env: process.env });
+
+  // Remove installed notify handler.
+  await fs.unlink(notifyPath).catch(() => {});
+
+  // Remove local app runtime (installed by init for notify-driven sync).
+  await fs.rm(path.join(trackerDir, "app"), { recursive: true, force: true }).catch(() => {});
+
+  if (opts.purge) {
+    await fs.rm(path.join(home, ".tokentracker"), { recursive: true, force: true }).catch(() => {});
+  }
+
+  process.stdout.write(
+    [
+      "Uninstalled:",
+      codexConfigExists
+        ? codexRestore?.restored
+          ? `- Codex notify restored: ${codexConfigPath}`
+          : codexRestore?.skippedReason === "no-backup-not-installed"
+            ? "- Codex notify: skipped (no backup; not installed)"
+            : "- Codex notify: no change"
+        : "- Codex notify: skipped (config.toml not found)",
+      codeConfigExists
+        ? codeRestore?.restored
+          ? `- Every Code notify restored: ${codeConfigPath}`
+          : codeRestore?.skippedReason === "no-backup-not-installed"
+            ? "- Every Code notify: skipped (no backup; not installed)"
+            : "- Every Code notify: no change"
+        : "- Every Code notify: skipped (config.toml not found)",
+      claudeConfigExists
+        ? claudeRemove?.removed
+          ? `- Claude hooks removed: ${claudeSettingsPath}`
+          : claudeRemove?.skippedReason === "hook-missing"
+            ? "- Claude hooks: no change"
+            : "- Claude hooks: skipped"
+        : "- Claude hooks: skipped (settings.json not found)",
+      geminiConfigExists
+        ? geminiRemove?.removed
+          ? `- Gemini hooks removed: ${geminiSettingsPath}`
+          : geminiRemove?.skippedReason === "hook-missing"
+            ? "- Gemini hooks: no change"
+            : "- Gemini hooks: skipped"
+        : `- Gemini hooks: skipped (${geminiConfigDir} not found)`,
+      opencodeConfigExists
+        ? opencodeRemove?.removed
+          ? `- Opencode plugin removed: ${opencodeConfigDir}`
+          : opencodeRemove?.skippedReason === "plugin-missing"
+            ? "- Opencode plugin: no change"
+            : opencodeRemove?.skippedReason === "unexpected-content"
+              ? "- Opencode plugin: skipped (unexpected content)"
+              : "- Opencode plugin: skipped"
+        : `- Opencode plugin: skipped (${opencodeConfigDir} not found)`,
+      openclawSessionPluginRemove?.removed
+        ? `- OpenClaw session plugin removed: ${openclawSessionPluginRemove.openclawConfigPath}`
+        : openclawSessionPluginRemove?.skippedReason === "openclaw-config-missing"
+          ? "- OpenClaw session plugin: skipped (openclaw config not found)"
+          : "- OpenClaw session plugin: no change",
+      openclawHookRemove?.removed
+        ? `- OpenClaw hook (legacy) removed: ${openclawHookRemove.openclawConfigPath}`
+        : openclawHookRemove?.skippedReason === "openclaw-config-missing"
+          ? "- OpenClaw hook (legacy): skipped (openclaw config not found)"
+          : "- OpenClaw hook (legacy): no change",
+      opts.purge ? `- Purged: ${path.join(home, ".tokentracker")}` : "- Purge: skipped (use --purge)",
+      "",
+    ].join("\n"),
+  );
+}
+
+function parseArgs(argv) {
+  const out = { purge: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--purge") out.purge = true;
+    else throw new Error(`Unknown option: ${a}`);
+  }
+  return out;
+}
+
+module.exports = { cmdUninstall };
+
+async function isFile(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isFile();
+  } catch (_e) {
+    return false;
+  }
+}
+
+async function isDir(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isDirectory();
+  } catch (_e) {
+    return false;
+  }
+}

package/src/lib/activation-check.js

@@ -0,0 +1,341 @@
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs/promises");
+const { readJson } = require("./fs");
+
+/**
+ * 跨 AI CLI 自动激活检测
+ * 在 vibeusage 各种命令执行时顺带检测并完成配置
+ */
+
+const AI_CLIS = [
+  {
+    name: "codex",
+    displayName: "Codex",
+    checkInstalled: checkCodexInstalled,
+    checkConfigured: checkCodexConfigured,
+    configure: configureCodex,
+  },
+  {
+    name: "claude-code",
+    displayName: "Claude Code", 
+    checkInstalled: checkClaudeCodeInstalled,
+    checkConfigured: checkClaudeCodeConfigured,
+    configure: configureClaudeCode,
+  },
+  {
+    name: "opencode",
+    displayName: "OpenCode",
+    checkInstalled: checkOpencodeInstalled,
+    checkConfigured: checkOpencodeConfigured,
+    configure: configureOpencode,
+  },
+  {
+    name: "every-code",
+    displayName: "Every Code",
+    checkInstalled: checkEveryCodeInstalled,
+    checkConfigured: checkEveryCodeConfigured,
+    configure: configureEveryCode,
+  },
+  {
+    name: "openclaw",
+    displayName: "OpenClaw",
+    checkInstalled: checkOpenclawInstalled,
+    checkConfigured: checkOpenclawConfigured,
+    configure: configureOpenclaw,
+  },
+];
+
+/**
+ * 检测所有 AI CLI 并自动配置未完成的
+ * @param {Object} options
+ * @param {string} options.home - home目录
+ * @param {boolean} options.silent - 是否静默模式
+ * @param {boolean} options.autoConfigure - 是否自动配置（否则仅提示）
+ */
+async function checkAndActivate({ home = os.homedir(), silent = true, autoConfigure = true } = {}) {
+  const results = [];
+  
+  for (const cli of AI_CLIS) {
+    try {
+      const isInstalled = await cli.checkInstalled({ home });
+      if (!isInstalled) continue;
+      
+      const isConfigured = await cli.checkConfigured({ home });
+      if (isConfigured) continue;
+      
+      // 发现已安装但未配置的 CLI
+      if (autoConfigure) {
+        const success = await cli.configure({ home, silent });
+        results.push({
+          name: cli.name,
+          displayName: cli.displayName,
+          action: success ? "configured" : "failed",
+        });
+        
+        if (!silent && success) {
+          console.log(`✅ 已自动配置 ${cli.displayName} 集成`);
+        }
+      } else {
+        results.push({
+          name: cli.name,
+          displayName: cli.displayName,
+          action: "pending",
+        });
+        
+        if (!silent) {
+          console.log(`⏳ 检测到 ${cli.displayName} 未配置，运行 'vibeusage init' 以配置`);
+        }
+      }
+    } catch (err) {
+      // 静默忽略错误，不影响主流程
+      if (!silent) {
+        console.error(`检查 ${cli.displayName} 失败:`, err.message);
+      }
+    }
+  }
+  
+  return results;
+}
+
+// ===== Codex 检测与配置 =====
+
+async function checkCodexInstalled({ home }) {
+  const configPath = path.join(home, ".codex", "config.toml");
+  try {
+    await fs.access(configPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkCodexConfigured({ home }) {
+  const configPath = path.join(home, ".codex", "config.toml");
+  try {
+    const content = await fs.readFile(configPath, "utf8");
+    // 检查是否已配置 notify
+    return content.includes("vibeusage") || content.includes("notify");
+  } catch {
+    return false;
+  }
+}
+
+async function configureCodex({ home, silent }) {
+  try {
+    // 使用现有的 codex-config 模块
+    const { upsertCodexNotify } = require("./codex-config");
+    const notifyCmd = path.join(home, ".vibeusage", "bin", "notify.cjs");
+    const codexConfigPath = path.join(home, ".codex", "config.toml");
+    const notifyOriginalPath = path.join(home, ".vibeusage", "backups", "codex-notify-original.json");
+    
+    await upsertCodexNotify({
+      codexConfigPath,
+      notifyCmd,
+      notifyOriginalPath,
+    });
+    return true;
+  } catch (err) {
+    if (!silent) console.error("配置 Codex 失败:", err.message);
+    return false;
+  }
+}
+
+// ===== Claude Code 检测与配置 =====
+
+async function checkClaudeCodeInstalled({ home }) {
+  const settingsPath = path.join(home, ".claude", "settings.json");
+  try {
+    await fs.access(settingsPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkClaudeCodeConfigured({ home }) {
+  const settingsPath = path.join(home, ".claude", "settings.json");
+  try {
+    const settings = await readJson(settingsPath);
+    // 检查是否已有 vibeusage 相关的 hook
+    const hooks = settings?.hooks?.SessionStart || [];
+    return hooks.some(h => 
+      h.hooks?.some(hook => hook.command?.includes("vibeusage"))
+    );
+  } catch {
+    return false;
+  }
+}
+
+async function configureClaudeCode({ home, silent }) {
+  try {
+    const settingsPath = path.join(home, ".claude", "settings.json");
+    const settings = (await readJson(settingsPath)) || {};
+    
+    // 添加 SessionStart hook
+    if (!settings.hooks) settings.hooks = {};
+    if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
+    
+    // 检查是否已存在
+    const exists = settings.hooks.SessionStart.some(h => 
+      h.matcher === "startup" && 
+      h.hooks?.some(hook => hook.command?.includes("vibeusage activate-if-needed"))
+    );
+    
+    if (!exists) {
+      settings.hooks.SessionStart.push({
+        matcher: "startup",
+        hooks: [{
+          type: "command",
+          command: "vibeusage activate-if-needed --silent 2>/dev/null || true"
+        }]
+      });
+      
+      await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+    }
+    return true;
+  } catch (err) {
+    if (!silent) console.error("配置 Claude Code 失败:", err.message);
+    return false;
+  }
+}
+
+// ===== OpenCode 检测与配置 =====
+
+async function checkOpencodeInstalled({ home }) {
+  const configPath = path.join(home, ".config", "opencode", "opencode.json");
+  try {
+    await fs.access(configPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkOpencodeConfigured({ home }) {
+  const pluginDir = path.join(home, ".config", "opencode", "plugins");
+  try {
+    const files = await fs.readdir(pluginDir);
+    return files.some(f => f.includes("vibeusage"));
+  } catch {
+    return false;
+  }
+}
+
+async function configureOpencode({ home, silent }) {
+  try {
+    const pluginDir = path.join(home, ".config", "opencode", "plugins");
+    await fs.mkdir(pluginDir, { recursive: true });
+    
+    const pluginPath = path.join(pluginDir, "vibeusage-activation.js");
+    const pluginCode = `export const VibeusageActivation = async ({ $ }) => {
+  return {
+    "session.created": async () => {
+      await $'vibeusage activate-if-needed --silent'.quiet().nothrow();
+    }
+  };
+};`;
+    
+    await fs.writeFile(pluginPath, pluginCode, "utf8");
+    return true;
+  } catch (err) {
+    if (!silent) console.error("配置 OpenCode 失败:", err.message);
+    return false;
+  }
+}
+
+// ===== Every Code 检测与配置 =====
+
+async function checkEveryCodeInstalled({ home }) {
+  const configPath = path.join(home, ".code", "config.toml");
+  try {
+    await fs.access(configPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkEveryCodeConfigured({ home }) {
+  const configPath = path.join(home, ".code", "config.toml");
+  try {
+    const content = await fs.readFile(configPath, "utf8");
+    return content.includes("vibeusage");
+  } catch {
+    return false;
+  }
+}
+
+async function configureEveryCode({ home, silent }) {
+  try {
+    // Every Code 配置类似 Codex
+    const configPath = path.join(home, ".code", "config.toml");
+    let content = "";
+    try {
+      content = await fs.readFile(configPath, "utf8");
+    } catch {
+      content = "";
+    }
+    
+    const notifyCmd = path.join(home, ".vibeusage", "bin", "notify.cjs");
+    const notifyLine = `notify = ["/usr/bin/env", "node", "${notifyCmd}"]`;
+    
+    if (!content.includes("vibeusage")) {
+      content = content.trim() + "\n\n# vibeusage integration\n" + notifyLine + "\n";
+      await fs.writeFile(configPath, content, "utf8");
+    }
+    return true;
+  } catch (err) {
+    if (!silent) console.error("配置 Every Code 失败:", err.message);
+    return false;
+  }
+}
+
+module.exports = {
+  checkAndActivate,
+  AI_CLIS,
+};
+
+// ===== OpenClaw 检测与配置 =====
+
+async function checkOpenclawInstalled({ home }) {
+  const configPath = path.join(home, ".openclaw", "openclaw.json");
+  try {
+    await fs.access(configPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkOpenclawConfigured({ home }) {
+  const { probeOpenclawSessionPluginState } = require("./openclaw-session-plugin");
+  const { resolveTrackerPaths } = require("./tracker-paths");
+  try {
+    const { trackerDir } = await resolveTrackerPaths({ home });
+    const state = await probeOpenclawSessionPluginState({ home, trackerDir, env: process.env });
+    return state?.configured === true;
+  } catch {
+    return false;
+  }
+}
+
+async function configureOpenclaw({ home, silent }) {
+  try {
+    const { installOpenclawSessionPlugin } = require("./openclaw-session-plugin");
+    const { resolveTrackerPaths } = require("./tracker-paths");
+    const { trackerDir } = await resolveTrackerPaths({ home });
+    
+    const result = await installOpenclawSessionPlugin({
+      home,
+      trackerDir,
+      packageName: "vibeusage",
+      env: process.env,
+    });
+    
+    return result?.configured === true;
+  } catch (err) {
+    if (!silent) console.error("配置 OpenClaw 失败:", err.message);
+    return false;
+  }
+}

package/src/lib/browser-auth.js

@@ -0,0 +1,177 @@
+const http = require("node:http");
+const crypto = require("node:crypto");
+const cp = require("node:child_process");
+
+const { DEFAULT_BASE_URL } = require("./runtime-config");
+
+async function beginBrowserAuth({ baseUrl, dashboardUrl, timeoutMs, open }) {
+  const nonce = crypto.randomBytes(16).toString("hex");
+  const callbackPath = `/vibeusage/callback/${nonce}`;
+  const authUrl = dashboardUrl ? new URL("/", dashboardUrl) : new URL("/auth/sign-up", baseUrl);
+  const postAuthRedirect = resolvePostAuthRedirect({ dashboardUrl, authUrl });
+  const { callbackUrl, waitForCallback } = await startLocalCallbackServer({
+    callbackPath,
+    timeoutMs,
+    redirectUrl: postAuthRedirect,
+  });
+  authUrl.searchParams.set("redirect", callbackUrl);
+  if (dashboardUrl && baseUrl && baseUrl !== DEFAULT_BASE_URL) {
+    authUrl.searchParams.set("base_url", baseUrl);
+  }
+
+  if (open !== false) openInBrowser(authUrl.toString());
+
+  return { authUrl: authUrl.toString(), waitForCallback };
+}
+
+async function startLocalCallbackServer({ callbackPath, timeoutMs, redirectUrl }) {
+  let resolved = false;
+  let resolveResult;
+  let rejectResult;
+
+  const resultPromise = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+
+  const server = http.createServer((req, res) => {
+    if (resolved) {
+      res.writeHead(409, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("Already authenticated.\n");
+      return;
+    }
+
+    const method = req.method || "GET";
+    if (method !== "GET") {
+      res.writeHead(405, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("Method not allowed.\n");
+      return;
+    }
+
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    if (url.pathname !== callbackPath) {
+      res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("Not found.\n");
+      return;
+    }
+
+    const accessToken = url.searchParams.get("access_token") || "";
+    if (!accessToken) {
+      res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("Missing access_token.\n");
+      return;
+    }
+
+    resolved = true;
+    if (redirectUrl) {
+      res.writeHead(302, {
+        Location: redirectUrl,
+        "Content-Type": "text/html; charset=utf-8",
+      });
+      res.end(
+        [
+          "<!doctype html>",
+          '<html><head><meta charset="utf-8"><title>TokenTracker</title></head>',
+          "<body>",
+          "<h2>Login succeeded</h2>",
+          `<p>Redirecting to <a href="${redirectUrl}">dashboard</a>...</p>`,
+          "</body></html>",
+        ].join(""),
+      );
+    } else {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(
+        [
+          "<!doctype html>",
+          '<html><head><meta charset="utf-8"><title>TokenTracker</title></head>',
+          "<body>",
+          "<h2>Login succeeded</h2>",
+          "<p>You can close this tab and return to the CLI.</p>",
+          "</body></html>",
+        ].join(""),
+      );
+    }
+
+    resolveResult({
+      accessToken,
+      userId: url.searchParams.get("user_id") || null,
+      email: url.searchParams.get("email") || null,
+      name: url.searchParams.get("name") || null,
+    });
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+
+  const addr = server.address();
+  const port = typeof addr === "object" && addr ? addr.port : null;
+  if (!port) {
+    server.close();
+    throw new Error("Failed to bind local callback server");
+  }
+
+  const callbackUrl = `http://127.0.0.1:${port}${callbackPath}`;
+
+  const timer = setTimeout(() => {
+    if (resolved) return;
+    resolved = true;
+    rejectResult(new Error("Authentication timed out"));
+    server.close();
+  }, timeoutMs);
+
+  async function waitForCallback() {
+    try {
+      return await resultPromise;
+    } finally {
+      clearTimeout(timer);
+      server.close();
+    }
+  }
+
+  return { callbackUrl, waitForCallback };
+}
+
+function openInBrowser(url) {
+  const platform = process.platform;
+
+  let cmd = null;
+  let args = [];
+
+  if (platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    cmd = "cmd";
+    args = ["/c", "start", "", url];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+
+  try {
+    const child = cp.spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.unref();
+  } catch (_e) {}
+}
+
+function resolvePostAuthRedirect({ dashboardUrl, authUrl }) {
+  try {
+    if (dashboardUrl) {
+      const target = new URL("/", dashboardUrl);
+      if (target.protocol === "http:" || target.protocol === "https:") {
+        return target.toString();
+      }
+      return null;
+    }
+  } catch (_e) {
+    return null;
+  }
+  return null;
+}
+
+module.exports = {
+  beginBrowserAuth,
+  openInBrowser,
+};