@ipv9/tokentracker-cli 0.39.0

package/src/lib/progress.js

@@ -0,0 +1,76 @@
+function createProgress({ stream } = {}) {
+  const out = stream || process.stdout;
+  const enabled = Boolean(out && out.isTTY);
+  const frames = ["|", "/", "-", "\\"];
+  const intervalMs = 90;
+
+  let timer = null;
+  let text = "";
+  let frame = 0;
+  let lastLen = 0;
+
+  function render() {
+    if (!enabled) return;
+    const line = `${frames[frame++ % frames.length]} ${text}`;
+    const pad = lastLen > line.length ? " ".repeat(lastLen - line.length) : "";
+    lastLen = line.length;
+    out.write(`\r${line}${pad}`);
+  }
+
+  function start(initialText) {
+    if (!enabled) return;
+    text = initialText || "";
+    if (timer) clearInterval(timer);
+    timer = setInterval(render, intervalMs);
+    render();
+  }
+
+  function update(nextText) {
+    text = nextText || "";
+    render();
+  }
+
+  function stop() {
+    if (!enabled) return;
+    if (timer) clearInterval(timer);
+    timer = null;
+    out.write(`\r${" ".repeat(lastLen)}\r`);
+    lastLen = 0;
+  }
+
+  return { enabled, start, update, stop };
+}
+
+function renderBar(progress, width = 20) {
+  const p = Number.isFinite(progress) ? Math.min(1, Math.max(0, progress)) : 0;
+  const filled = Math.round(p * width);
+  const empty = Math.max(0, width - filled);
+  return `[${"=".repeat(filled)}${"-".repeat(empty)}] ${Math.round(p * 100)}%`;
+}
+
+function formatNumber(n) {
+  const v = Number(n);
+  if (!Number.isFinite(v)) return "0";
+  return Math.trunc(v).toLocaleString("en-US");
+}
+
+function formatBytes(bytes) {
+  const n = Number(bytes);
+  if (!Number.isFinite(n) || n <= 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let v = n;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i += 1;
+  }
+  const fixed = i === 0 ? String(Math.trunc(v)) : v.toFixed(v >= 10 ? 1 : 2);
+  return `${fixed} ${units[i]}`;
+}
+
+module.exports = {
+  createProgress,
+  renderBar,
+  formatNumber,
+  formatBytes,
+};

package/src/lib/project-usage-purge.js

@@ -0,0 +1,106 @@
+const fs = require("node:fs");
+const fsp = require("node:fs/promises");
+const path = require("node:path");
+const readline = require("node:readline");
+
+async function purgeProjectUsage({
+  projectKey,
+  projectQueuePath,
+  projectQueueStatePath,
+  projectState,
+}) {
+  if (!projectKey || !projectQueuePath || !projectQueueStatePath || !projectState) {
+    return { removed: 0, kept: 0, removedBuckets: 0 };
+  }
+
+  let previousOffset = 0;
+  const previousState = await fsp.readFile(projectQueueStatePath, "utf8").catch(() => null);
+  if (previousState) {
+    try {
+      const parsed = JSON.parse(previousState);
+      const offset = Number(parsed?.offset || 0);
+      if (Number.isFinite(offset) && offset >= 0) previousOffset = offset;
+    } catch (_err) {
+      previousOffset = 0;
+    }
+  }
+
+  const buckets =
+    projectState.buckets && typeof projectState.buckets === "object" ? projectState.buckets : {};
+  let removedBuckets = 0;
+  const prefix = `${projectKey}|`;
+  for (const key of Object.keys(buckets)) {
+    if (key.startsWith(prefix)) {
+      delete buckets[key];
+      removedBuckets += 1;
+    }
+  }
+  projectState.buckets = buckets;
+
+  let removed = 0;
+  let kept = 0;
+  let nextOffset = 0;
+  const st = await fsp.stat(projectQueuePath).catch(() => null);
+  if (st && st.isFile()) {
+    const tmpPath = `${projectQueuePath}.tmp`;
+    await fsp.mkdir(path.dirname(projectQueuePath), { recursive: true });
+    const input = fs.createReadStream(projectQueuePath, "utf8");
+    const output = fs.createWriteStream(tmpPath, { encoding: "utf8" });
+    const rl = readline.createInterface({ input, crlfDelay: Infinity });
+
+    let inputOffset = 0;
+    let outputOffset = 0;
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      const inputBytes = Buffer.byteLength(line, "utf8") + 1;
+      inputOffset += inputBytes;
+      if (!trimmed) continue;
+      let parsed = null;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch (_err) {
+        const entry = trimmed + "\n";
+        output.write(entry);
+        outputOffset += Buffer.byteLength(entry, "utf8");
+        kept += 1;
+        if (inputOffset <= previousOffset) {
+          nextOffset = outputOffset;
+        }
+        continue;
+      }
+      if (parsed && parsed.project_key === projectKey) {
+        removed += 1;
+        if (inputOffset <= previousOffset) {
+          nextOffset = outputOffset;
+        }
+        continue;
+      }
+      const entry = JSON.stringify(parsed) + "\n";
+      output.write(entry);
+      outputOffset += Buffer.byteLength(entry, "utf8");
+      kept += 1;
+      if (inputOffset <= previousOffset) {
+        nextOffset = outputOffset;
+      }
+    }
+
+    await new Promise((resolve, reject) => {
+      output.end(resolve);
+      output.on("error", reject);
+    });
+
+    await fsp.rename(tmpPath, projectQueuePath);
+    if (previousOffset >= inputOffset) {
+      nextOffset = outputOffset;
+    }
+  } else {
+    await fsp.writeFile(projectQueuePath, "", "utf8");
+    nextOffset = 0;
+  }
+
+  await fsp.writeFile(projectQueueStatePath, JSON.stringify({ offset: nextOffset }), "utf8");
+
+  return { removed, kept, removedBuckets };
+}
+
+module.exports = { purgeProjectUsage };

package/src/lib/prompt.js

@@ -0,0 +1,24 @@
+const readline = require("node:readline");
+
+async function prompt(label) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const value = await new Promise((resolve) => rl.question(label, resolve));
+  rl.close();
+  return String(value || "").trim();
+}
+
+async function promptHidden(label) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+  });
+  const value = await new Promise((resolve) => {
+    rl._writeToOutput = function _writeToOutput() {};
+    rl.question(label, (answer) => resolve(answer));
+  });
+  rl.close();
+  return String(value || "").trim();
+}
+
+module.exports = { prompt, promptHidden };

package/src/lib/proxy-env.js

@@ -0,0 +1,131 @@
+const cp = require("node:child_process");
+
+function hasProxyEnv(env = process.env) {
+  return Boolean(
+    env.HTTPS_PROXY ||
+    env.https_proxy ||
+    env.HTTP_PROXY ||
+    env.http_proxy ||
+    env.ALL_PROXY ||
+    env.all_proxy,
+  );
+}
+
+function parseMacProxyOutput(output) {
+  const values = {};
+  for (const line of String(output || "").split(/\r?\n/)) {
+    const match = line.match(/^\s*([A-Za-z]+)\s*:\s*(.+?)\s*$/);
+    if (match) values[match[1]] = match[2];
+  }
+  if (values.HTTPSEnable !== "1" || !values.HTTPSProxy || !values.HTTPSPort) return null;
+  return `http://${values.HTTPSProxy}:${values.HTTPSPort}`;
+}
+
+function resolveSystemProxyEnv({ env = process.env, platform = process.platform, commandRunner = cp.spawnSync } = {}) {
+  const out = {};
+  if (hasProxyEnv(env)) {
+    out.NODE_USE_ENV_PROXY = env.NODE_USE_ENV_PROXY || "1";
+    return out;
+  }
+
+  if (platform !== "darwin") return null;
+  const result = commandRunner("scutil", ["--proxy"], {
+    encoding: "utf8",
+    timeout: 2000,
+  });
+  if (result?.error || result?.status !== 0) return null;
+  const proxyUrl = parseMacProxyOutput(result.stdout);
+  if (!proxyUrl) return null;
+
+  return {
+    NODE_USE_ENV_PROXY: "1",
+    HTTPS_PROXY: proxyUrl,
+    HTTP_PROXY: proxyUrl,
+  };
+}
+
+function shouldRelaunchForProxy(argv, env = process.env) {
+  if (env.TOKENTRACKER_PROXY_ENV_APPLIED === "1") return false;
+  const command = Array.isArray(argv) ? argv[0] : null;
+  return !command || command === "serve";
+}
+
+function relaunchWithProxyEnvIfNeeded({
+  argv,
+  originalArgv,
+  env = process.env,
+  platform = process.platform,
+  commandRunner = cp.spawnSync,
+  nodePath = process.execPath,
+} = {}) {
+  if (!shouldRelaunchForProxy(argv, env)) return null;
+  const proxyEnv = resolveSystemProxyEnv({ env, platform, commandRunner });
+  if (!proxyEnv || proxyEnv.NODE_USE_ENV_PROXY === env.NODE_USE_ENV_PROXY) return null;
+
+  const childEnv = {
+    ...env,
+    ...proxyEnv,
+    TOKENTRACKER_PROXY_ENV_APPLIED: "1",
+  };
+  return commandRunner(nodePath, originalArgv, {
+    stdio: "inherit",
+    env: childEnv,
+  });
+}
+
+function pickProxyUrl(env = process.env) {
+  return (
+    env.HTTPS_PROXY ||
+    env.https_proxy ||
+    env.HTTP_PROXY ||
+    env.http_proxy ||
+    env.ALL_PROXY ||
+    env.all_proxy ||
+    null
+  );
+}
+
+// Node's built-in NODE_USE_ENV_PROXY support only landed in v22.21 / v24.5.
+// For older runtimes (including the v22.14 we historically embedded in the
+// macOS app, and the v22.16 a community user hit on Discussion #68) the env
+// var is silently ignored and fetch() bypasses the proxy. Setting an undici
+// ProxyAgent dispatcher at startup gives us proxy support on every Node ≥ 18
+// regardless of the env-proxy flag.
+function applyUndiciProxyIfNeeded({
+  env = process.env,
+  setGlobalDispatcher,
+  ProxyAgent,
+} = {}) {
+  const proxyUrl = pickProxyUrl(env);
+  if (!proxyUrl) return null;
+
+  let setter = setGlobalDispatcher;
+  let Agent = ProxyAgent;
+  if (!setter || !Agent) {
+    try {
+      // eslint-disable-next-line global-require
+      const undici = require("undici");
+      setter = setter || undici.setGlobalDispatcher;
+      Agent = Agent || undici.ProxyAgent;
+    } catch (_e) {
+      return null;
+    }
+  }
+  if (typeof setter !== "function" || typeof Agent !== "function") return null;
+
+  try {
+    setter(new Agent(proxyUrl));
+    return proxyUrl;
+  } catch (_e) {
+    return null;
+  }
+}
+
+module.exports = {
+  hasProxyEnv,
+  parseMacProxyOutput,
+  pickProxyUrl,
+  resolveSystemProxyEnv,
+  relaunchWithProxyEnvIfNeeded,
+  applyUndiciProxyIfNeeded,
+};