@ipv9/tokentracker-cli 0.39.0

package/src/commands/uninstall.js

@@ -0,0 +1,189 @@
+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, buildHookCommand } = 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 { removeGrokHook } = require("../lib/grok-hook");
+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 codebuddyDir = process.env.CODEBUDDY_HOME || path.join(home, ".codebuddy");
+  const codebuddySettingsPath = path.join(codebuddyDir, "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 codebuddyHookCommand = buildHookCommand(notifyPath, "codebuddy");
+  const geminiHookCommand = buildGeminiHookCommand(notifyPath);
+
+  const codexConfigExists = await isFile(codexConfigPath);
+  const codeConfigExists = await isFile(codeConfigPath);
+  const claudeConfigExists = await isFile(claudeSettingsPath);
+  const codebuddyConfigExists = await isFile(codebuddySettingsPath);
+  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 codebuddyRemove = codebuddyConfigExists
+    ? await removeClaudeHook({
+        settingsPath: codebuddySettingsPath,
+        hookCommand: codebuddyHookCommand,
+      })
+    : { 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 });
+  const grokHookRemove = await removeGrokHook({ 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)",
+      codebuddyConfigExists
+        ? codebuddyRemove?.removed
+          ? `- CodeBuddy hooks removed: ${codebuddySettingsPath}`
+          : codebuddyRemove?.skippedReason === "hook-missing"
+            ? "- CodeBuddy hooks: no change"
+            : "- CodeBuddy hooks: skipped"
+        : "- CodeBuddy 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",
+      grokHookRemove?.removed
+        ? `- Grok Build hook removed: ${grokHookRemove.hookPath}`
+        : "- Grok Build hook: 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/commands/wrapped.js

@@ -0,0 +1,150 @@
+"use strict";
+
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs");
+
+const { resolveTrackerPaths } = require("../lib/tracker-paths");
+const { aggregateWrapped, formatCompact } = require("../lib/wrapped-aggregator");
+
+async function readQueueRows(queuePath) {
+  if (!fs.existsSync(queuePath)) return [];
+  const raw = await fs.promises.readFile(queuePath, "utf8");
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      rows.push(JSON.parse(line));
+    } catch (_e) {
+      // skip malformed line — production queues sometimes hold a partial
+      // tail row mid-write that becomes valid on the next read.
+    }
+  }
+  return rows;
+}
+
+function parseArgs(argv) {
+  const out = { year: null, json: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--json") out.json = true;
+    else if (a === "--year") {
+      const v = argv[++i];
+      const y = Number(v);
+      if (!Number.isInteger(y) || y < 2000 || y > 2100) {
+        throw new Error(`--year expects a 4-digit year, got: ${v}`);
+      }
+      out.year = y;
+    } else throw new Error(`Unknown option: ${a}`);
+  }
+  return out;
+}
+
+function renderAscii(wrapped) {
+  const lines = [];
+  const w = 60;
+  const border = "═".repeat(w - 2);
+  const center = (s) => {
+    const text = String(s);
+    const padTotal = Math.max(0, w - 2 - text.length);
+    const left = Math.floor(padTotal / 2);
+    const right = padTotal - left;
+    return `║${" ".repeat(left)}${text}${" ".repeat(right)}║`;
+  };
+  const row = (label, value) => {
+    const text = `  ${label}: ${value}`;
+    const right = Math.max(0, w - 2 - text.length);
+    return `║${text}${" ".repeat(right)}║`;
+  };
+
+  lines.push(`╔${border}╗`);
+  lines.push(center(""));
+  lines.push(center(`TokenTracker Wrapped · ${wrapped.year}`));
+  lines.push(center(""));
+  lines.push(`╠${border}╣`);
+  lines.push(row("Total tokens", formatCompact(wrapped.totals.tokens)));
+  lines.push(row("Conversations", wrapped.totals.conversations.toLocaleString("en-US")));
+  lines.push(row("Active days", `${wrapped.totals.active_days} / 365`));
+  lines.push(row("Tools used", String(wrapped.totals.sources)));
+  lines.push(row("Models used", String(wrapped.totals.models)));
+  if (wrapped.peak_hour) {
+    lines.push(
+      row(
+        "Peak hour",
+        `${String(wrapped.peak_hour.hour).padStart(2, "0")}:00 UTC (${formatCompact(wrapped.peak_hour.tokens)})`,
+      ),
+    );
+  }
+  if (wrapped.longest_streak.days > 0) {
+    lines.push(
+      row("Longest streak", `${wrapped.longest_streak.days} days (${wrapped.longest_streak.from} → ${wrapped.longest_streak.to})`),
+    );
+  }
+  lines.push(`╠${border}╣`);
+
+  if (wrapped.top.sources.length > 0) {
+    lines.push(row("Top tools", ""));
+    for (const s of wrapped.top.sources.slice(0, 3)) {
+      lines.push(row(`  ${s.source}`, `${formatCompact(s.tokens)} (${(s.share * 100).toFixed(0)}%)`));
+    }
+  }
+  if (wrapped.top.models.length > 0) {
+    lines.push(`╠${border}╣`);
+    lines.push(row("Top models", ""));
+    for (const m of wrapped.top.models.slice(0, 3)) {
+      lines.push(row(`  ${m.model}`, `${formatCompact(m.tokens)} (${(m.share * 100).toFixed(0)}%)`));
+    }
+  }
+  if (wrapped.top.days.length > 0) {
+    lines.push(`╠${border}╣`);
+    lines.push(row("Top days", ""));
+    for (const d of wrapped.top.days.slice(0, 3)) {
+      lines.push(row(`  ${d.day}`, formatCompact(d.tokens)));
+    }
+  }
+  if (wrapped.highlights.length > 0) {
+    lines.push(`╠${border}╣`);
+    const max = w - 4; // 2 borders + 2 padding
+    for (const h of wrapped.highlights) {
+      // Wrap long highlights into multiple rows.
+      for (let start = 0; start < h.length; start += max) {
+        const segment = h.slice(start, start + max);
+        const padded = ` ${segment}`;
+        const right = Math.max(0, w - 2 - padded.length);
+        lines.push(`║${padded}${" ".repeat(right)}║`);
+      }
+    }
+  }
+  lines.push(`╚${border}╝`);
+  return lines.join("\n");
+}
+
+async function cmdWrapped(argv = []) {
+  const opts = parseArgs(argv);
+  const home = os.homedir();
+  const { trackerDir } = await resolveTrackerPaths({ home });
+  const queuePath = path.join(trackerDir, "queue.jsonl");
+
+  const rows = await readQueueRows(queuePath);
+  if (rows.length === 0) {
+    if (opts.json) {
+      process.stdout.write(JSON.stringify({ error: "no data" }, null, 2) + "\n");
+    } else {
+      process.stdout.write(
+        "No queue data found yet. Run `tracker sync` first to ingest some history.\n",
+      );
+    }
+    return;
+  }
+
+  const wrapped = aggregateWrapped(rows, opts.year ? { year: opts.year } : {});
+
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(wrapped, null, 2) + "\n");
+    return;
+  }
+
+  process.stdout.write(renderAscii(wrapped) + "\n");
+}
+
+module.exports = { cmdWrapped };

package/src/lib/antigravity-paths.js

@@ -0,0 +1,48 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const MAIN_APP_SUBDIR = "antigravity";
+const IDE_SUBDIR = "antigravity-ide";
+
+function geminiHome(env) {
+  return path.join(env.HOME || env.USERPROFILE || os.homedir(), ".gemini");
+}
+
+function trimmed(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function existsDir(dirPath) {
+  try {
+    return fs.statSync(dirPath).isDirectory();
+  } catch (_e) {
+    return false;
+  }
+}
+
+function resolveAntigravitySkillDirs(env = process.env) {
+  const override = trimmed(env.TOKENTRACKER_ANTIGRAVITY_HOME);
+  if (override) return [path.join(override, "skills")];
+
+  const home = geminiHome(env);
+  const mainSkills = path.join(home, MAIN_APP_SUBDIR, "skills");
+  const ideSkills = path.join(home, IDE_SUBDIR, "skills");
+  const mainParent = path.join(home, MAIN_APP_SUBDIR);
+  const ideParent = path.join(home, IDE_SUBDIR);
+
+  const dirs = [];
+  if (existsDir(mainParent)) dirs.push(mainSkills);
+  if (existsDir(ideParent)) dirs.push(ideSkills);
+
+  // Neither Antigravity install present: fall back to the main-app path so
+  // targetList still surfaces a stable path string and the user can install
+  // skills now and run Antigravity later. The empty parent will be created on
+  // demand by ensureDir; cleanup happens naturally via uninstallSkill.
+  if (dirs.length > 0) return dirs;
+  return [mainSkills];
+}
+
+module.exports = {
+  resolveAntigravitySkillDirs,
+};

package/src/lib/browser-auth.js

@@ -0,0 +1,281 @@
+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 = `/tokentracker/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 detectDefaultBrowser() {
+  try {
+    const raw = cp.execFileSync("defaults", [
+      "read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers",
+    ], { encoding: "utf8", timeout: 3000 });
+    const match = raw.match(/https[\s\S]*?LSHandlerRoleAll\s*=\s*"([^"]+)"/);
+    if (!match) return null;
+    const bundleId = match[1].toLowerCase();
+    if (bundleId.includes("chrome")) return "Google Chrome";
+    if (bundleId.includes("safari")) return "Safari";
+    if (bundleId.includes("edgemac")) return "Microsoft Edge";
+    if (bundleId.includes("thebrowser") || bundleId.includes("arc")) return "Arc";
+    return null;
+  } catch (_e) {
+    return null;
+  }
+}
+
+function buildBrowserList() {
+  const all = ["Google Chrome", "Safari", "Microsoft Edge", "Arc"];
+  const def = detectDefaultBrowser();
+  if (!def) return all;
+  return [def, ...all.filter((b) => b !== def)];
+}
+
+function openInBrowser(url) {
+  const platform = process.platform;
+
+  if (platform === "darwin") {
+    // On macOS, prefer reusing a matching tab in a supported running browser.
+    // Supported browsers are checked with the user's default browser first.
+    const browsers = buildBrowserList();
+    const listLiteral = browsers.map((b) => `"${b}"`).join(", ");
+    const script = `
+tell application "System Events"
+  set browserList to {${listLiteral}}
+  set runningBrowser to ""
+  repeat with b in browserList
+    if (exists process (b as text)) then
+      set runningBrowser to (b as text)
+      exit repeat
+    end if
+  end repeat
+end tell
+
+if runningBrowser is "" then
+  open location "${url}"
+else if runningBrowser is "Google Chrome" then
+  tell application "Google Chrome"
+    set found to false
+    repeat with w in windows
+      set tabIndex to 0
+      repeat with t in tabs of w
+        set tabIndex to tabIndex + 1
+        if URL of t starts with "${url}" then
+          set active tab index of w to tabIndex
+          set index of w to 1
+          reload t
+          activate
+          set found to true
+          exit repeat
+        end if
+      end repeat
+      if found then exit repeat
+    end repeat
+    if not found then
+      open location "${url}"
+      activate
+    end if
+  end tell
+else if runningBrowser is "Safari" then
+  tell application "Safari"
+    set found to false
+    repeat with w in windows
+      set tabIndex to 0
+      repeat with t in tabs of w
+        set tabIndex to tabIndex + 1
+        if URL of t starts with "${url}" then
+          set current tab of w to t
+          set index of w to 1
+          do JavaScript "location.reload()" in t
+          activate
+          set found to true
+          exit repeat
+        end if
+      end repeat
+      if found then exit repeat
+    end repeat
+    if not found then
+      open location "${url}"
+      activate
+    end if
+  end tell
+else
+  open location "${url}"
+end if
+`;
+    try {
+      const child = cp.spawn("osascript", ["-e", script], { stdio: "ignore", detached: true });
+      child.unref();
+    } catch (_e) {
+      // Fallback to plain open
+      try {
+        const child = cp.spawn("open", [url], { stdio: "ignore", detached: true });
+        child.unref();
+      } catch (_e2) {}
+    }
+    return;
+  }
+
+  let cmd = null;
+  let args = [];
+
+  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,
+};