troxy-cli 1.21.1 → 1.23.0

package/src/tests/tool_detect.test.js

@@ -0,0 +1,389 @@
+// tool_detect.js: the AI-tool inventory scan + subscription-plan self-report
+// wired into `troxy init` (after reprovisionKeyConsumers) and standalone
+// `troxy tools`. A single machine can have more than one of these six tools
+// installed at once, and each is tracked independently - never assume "one
+// AI tool per user" (that's the whole reason detectAiTools() returns an
+// array, not a single match).
+//
+// Path-based detection (cursor/github_copilot/windsurf/continue) runs
+// against a real temp HOME, the same technique config.test.js and
+// hook-report.test.js already use - this suite has no fs/execSync mocking
+// anywhere, and a real temp dir is simpler than reimplementing
+// fs.existsSync's contract. claude_code/aider are execSync('<bin>
+// --version') probes; asserting a specific installed/not-installed result
+// for those would depend on whatever machine happens to run the suite (CI
+// vs. a dev box with the CLI on PATH), so those are covered by testing the
+// binExists() mechanism itself with synthetic commands, plus source
+// inspection confirming the real TOOLS entries use it (and, for
+// claude_code, reuse init.js's own hasClaudeCode() rather than
+// reimplementing the probe).
+import { describe, it, before, beforeEach, after, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+// tool_detect.js reads os.homedir() once at module load time (`const home =
+// os.homedir()`), so HOME must point at an isolated temp dir *before* the
+// first import - exactly the trick config.test.js uses to keep tests off
+// the real ~/.troxy (and, here, off the real ~/.cursor, ~/.continue, etc.).
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-tool-detect-test-'));
+process.env.HOME = TMP;
+process.env.APPDATA = path.join(TMP, 'AppData/Roaming');
+process.env.LOCALAPPDATA = path.join(TMP, 'AppData/Local');
+
+const {
+  detectAiTools,
+  promptForToolPlans,
+  silentToolReport,
+  reportToolPlans,
+  runToolDetection,
+  binExists,
+  TOOLS,
+} = await import('../tool_detect.js');
+const { api } = await import('../api.js');
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const toolDetectSrc = readFileSync(join(__dirname, '..', 'tool_detect.js'), 'utf8');
+
+after(() => fs.rmSync(TMP, { recursive: true, force: true }));
+
+describe('TOOLS registry', () => {
+  it('has exactly the 6 documented tools, in slug form', () => {
+    assert.deepEqual(
+      TOOLS.map(t => t.slug),
+      ['claude_code', 'cursor', 'github_copilot', 'windsurf', 'continue', 'aider'],
+    );
+  });
+
+  // Keep in sync with the backend registry (tool_plans.py TOOL_PLANS) - the
+  // backend validates against its own copy of these slugs, so a slug typo
+  // here would silently fail every report for that tool.
+  const EXPECTED_PLAN_SLUGS = {
+    claude_code:     ['free', 'pro', 'max_5x', 'max_20x', 'api', 'not_sure'],
+    cursor:          ['hobby', 'pro', 'business', 'not_sure'],
+    github_copilot:  ['individual', 'business', 'enterprise', 'not_sure'],
+    windsurf:        ['free', 'pro', 'not_sure'],
+    continue:        ['free', 'pro', 'not_sure'],
+    aider:           ['free', 'pro', 'not_sure'],
+  };
+
+  for (const [slug, expected] of Object.entries(EXPECTED_PLAN_SLUGS)) {
+    it(`${slug} offers exactly the plan slugs the backend registry expects`, () => {
+      const tool = TOOLS.find(t => t.slug === slug);
+      assert.ok(tool, `${slug} missing from TOOLS`);
+      assert.deepEqual(tool.plans.map(p => p.slug), expected);
+    });
+  }
+});
+
+describe('binExists (the mechanism behind claude_code/aider detection)', () => {
+  it('returns true when the command succeeds', () => {
+    assert.equal(binExists('true'), true);
+  });
+
+  it('returns false when the command exits non-zero, without throwing', () => {
+    assert.equal(binExists('false'), false);
+  });
+
+  it('returns false for a binary that does not exist at all', () => {
+    assert.equal(binExists('this-command-almost-certainly-does-not-exist-xyz123 --version'), false);
+  });
+});
+
+describe('claude_code / aider detection wiring', () => {
+  it('claude_code reuses init.js\'s hasClaudeCode() rather than reimplementing the probe', () => {
+    assert.ok(
+      toolDetectSrc.includes("import { prompt, hasClaudeCode } from './init.js'"),
+      'tool_detect.js must import hasClaudeCode from init.js, not redeclare its own execSync probe',
+    );
+    const claudeBlock = toolDetectSrc.slice(
+      toolDetectSrc.indexOf("slug: 'claude_code'"),
+      toolDetectSrc.indexOf("slug: 'cursor'"),
+    );
+    assert.match(claudeBlock, /detect:\s*\(\)\s*=>\s*hasClaudeCode\(\)/);
+  });
+
+  it('aider probes "aider --version" via binExists', () => {
+    const aiderBlock = toolDetectSrc.slice(toolDetectSrc.indexOf("slug: 'aider'"));
+    assert.match(aiderBlock, /detect:\s*\(\)\s*=>\s*binExists\('aider --version'\)/);
+  });
+});
+
+describe('detectAiTools - path-based markers (cursor / github_copilot / windsurf / continue)', () => {
+  function reset() {
+    fs.rmSync(TMP, { recursive: true, force: true });
+    fs.mkdirSync(TMP, { recursive: true });
+  }
+  beforeEach(reset);
+  after(reset);
+
+  it('reports none of the path-based tools installed against a clean home dir', () => {
+    const detected = detectAiTools();
+    for (const slug of ['cursor', 'github_copilot', 'windsurf', 'continue']) {
+      assert.equal(detected.find(d => d.slug === slug).installed, false, `${slug} should not be detected against an empty home dir`);
+    }
+  });
+
+  it("detects Cursor from its own app-support dir (~/Library/Application Support/Cursor)", () => {
+    fs.mkdirSync(path.join(TMP, 'Library/Application Support/Cursor'), { recursive: true });
+    assert.equal(detectAiTools().find(d => d.slug === 'cursor').installed, true);
+  });
+
+  it('does NOT treat a troxy-created .cursor/mcp.json as evidence Cursor is installed', () => {
+    fs.mkdirSync(path.join(TMP, '.cursor'), { recursive: true });
+    fs.writeFileSync(path.join(TMP, '.cursor/mcp.json'), '{}');
+    assert.equal(
+      detectAiTools().find(d => d.slug === 'cursor').installed,
+      false,
+      'the MCP config troxy init itself creates must never look like Cursor being installed',
+    );
+  });
+
+  it('detects GitHub Copilot from ~/.config/github-copilot/hosts.json', () => {
+    fs.mkdirSync(path.join(TMP, '.config/github-copilot'), { recursive: true });
+    fs.writeFileSync(path.join(TMP, '.config/github-copilot/hosts.json'), '{}');
+    assert.equal(detectAiTools().find(d => d.slug === 'github_copilot').installed, true);
+  });
+
+  it('detects Windsurf from ~/.codeium/windsurf/, not the mcp_config.json troxy might create inside it', () => {
+    fs.mkdirSync(path.join(TMP, '.codeium/windsurf'), { recursive: true });
+    assert.equal(detectAiTools().find(d => d.slug === 'windsurf').installed, true);
+
+    // The MCP-specific file alone (same troxy-created-file risk as cursor)
+    // must not be required, but also must not be the thing being matched -
+    // the base dir is. Deleting it, base dir intact, should stay detected.
+    fs.rmSync(path.join(TMP, '.codeium/windsurf'), { recursive: true, force: true });
+    fs.mkdirSync(path.join(TMP, '.codeium/windsurf'), { recursive: true });
+    fs.writeFileSync(path.join(TMP, '.codeium/windsurf/mcp_config.json'), '{}');
+    assert.equal(detectAiTools().find(d => d.slug === 'windsurf').installed, true);
+  });
+
+  it('detects Continue from ~/.continue/', () => {
+    fs.mkdirSync(path.join(TMP, '.continue'), { recursive: true });
+    assert.equal(detectAiTools().find(d => d.slug === 'continue').installed, true);
+  });
+
+  it('a machine with several tools installed reports every one independently - never just the first match', () => {
+    fs.mkdirSync(path.join(TMP, 'Library/Application Support/Cursor'), { recursive: true });
+    fs.mkdirSync(path.join(TMP, '.continue'), { recursive: true });
+    const detected = detectAiTools();
+    assert.equal(detected.find(d => d.slug === 'cursor').installed, true);
+    assert.equal(detected.find(d => d.slug === 'continue').installed, true);
+    assert.equal(detected.find(d => d.slug === 'github_copilot').installed, false);
+    assert.equal(detected.find(d => d.slug === 'windsurf').installed, false);
+  });
+});
+
+describe('silentToolReport (non-interactive fallback shape)', () => {
+  it('reports every installed tool as not_sure with no cycle_day, and skips tools that are not installed', () => {
+    const detected = [
+      { slug: 'claude_code', name: 'Claude Code', installed: true },
+      { slug: 'cursor',      name: 'Cursor',      installed: false },
+      { slug: 'aider',       name: 'Aider',       installed: true },
+    ];
+    assert.deepEqual(silentToolReport(detected), [
+      { slug: 'claude_code', installed: true, plan: 'not_sure', cycle_day: null },
+      { slug: 'aider',       installed: true, plan: 'not_sure', cycle_day: null },
+    ]);
+  });
+
+  it('returns an empty array when nothing is installed', () => {
+    assert.deepEqual(silentToolReport([{ slug: 'cursor', name: 'Cursor', installed: false }]), []);
+  });
+});
+
+describe('runToolDetection - non-interactive guard (a scripted/CI init must never hang on stdin)', () => {
+  let calls;
+  let originalReportToolPlans;
+  let originalIsTTY;
+
+  before(() => {
+    // A deterministic installed tool, independent of whether claude/aider
+    // binaries happen to be on PATH wherever this suite runs - the whole
+    // point of driving detection through the temp-HOME path markers rather
+    // than asserting on the real machine's execSync probes.
+    fs.mkdirSync(path.join(TMP, '.continue'), { recursive: true });
+  });
+  after(() => fs.rmSync(path.join(TMP, '.continue'), { recursive: true, force: true }));
+
+  beforeEach(() => {
+    calls = [];
+    originalReportToolPlans = api.reportToolPlans;
+    api.reportToolPlans = async (apiKey, tools) => { calls.push({ apiKey, tools }); return {}; };
+    originalIsTTY = process.stdin.isTTY;
+  });
+  afterEach(() => {
+    api.reportToolPlans = originalReportToolPlans;
+    process.stdin.isTTY = originalIsTTY;
+  });
+
+  it('skips the interactive prompt and reports every detected tool as not_sure when stdin is not a TTY', async () => {
+    process.stdin.isTTY = false;
+    await runToolDetection('txy-test-key', { interactive: true });
+
+    assert.equal(calls.length, 1, 'reportToolPlans must be called exactly once when at least one tool is installed');
+    assert.equal(calls[0].apiKey, 'txy-test-key');
+    const tools = calls[0].tools;
+    const cont = tools.find(t => t.slug === 'continue');
+    assert.ok(cont, 'the tool detected via the temp-HOME marker must be in the reported set');
+    for (const t of tools) {
+      assert.equal(t.installed, true);
+      assert.equal(t.plan, 'not_sure');
+      assert.equal(t.cycle_day, null);
+    }
+  });
+
+  it('returns promptly rather than blocking on stdin when stdin is not a TTY', async () => {
+    process.stdin.isTTY = false;
+    const start = Date.now();
+    await runToolDetection('txy-test-key', { interactive: true });
+    assert.ok(Date.now() - start < 2000, 'runToolDetection must not block waiting on a readline question nothing will ever answer');
+  });
+
+  it('runToolDetection only takes the interactive path when both interactive AND stdin.isTTY are true', () => {
+    assert.ok(
+      toolDetectSrc.includes('(interactive && process.stdin.isTTY)'),
+      'the non-interactive guard must check both interactive and process.stdin.isTTY, not just one',
+    );
+  });
+});
+
+describe("promptForToolPlans - returns immediately when nothing is installed (no prompt call, no stdin needed)", () => {
+  it('resolves to [] without touching stdin', async () => {
+    const result = await promptForToolPlans([{ slug: 'cursor', name: 'Cursor', installed: false }]);
+    assert.deepEqual(result, []);
+  });
+});
+
+describe('promptForToolPlans numbered-choice parsing (mirrors the real logic in tool_detect.js)', () => {
+  // Mirrors the parsing inside promptForToolPlans's loop: a numbered-menu
+  // answer maps 1-based to the plan array; anything out of range - blank,
+  // 0, a too-large number, non-numeric junk - degrades to 'not_sure' rather
+  // than re-prompting, so a stray keystroke can never hang setup. The last
+  // test in each block below source-checks that the real implementation
+  // still contains this exact logic, so the two can't silently drift apart.
+  function resolvePlanChoice(ans, plans) {
+    const idx = parseInt(ans, 10) - 1;
+    return (idx >= 0 && idx < plans.length) ? plans[idx].slug : 'not_sure';
+  }
+
+  const cursorPlans = TOOLS.find(t => t.slug === 'cursor').plans; // hobby, pro, business, not_sure
+
+  it('maps a valid 1-based numbered choice to the matching plan slug', () => {
+    assert.equal(resolvePlanChoice('1', cursorPlans), 'hobby');
+    assert.equal(resolvePlanChoice('2', cursorPlans), 'pro');
+    assert.equal(resolvePlanChoice('3', cursorPlans), 'business');
+    assert.equal(resolvePlanChoice('4', cursorPlans), 'not_sure');
+  });
+
+  it('defaults to not_sure on a blank answer (Enter to skip)', () => {
+    assert.equal(resolvePlanChoice('', cursorPlans), 'not_sure');
+  });
+
+  it('defaults to not_sure on an out-of-range or non-numeric answer, rather than throwing', () => {
+    assert.equal(resolvePlanChoice('99', cursorPlans), 'not_sure');
+    assert.equal(resolvePlanChoice('0', cursorPlans), 'not_sure');
+    assert.equal(resolvePlanChoice('-1', cursorPlans), 'not_sure');
+    assert.equal(resolvePlanChoice('banana', cursorPlans), 'not_sure');
+  });
+
+  it('the real implementation uses this exact idx = parseInt(ans, 10) - 1 mapping', () => {
+    assert.ok(toolDetectSrc.includes('const idx = parseInt(ans, 10) - 1;'));
+    assert.ok(toolDetectSrc.includes("(idx >= 0 && idx < tool.plans.length) ? tool.plans[idx].slug : 'not_sure'"));
+  });
+});
+
+describe('promptForToolPlans cycle_day parsing (mirrors the real logic)', () => {
+  function resolveCycleDay(ans) {
+    const day = parseInt(ans, 10);
+    return (day >= 1 && day <= 31) ? day : null;
+  }
+
+  it('accepts a valid day 1-31', () => {
+    assert.equal(resolveCycleDay('1'), 1);
+    assert.equal(resolveCycleDay('15'), 15);
+    assert.equal(resolveCycleDay('31'), 31);
+  });
+
+  it('rejects out-of-range or non-numeric input as null (Enter to skip), never throws', () => {
+    assert.equal(resolveCycleDay(''), null);
+    assert.equal(resolveCycleDay('0'), null);
+    assert.equal(resolveCycleDay('32'), null);
+    assert.equal(resolveCycleDay('abc'), null);
+  });
+
+  it('the real implementation uses this exact 1-31 range check', () => {
+    assert.ok(toolDetectSrc.includes('if (day >= 1 && day <= 31) cycle_day = day;'));
+  });
+
+  it('only asks for a renewal day on a real paid plan - never free/hobby/not_sure/api', () => {
+    assert.ok(toolDetectSrc.includes("!['free', 'hobby', 'not_sure', 'api'].includes(plan)"));
+  });
+});
+
+describe('reportToolPlans', () => {
+  let originalReportToolPlans;
+  beforeEach(() => { originalReportToolPlans = api.reportToolPlans; });
+  afterEach(() => { api.reportToolPlans = originalReportToolPlans; });
+
+  it('POSTs the tools array via api.reportToolPlans, unchanged', async () => {
+    let captured;
+    api.reportToolPlans = async (apiKey, tools) => { captured = { apiKey, tools }; return {}; };
+    const results = [{ slug: 'cursor', installed: true, plan: 'pro', cycle_day: 5 }];
+    await reportToolPlans('txy-key', results);
+    assert.deepEqual(captured, { apiKey: 'txy-key', tools: results });
+  });
+
+  it('makes no API call for an empty result set', async () => {
+    let called = false;
+    api.reportToolPlans = async () => { called = true; };
+    await reportToolPlans('txy-key', []);
+    assert.equal(called, false);
+  });
+
+  it('swallows a failed report rather than throwing - must never break `troxy init`', async () => {
+    api.reportToolPlans = async () => { throw new Error('network down'); };
+    await assert.doesNotReject(
+      reportToolPlans('txy-key', [{ slug: 'cursor', installed: true, plan: 'pro', cycle_day: 5 }]),
+    );
+  });
+});
+
+describe('wiring: api.js / bin/troxy.js / init.js', () => {
+  const apiSrc = readFileSync(join(__dirname, '..', 'api.js'), 'utf8');
+  const binSrc = readFileSync(join(__dirname, '..', '..', 'bin', 'troxy.js'), 'utf8');
+  const initSrc = readFileSync(join(__dirname, '..', 'init.js'), 'utf8');
+
+  it("api.js POSTs to /agents/tool-plans with {tools} as the body", () => {
+    assert.ok(apiSrc.includes("'/agents/tool-plans'"), '/agents/tool-plans route missing from api.js');
+    assert.match(
+      apiSrc,
+      /reportToolPlans:\s*\(apiKey,\s*tools\)\s*=>\s*request\('POST',\s*'\/agents\/tool-plans',\s*\{\s*apiKey,\s*body:\s*\{\s*tools\s*\}\s*\}\)/,
+    );
+  });
+
+  it("bin/troxy.js registers a 'tools' subcommand that reuses tool_detect.js's runToolDetection", () => {
+    assert.ok(binSrc.includes("case 'tools'"), 'troxy tools subcommand missing');
+    assert.ok(binSrc.includes("'../src/tool_detect.js'"), 'troxy tools must import from tool_detect.js, not reimplement detection');
+    assert.ok(binSrc.includes('runToolDetection'));
+  });
+
+  it('runInit calls tool detection after reprovisionKeyConsumers, wrapped so a scan failure never blocks init', () => {
+    const reprovisionIdx = initSrc.indexOf('reprovisionKeyConsumers(key, agentName)');
+    const toolIdx = initSrc.indexOf('runToolDetection');
+    assert.ok(reprovisionIdx !== -1, 'reprovisionKeyConsumers call not found in init.js');
+    assert.ok(toolIdx !== -1, 'runToolDetection not wired into runInit');
+    assert.ok(toolIdx > reprovisionIdx, 'tool detection must run after reprovisionKeyConsumers, per spec');
+
+    const surrounding = initSrc.slice(Math.max(0, toolIdx - 200), toolIdx + 300);
+    assert.match(
+      surrounding,
+      /try\s*\{[\s\S]*runToolDetection[\s\S]*\}\s*catch/,
+      'the tool-detection step must be wrapped in try/catch so a scan/report failure never breaks a successful init',
+    );
+  });
+});

package/src/tool_detect.js

@@ -0,0 +1,181 @@
+import fs       from 'fs';
+import os       from 'os';
+import path     from 'path';
+import { execSync } from 'child_process';
+import { api }   from './api.js';
+import { prompt, hasClaudeCode } from './init.js';
+
+// AI coding tools we detect + the subscription plans a user can confirm for
+// each. Mirrors the backend registry (troxy-tf-live tool_plans.py TOOL_PLANS)
+// deliberately - six rows that rarely change aren't worth a shared package.
+// Keep the plan slugs identical on both sides; the backend validates against
+// its own copy and resolves the price, so the CLI never sends a price.
+//
+// `detect()` returns true if the tool looks present. Two techniques, same as
+// init.js's detectMcpClients: a `--version` probe for CLI tools, an
+// existence check on the tool's OWN config dir for the rest - never the
+// `.cursor/mcp.json` / windsurf `mcp_config.json` files, since `troxy init`
+// may have created those itself even where the tool was later removed.
+
+const home = os.homedir();
+
+// Exported for direct unit testing of the detection mechanism itself
+// (with a synthetic command / synthetic paths), independent of whether the
+// real tools happen to be installed on whatever machine runs the tests.
+export function binExists(cmd) {
+  try { execSync(cmd, { stdio: 'ignore' }); return true; } catch { return false; }
+}
+
+export function anyPathExists(paths) {
+  return paths.some(p => { try { return fs.existsSync(p); } catch { return false; } });
+}
+
+export const TOOLS = [
+  {
+    slug: 'claude_code',
+    name: 'Claude Code',
+    // Reuses init.js's own hasClaudeCode() as-is (execSync('claude
+    // --version')) rather than reimplementing it - one source of truth for
+    // "is Claude Code on PATH".
+    detect: () => hasClaudeCode(),
+    plans: [
+      { slug: 'free',     label: 'Free' },
+      { slug: 'pro',      label: 'Pro ($20/mo)' },
+      { slug: 'max_5x',   label: 'Max 5x ($100/mo)' },
+      { slug: 'max_20x',  label: 'Max 20x ($200/mo)' },
+      { slug: 'api',      label: 'API / pay-per-token' },
+      { slug: 'not_sure', label: 'Not sure' },
+    ],
+  },
+  {
+    slug: 'cursor',
+    name: 'Cursor',
+    detect: () => anyPathExists([
+      path.join(home, 'Library/Application Support/Cursor'),
+      path.join(process.env.APPDATA || home, 'Cursor'),
+      path.join(home, '.config/Cursor'),
+    ]),
+    plans: [
+      { slug: 'hobby',    label: 'Hobby (free)' },
+      { slug: 'pro',      label: 'Pro ($20/mo)' },
+      { slug: 'business', label: 'Business ($40/mo)' },
+      { slug: 'not_sure', label: 'Not sure' },
+    ],
+  },
+  {
+    slug: 'github_copilot',
+    name: 'GitHub Copilot',
+    detect: () => anyPathExists([
+      path.join(home, '.config/github-copilot/hosts.json'),
+      path.join(home, '.config/github-copilot/apps.json'),
+      path.join(process.env.LOCALAPPDATA || path.join(home, 'AppData/Local'), 'github-copilot/hosts.json'),
+    ]),
+    plans: [
+      { slug: 'individual', label: 'Individual ($10/mo)' },
+      { slug: 'business',   label: 'Business ($19/mo)' },
+      { slug: 'enterprise', label: 'Enterprise ($39/mo)' },
+      { slug: 'not_sure',   label: 'Not sure' },
+    ],
+  },
+  {
+    slug: 'windsurf',
+    name: 'Windsurf',
+    detect: () => anyPathExists([path.join(home, '.codeium/windsurf')]),
+    plans: [
+      { slug: 'free',     label: 'Free' },
+      { slug: 'pro',      label: 'Pro ($15/mo)' },
+      { slug: 'not_sure', label: 'Not sure' },
+    ],
+  },
+  {
+    slug: 'continue',
+    name: 'Continue',
+    detect: () => anyPathExists([path.join(home, '.continue')]),
+    plans: [
+      { slug: 'free',     label: 'Free' },
+      { slug: 'pro',      label: 'Pro ($15/mo)' },
+      { slug: 'not_sure', label: 'Not sure' },
+    ],
+  },
+  {
+    slug: 'aider',
+    name: 'Aider',
+    detect: () => binExists('aider --version'),
+    plans: [
+      { slug: 'free',     label: 'Free (bring your own API key)' },
+      { slug: 'pro',      label: 'Pro ($15/mo)' },
+      { slug: 'not_sure', label: 'Not sure' },
+    ],
+  },
+];
+
+export function detectAiTools() {
+  return TOOLS.map(t => ({ slug: t.slug, name: t.name, installed: !!t.detect() }));
+}
+
+// For each detected tool: show a numbered plan menu, read a choice, then ask
+// the renewal day. Returns [{slug, installed:true, plan, cycle_day}]. A tool
+// detected but skipped (blank / invalid choice) is reported as 'not_sure' so
+// the dashboard still shows it's installed. Never throws on bad input - a
+// stray keystroke degrades to 'not_sure', it doesn't abort setup.
+export async function promptForToolPlans(detected) {
+  const installed = detected.filter(d => d.installed);
+  if (installed.length === 0) return [];
+
+  console.log('\n  Found these AI tools on this machine. Set your plan for each so');
+  console.log('  the dashboard shows what you actually pay, not raw token estimates.\n');
+
+  const results = [];
+  for (const d of installed) {
+    const tool = TOOLS.find(t => t.slug === d.slug);
+    console.log(`  ${tool.name}:`);
+    tool.plans.forEach((p, i) => console.log(`    ${i + 1}) ${p.label}`));
+    const ans = await prompt(`  Which plan? [1-${tool.plans.length}, Enter to skip]: `);
+    const idx = parseInt(ans, 10) - 1;
+    const plan = (idx >= 0 && idx < tool.plans.length) ? tool.plans[idx].slug : 'not_sure';
+
+    let cycle_day = null;
+    const chosen = tool.plans.find(p => p.slug === plan);
+    // Only ask the renewal day for a real paid plan - "Free"/"Not sure"/API
+    // have no monthly renewal to track a usage window against.
+    const isPaid = chosen && !['free', 'hobby', 'not_sure', 'api'].includes(plan);
+    if (isPaid) {
+      const dayAns = await prompt('  What day of the month does it renew? [1-31, Enter to skip]: ');
+      const day = parseInt(dayAns, 10);
+      if (day >= 1 && day <= 31) cycle_day = day;
+    }
+    results.push({ slug: d.slug, installed: true, plan, cycle_day });
+    console.log('');
+  }
+  return results;
+}
+
+// Non-interactive fallback (piped stdin / CI): report what's installed as
+// 'not_sure' with no prompt, so a scripted `troxy init` never hangs. The
+// dashboard still gets the inventory; the plan can be set later via the
+// dashboard or an interactive `troxy tools`.
+export function silentToolReport(detected) {
+  return detected.filter(d => d.installed).map(d => ({ slug: d.slug, installed: true, plan: 'not_sure', cycle_day: null }));
+}
+
+export async function reportToolPlans(apiKey, results) {
+  if (!results || results.length === 0) return;
+  try {
+    await api.reportToolPlans(apiKey, results);
+  } catch (err) {
+    // Non-fatal: a failed tool-plan report must never break `troxy init`.
+    console.error(`\n  Could not save AI tool info: ${err.message} (you can set it later in the dashboard).`);
+  }
+}
+
+// The full flow, shared by `troxy init` (interactive step) and `troxy tools`.
+export async function runToolDetection(apiKey, { interactive = true } = {}) {
+  const detected = detectAiTools();
+  const installedCount = detected.filter(d => d.installed).length;
+  if (installedCount === 0) return;
+
+  const results = (interactive && process.stdin.isTTY)
+    ? await promptForToolPlans(detected)
+    : silentToolReport(detected);
+  await reportToolPlans(apiKey, results);
+}

package/src/chat-budget.js

@@ -1,73 +0,0 @@
-import { api }        from './api.js';
-import { requireJwt } from './auth.js';
-import { table }      from './print.js';
-
-const VALID_CURRENCIES = ['USD', 'ILS', 'EUR'];
-const VALID_ACTIONS    = ['block', 'allow', 'notify', 'escalate'];
-
-const HELP = {
-  show: `  troxy chat-budget show\n\n  Shows Troxy Chat's monthly budget limits and what happens when they're hit.\n`,
-  set:  `  troxy chat-budget set [options]\n\n  Updates Troxy Chat's monthly budget. Login required.\n\n    --currency <cur>    USD, ILS, or EUR (default: USD)\n    --limit <n>          Monthly limit for that currency\n    --clear              Remove the limit for that currency\n    --action <action>    block, allow, notify, or escalate: what happens once the limit is hit\n\n  Examples:\n    troxy chat-budget set --currency USD --limit 500\n    troxy chat-budget set --action notify\n    troxy chat-budget set --currency EUR --clear\n`,
-};
-
-export async function runChatBudget([sub, ...args], flags) {
-  if (flags.help || flags.h) {
-    console.log('\n' + (HELP[sub] || `  troxy chat-budget <subcommand> [options]\n\n  Subcommands:\n    show    Show Troxy Chat's budget\n    set     Update Troxy Chat's budget\n\n  Run 'troxy chat-budget <subcommand> --help' for subcommand help.\n`));
-    process.exit(0);
-  }
-
-  const jwt = requireJwt();
-
-  switch (sub || 'show') {
-    case 'show': {
-      const s = await api.getSettings(jwt);
-      console.log(`\n  Action when budget is hit:  ${s.chat_budget_action}\n`);
-      if (!s.chat_budget_limits.length) {
-        console.log('  No monthly limits set.\n');
-        return;
-      }
-      table(
-        ['Currency', 'Limit', 'Used', 'Remaining'],
-        s.chat_budget_limits.map(b => [b.currency, b.limit, b.used, (b.limit - b.used).toFixed(2)]),
-      );
-      break;
-    }
-
-    case 'set': {
-      const body = {};
-
-      if (flags.action) {
-        const action = flags.action.toLowerCase();
-        if (!VALID_ACTIONS.includes(action)) {
-          console.error(`  --action must be one of: ${VALID_ACTIONS.join(', ')}\n`); process.exit(1);
-        }
-        body.budget_action = action;
-      }
-
-      if (flags.limit != null || flags.clear || flags.currency) {
-        const currency = (flags.currency || 'USD').toUpperCase();
-        if (!VALID_CURRENCIES.includes(currency)) {
-          console.error(`  --currency must be one of: ${VALID_CURRENCIES.join(', ')}\n`); process.exit(1);
-        }
-        body.currency = currency;
-        if (flags.clear) body.limit = null;
-        else if (flags.limit != null) body.limit = parseFloat(flags.limit);
-        else { console.error('  --limit is required (or pass --clear to remove the limit)\n'); process.exit(1); }
-      }
-
-      if (Object.keys(body).length === 0) {
-        console.error('  Nothing to update, pass at least one option. Run troxy chat-budget set --help\n');
-        process.exit(1);
-      }
-
-      await api.updateChatBudget(jwt, body);
-      console.log('\n  Chat budget updated ✓\n');
-      break;
-    }
-
-    default:
-      console.error(`  Unknown subcommand: ${sub}`);
-      console.error('  Usage: troxy chat-budget [show|set]\n');
-      process.exit(1);
-  }
-}