token-quota 1.0.0

package/src/resolve-deps.js

@@ -0,0 +1,240 @@
+/**
+ * Dependency resolution — finds the three data-source CLIs inside this
+ * package's own dependency tree.
+ *
+ * token-quota declares `quota-axi`, `bailian-cli` and `@volcengine/ark-cli` as
+ * dependencies, so after `npm i -g token-quota` (or `npx token-quota`) they sit
+ * on disk next to this package. These helpers locate the package directory with
+ * `createRequire(import.meta.url)` (never by guessing a global layout) and then
+ * read **that package's own `bin` map** to find its entry point, so a dependency
+ * that moves its entry file does not silently break us.
+ *
+ * Resolution order per package, first hit wins:
+ *  1. `<pkg>/package.json` through the Node resolver
+ *  2. the package's resolved main entry, then walk up to the package root
+ *  3. the plain `node_modules/<pkg>` directory in the resolver's search paths
+ * Every step is read-only and side-effect free; a failure returns null so the
+ * caller can fall back to its own global-install-layout probes.
+ *
+ * `@volcengine/ark-cli` is special: its platform binary is downloaded by its own
+ * postinstall script, so the binary is preferred and the bin script
+ * (`scripts/run.js`, a node program that execs the binary) is the fallback.
+ */
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+const defaultRequire = createRequire(import.meta.url);
+
+/** npm package names of the three data sources. */
+export const PACKAGES = {
+  quotaAxi: 'quota-axi',
+  bailianCli: 'bailian-cli',
+  arkCli: '@volcengine/ark-cli',
+};
+
+/** How deep to walk up looking for the package root behind a resolved entry. */
+const MAX_WALK_UP = 12;
+
+/** Reads and parses a package.json inside `dir`; null when absent or unreadable. */
+export function readManifest(dir) {
+  try {
+    return JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Absolute directory of an installed package, or null.
+ * @param {string} name package name (may be scoped)
+ * @param {{ require?: { resolve: Function } }} [options]
+ */
+export function resolvePackageDir(name, { require: req = defaultRequire } = {}) {
+  // 1. Direct package.json lookup (works unless the package restricts "exports").
+  try {
+    const manifest = req.resolve(`${name}/package.json`);
+    if (manifest) {
+      const dir = dirname(manifest);
+      if (isDirectory(dir)) return dir;
+    }
+  } catch {
+    // fall through: quota-axi ships an "exports" map without ./package.json
+  }
+
+  // 2. Resolve the main entry, then walk up to the package root.
+  try {
+    const entry = req.resolve(name);
+    if (entry) {
+      const found = walkUpToPackage(dirname(entry), name);
+      if (found) return found;
+    }
+  } catch {
+    // fall through: no main entry resolvable either
+  }
+
+  // 3. Bare node_modules directory in the resolver's search paths.
+  const roots = typeof req.resolve?.paths === 'function' ? req.resolve.paths(name) ?? [] : [];
+  for (const root of roots) {
+    const dir = join(root, ...name.split('/'));
+    if (isDirectory(dir)) return dir;
+  }
+  return null;
+}
+
+function walkUpToPackage(from, name) {
+  let dir = from;
+  for (let i = 0; i < MAX_WALK_UP; i += 1) {
+    const manifest = readManifest(dir);
+    if (manifest?.name === name) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Absolute path of a bin entry declared by the package in `dir`, or null.
+ * Accepts both `bin` shapes npm allows: a string (one bin, named like the
+ * package) and an object keyed by command name — falling back to its only
+ * entry when the requested key is absent.
+ * @param {string} dir package root
+ * @param {string} binName command name, e.g. "quota-axi" or "bl"
+ */
+export function binEntry(dir, binName) {
+  const bin = readManifest(dir)?.bin;
+  let relative = null;
+  if (typeof bin === 'string') relative = bin;
+  else if (bin && typeof bin === 'object') {
+    relative = typeof bin[binName] === 'string' ? bin[binName] : null;
+    if (relative === null) {
+      const values = Object.values(bin).filter((value) => typeof value === 'string');
+      if (values.length === 1) [relative] = values;
+    }
+  }
+  if (relative === null) return null;
+  const entry = resolve(dir, relative);
+  return existsSync(entry) ? entry : null;
+}
+
+/**
+ * Launch descriptor for one package's first matching bin name, or null.
+ * Exported for callers that need a bare command from PATH instead of the tree.
+ */
+export function resolveCliEntry(name, binNames, options = {}) {
+  const dir = resolvePackageDir(name, options);
+  if (!dir) return null;
+  for (const binName of binNames) {
+    const entry = binEntry(dir, binName);
+    if (entry) return entry;
+  }
+  return null;
+}
+
+/** quota-axi's entry script inside our dependency tree, or null. */
+export function resolveQuotaAxiEntry(options = {}) {
+  return resolveCliEntry(PACKAGES.quotaAxi, ['quota-axi'], options);
+}
+
+/** The official Bailian CLI (`bl`) entry inside our dependency tree, or null. */
+export function resolveBailianCliEntry(options = {}) {
+  return resolveCliEntry(PACKAGES.bailianCli, ['bl', 'bailian'], options);
+}
+
+/**
+ * File name of the ark-cli platform binary for a platform/arch pair, mirroring
+ * the mapping in @volcengine/ark-cli's own `scripts/run.js`. null when the
+ * platform has no published binary.
+ */
+export function arkCliBinaryName({ platform = process.platform, arch = process.arch } = {}) {
+  const platforms = { darwin: 'darwin', linux: 'linux', win32: 'windows' };
+  const arches = { x64: 'amd64', arm64: 'arm64' };
+  const os = platforms[platform];
+  const machine = arches[arch];
+  if (!os || !machine) return null;
+  return `arkcli-${os}-${machine}${os === 'windows' ? '.exe' : ''}`;
+}
+
+/**
+ * How to launch the dependency-tree arkcli:
+ *  - `{ command: <platform binary> }` when the postinstall download succeeded
+ *  - `{ command: <scripts/run.js>, nodeEntry: true }` — the package's own bin
+ *    script, which needs the node binary in front of it
+ *  - null when the package is not in the dependency tree
+ */
+export function resolveArkCliLaunch(options = {}) {
+  const { platform = process.platform, arch = process.arch } = options;
+  const dir = resolvePackageDir(PACKAGES.arkCli, options);
+  if (!dir) return null;
+  const binaryName = arkCliBinaryName({ platform, arch });
+  if (binaryName) {
+    const binary = join(dir, 'bin', binaryName);
+    if (existsSync(binary)) return { command: binary };
+  }
+  const script = binEntry(dir, 'arkcli');
+  if (script) return { command: script, nodeEntry: true };
+  return null;
+}
+
+/**
+ * Uniform launch descriptor for one data-source CLI from the dependency tree.
+ * JS entries are run with the current node binary, so callers get an executable
+ * plus the arguments that must precede the CLI's own arguments.
+ * @returns {{ command: string, prefixArgs: string[] } | null}
+ */
+export function resolveDependencyCli(name, { execPath = process.execPath, ...options } = {}) {
+  if (name === PACKAGES.arkCli) {
+    const launch = resolveArkCliLaunch(options);
+    if (!launch) return null;
+    return launch.nodeEntry
+      ? { command: execPath, prefixArgs: [launch.command] }
+      : { command: launch.command, prefixArgs: [] };
+  }
+  const binNames = name === PACKAGES.bailianCli ? ['bl', 'bailian'] : ['quota-axi'];
+  const entry = resolveCliEntry(name, binNames, options);
+  return entry ? { command: execPath, prefixArgs: [entry] } : null;
+}
+
+/**
+ * npm's `.bin` shim directory for each dependency that resolved, deduplicated
+ * and filtered to what exists on disk.
+ *
+ * quota-axi looks up the Bailian CLI (`bl`) on PATH itself, and npm does not put
+ * a nested dependency's bin shims on the user's PATH — so the bailian row only
+ * works from a packaged install if those shims are prepended to the subprocess
+ * PATH (the same trick the vendored sqlite3 shim uses).
+ */
+export function dependencyBinDirs(options = {}) {
+  const dirs = [];
+  for (const name of Object.values(PACKAGES)) {
+    const dir = resolvePackageDir(name, options);
+    if (!dir) continue;
+    const binDir = join(dirname(dir), '.bin');
+    if (dirs.includes(binDir) || !isDirectory(binDir)) continue;
+    dirs.push(binDir);
+  }
+  return dirs;
+}
+
+/**
+ * Launch descriptor for a bare command name resolved through PATH, used as the
+ * last resort when nothing is found in the dependency tree.
+ *
+ * On Windows the npm shims are `.cmd` wrappers, which a spawned process cannot
+ * execute directly (and libuv's PATH search only appends `.exe`), so the `.cmd`
+ * form plus a shell is required there. On POSIX the plain name works.
+ * @returns {{ command: string, prefixArgs: string[], shell?: true }}
+ */
+export function pathFallback(command, { platform = process.platform } = {}) {
+  if (platform !== 'win32') return { command, prefixArgs: [] };
+  return { command: `${command}.cmd`, prefixArgs: [], shell: true };
+}

package/src/setup.js

@@ -0,0 +1,226 @@
+/**
+ * `token-quota setup` — first-run sign-in wizard.
+ *
+ * For each selected platform it checks the current state (a real, read-only
+ * query) and, when a sign-in is missing, explains what is needed and runs the
+ * platform's own login command with inherited stdio so the browser flow is the
+ * official one:
+ *
+ *   doubao   `arkcli auth login volc-sso`   (one browser SSO sign-in)
+ *   bailian  `bl auth login --console`      (one browser sign-in)
+ *   cursor   sign in inside the Cursor editor, then this wizard re-checks
+ *
+ * The wizard writes no file and stores no credential: every session stays owned
+ * by the vendor CLI or editor that created it. Non-interactive runs (no TTY)
+ * only print the manual steps and exit 0.
+ */
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+
+import { commandLine, selectPlatforms } from './cli.js';
+import { classifyFailure } from './doctor.js';
+import { runPanel } from './panel.js';
+import { platforms as allPlatforms } from './platforms/index.js';
+import { PACKAGES, pathFallback, resolveDependencyCli } from './resolve-deps.js';
+
+/** How many sign-in attempts one platform gets before the wizard moves on. */
+const MAX_ATTEMPTS = 3;
+
+/**
+ * Per-platform sign-in facts. `cli` is the npm package that owns the login
+ * command, `loginArgs` its arguments (null = the credential is created inside
+ * an editor), `manual` the copy-pasteable command for non-interactive runs.
+ */
+export const PLATFORM_GUIDE = {
+  doubao: {
+    cli: PACKAGES.arkCli,
+    fallback: 'arkcli',
+    loginArgs: ['auth', 'login', 'volc-sso'],
+    manual: 'arkcli auth login volc-sso',
+    summary: 'Volcengine Ark CLI SSO session — one browser SSO sign-in',
+    editor: false,
+  },
+  bailian: {
+    cli: PACKAGES.bailianCli,
+    fallback: 'bl',
+    loginArgs: ['auth', 'login', '--console'],
+    manual: 'bl auth login --console',
+    summary: 'Bailian console session — one browser sign-in',
+    editor: false,
+  },
+  cursor: {
+    cli: PACKAGES.quotaAxi,
+    fallback: 'quota-axi',
+    loginArgs: null,
+    manual: 'open Cursor and sign in',
+    summary: 'Cursor sign-in inside the editor — quota-axi reads the local credential store Cursor itself keeps',
+    editor: true,
+  },
+};
+
+const HOW_TO_INSTALL = {
+  [PACKAGES.arkCli]: 'npm i -g @volcengine/ark-cli',
+  [PACKAGES.bailianCli]: 'npm i -g bailian-cli',
+  [PACKAGES.quotaAxi]: 'npm i -g quota-axi',
+};
+
+/**
+ * Runs the wizard (or prints the manual steps) and finishes with the panel.
+ * @param {{ only?: string[]|null }} options parsed CLI options
+ * @param {object} [io] injectable environment
+ * @returns {Promise<number>} exit code
+ */
+export async function runSetup(options = {}, io = {}) {
+  const {
+    stdout = process.stdout,
+    stderr = process.stderr,
+    stdin = process.stdin,
+    isTTY = Boolean(stdin.isTTY && stdout.isTTY),
+    platforms = allPlatforms,
+    execPath = process.execPath,
+    platform = process.platform,
+    arch = process.arch,
+    ask = null,
+    runLogin = defaultRunLogin,
+  } = io;
+
+  let selected;
+  try {
+    selected = selectPlatforms(options.only, platforms);
+  } catch (error) {
+    stderr.write(`token-quota: ${error.message}\n`);
+    return 2;
+  }
+
+  if (!isTTY) {
+    printManualGuide(selected, stdout);
+    return 0;
+  }
+
+  const ownPrompt = ask === null;
+  const prompt = ask ?? createPrompt({ input: stdin, output: stdout });
+  try {
+    stdout.write('token-quota setup — signing in to the platforms that are not configured yet\n\n');
+    for (const platformCheck of selected) {
+      await setupOne(platformCheck, { stdout, prompt, execPath, platform, arch, runLogin });
+      stdout.write('\n');
+    }
+  } finally {
+    if (ownPrompt) prompt.close?.();
+  }
+
+  stdout.write('Final panel:\n\n');
+  return runPanel({ only: selected.map((entry) => entry.id), json: false }, { stdout, stderr, isTTY: true, platforms });
+}
+
+/**
+ * Sign-in loop for one platform: check → explain → run the official login →
+ * re-check. `cli-missing` and plain query failures end the loop with guidance.
+ */
+async function setupOne(platformCheck, { stdout, prompt, execPath, platform, arch, runLogin }) {
+  const guide = PLATFORM_GUIDE[platformCheck.id] ?? { editor: false, loginArgs: null };
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+    const state = await probe(platformCheck);
+    if (state.ok) {
+      stdout.write(`  [ok]   ${platformCheck.id} — already configured (${state.rows} row(s) read)\n`);
+      return true;
+    }
+    if (state.kind === 'cli-missing') {
+      stdout.write(`  [fail] ${platformCheck.id} — ${state.detail}\n`);
+      stdout.write(`         fix:  ${state.fix ?? HOW_TO_INSTALL[guide.cli] ?? 'install the CLI'}\n`);
+      return false;
+    }
+    if (state.kind === 'failed') {
+      stdout.write(`  [fail] ${platformCheck.id} — ${state.detail}\n`);
+      return false;
+    }
+
+    stdout.write(`  [--]   ${platformCheck.id} — not signed in: ${state.detail}\n`);
+    if (guide.editor) {
+      const answer = await prompt(`         ${guide.manual}, then press Enter to check again (or "s" to skip): `);
+      if (isSkip(answer)) return false;
+      continue;
+    }
+
+    const launch = resolveDependencyCli(guide.cli, { execPath, platform, arch });
+    const command = launch ?? pathFallback(guide.fallback, { platform });
+    const rendered = [command.command, ...command.prefixArgs, ...guide.loginArgs].join(' ');
+    const answer = await prompt(`         Press Enter to run \`${guide.manual}\` now (or "s" to skip): `);
+    if (isSkip(answer)) return false;
+
+    stdout.write(`         running: ${rendered}\n`);
+    const code = await runLogin(command, guide.loginArgs);
+    if (code !== 0) {
+      stdout.write(`         that command exited with code ${code} — you can re-run it later and start setup again\n`);
+    }
+  }
+  stdout.write(`  [--]   ${platformCheck.id} — still not signed in; re-run \`token-quota setup\` when you are ready\n`);
+  return false;
+}
+
+/** Read-only platform probe reusing the doctor classification. */
+async function probe(platformCheck) {
+  try {
+    const { rows } = await platformCheck.query();
+    return { ok: true, rows: Array.isArray(rows) ? rows.length : 0 };
+  } catch (error) {
+    return { ok: false, ...classifyFailure(error) };
+  }
+}
+
+function isSkip(answer) {
+  return /^(s|skip|n|no|q|quit)$/i.test(String(answer ?? '').trim());
+}
+
+function createPrompt({ input, output }) {
+  const rl = createInterface({ input, output });
+  const prompt = (question) => new Promise((resolve) => rl.question(question, resolve));
+  prompt.close = () => rl.close();
+  return prompt;
+}
+
+/** Spawns the vendor login command with inherited stdio; resolves with its exit code. */
+export function defaultRunLogin(launch, args) {
+  const argv = [...launch.prefixArgs, ...args];
+  return new Promise((resolve) => {
+    let child;
+    try {
+      // Windows `.cmd` npm shims need a shell and therefore one composed line.
+      child =
+        launch.shell === true
+          ? spawn(commandLine(launch.command, argv), { stdio: 'inherit', shell: true, windowsHide: false })
+          : spawn(launch.command, argv, { stdio: 'inherit', windowsHide: false });
+    } catch (error) {
+      resolve(1);
+      return;
+    }
+    child.on('error', () => resolve(1));
+    child.on('close', (code) => resolve(code ?? 0));
+  });
+}
+
+/** Non-interactive output: what to run by hand, per platform. Exit code is always 0. */
+function printManualGuide(selected, stdout) {
+  const lines = [
+    'token-quota setup — sign-in helper',
+    '',
+    'Not running in an interactive terminal, so no login command is launched here.',
+    'Sign in once per platform, then run `token-quota` again:',
+    '',
+  ];
+  for (const platformCheck of selected) {
+    const guide = PLATFORM_GUIDE[platformCheck.id];
+    if (!guide) continue;
+    lines.push(`  ${platformCheck.id}`);
+    lines.push(`    ${guide.manual}`);
+    lines.push(`    ${guide.summary}`);
+    lines.push('');
+  }
+  lines.push('  Every session belongs to the vendor CLI or editor that created it:');
+  lines.push('  this wizard writes no file and stores no credential.');
+  lines.push('');
+  lines.push('Next:  token-quota setup    (interactive wizard)');
+  lines.push('       token-quota doctor   (read-only check of what is missing)');
+  lines.push('');
+  stdout.write(`${lines.join('\n')}`);
+}

package/src/table.js

@@ -0,0 +1,37 @@
+/**
+ * Minimal fixed-width table renderer for the compact one-table output.
+ * Every cell is a plain string; rows carry no colour so output stays pipeable.
+ */
+
+const COLUMNS = ['PLATFORM', 'PLAN/PACKAGE', 'TOTAL', 'USED', 'REMAINING', 'RESET'];
+
+/** @param {Array<{platform: string, plan: string, total: string, used: string, remaining: string, reset: string}>} rows */
+export function renderTable(rows) {
+  const cells = rows.map((row) => [
+    row.platform ?? '',
+    row.plan ?? '',
+    row.total ?? '',
+    row.used ?? '',
+    row.remaining ?? '',
+    row.reset ?? '',
+  ]);
+
+  const widths = COLUMNS.map((header, i) =>
+    cells.reduce((max, row) => Math.max(max, row[i].length), header.length),
+  );
+
+  const line = (row) =>
+    row
+      .map((cell, i) => (i === row.length - 1 ? cell : pad(cell, widths[i])))
+      .join('  ')
+      .trimEnd();
+
+  const rule = widths.map((w) => '-'.repeat(w)).join('  ');
+  return [line(COLUMNS), rule, ...cells.map(line)].join('\n');
+}
+
+function pad(text, width) {
+  return text.length >= width ? text : text + ' '.repeat(width - text.length);
+}
+
+export { COLUMNS };