troxy-cli 1.21.0 → 1.22.0

package/src/tests/policies-org.test.js

@@ -0,0 +1,60 @@
+// Org policy support end to end: api.js has the routes, policies.js checks
+// --org in every subcommand that has both a personal and an org meaning, and
+// a write subcommand requires admin while list/describe only require
+// membership - matching orgs.py's is_org_admin vs is_org_member split.
+//
+// Source-inspection style, like rotate-key.test.js: driving the real
+// subcommands would need a live JWT and a real org, which this test suite
+// doesn't have. What it can check without either is that the wiring exists
+// and that a write path can't skip the admin check.
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const apiSrc = readFileSync(join(__dirname, '..', 'api.js'), 'utf8');
+const polSrc = readFileSync(join(__dirname, '..', 'policies.js'), 'utf8');
+
+test('the org policy routes are wired in the api client', () => {
+  for (const path of ["'/orgs/current'", '`/orgs/${orgId}/policies`', '`/orgs/${orgId}/policies/${id}`']) {
+    assert.ok(apiSrc.includes(path), `${path} not wired in api.js`);
+  }
+});
+
+test('every write subcommand resolves org context with admin required', () => {
+  // Each of these blocks should call _resolveOrgContext(jwt, true) when
+  // flags.org is set, mirroring orgs.py's is_org_admin gate on every
+  // POST/PATCH/DELETE to /orgs/:id/policies*.
+  const writeSubcommands = ["case 'delete'", "case 'pause'", "case 'set-priority'"];
+  for (const marker of writeSubcommands) {
+    const start = polSrc.indexOf(marker);
+    assert.ok(start !== -1, `${marker} not found in policies.js`);
+    const chunk = polSrc.slice(start, start + 1200);
+    assert.ok(
+      /_resolveOrgContext\(jwt,\s*true\)/.test(chunk),
+      `${marker} does not call _resolveOrgContext(jwt, true) - an org write could bypass the admin check`,
+    );
+  }
+});
+
+test('create requires admin for --org but read subcommands do not', () => {
+  const createStart = polSrc.indexOf("case 'create'");
+  const createChunk = polSrc.slice(createStart, createStart + 4000);
+  assert.ok(/_resolveOrgContext\(jwt,\s*true\)/.test(createChunk), 'create --org must require admin');
+
+  // list/describe are read-only - orgs.py's handle_list_org_policies allows
+  // any active member, not just admins. Passing `false` here is what makes
+  // that distinction actually reach the CLI instead of over-restricting reads.
+  const listStart = polSrc.indexOf("case 'list':");
+  const listChunk = polSrc.slice(listStart, listStart + 800);
+  assert.ok(/_resolveOrgContext\(jwt,\s*false\)/.test(listChunk), 'list --org should not require admin (read access is for any member)');
+});
+
+test('org policy creation sends the domain, unlike the old payment-only path', () => {
+  const createStart = polSrc.indexOf("case 'create'");
+  const chunk = polSrc.slice(createStart, polSrc.indexOf('createOrgPolicy', createStart) + 50);
+  assert.ok(/createOrgPolicy\(jwt,\s*org\.id,\s*body\)/.test(chunk));
+  assert.ok(/body\s*=\s*\{\s*name,\s*action,\s*domain,\s*conditions,\s*or_conditions/.test(chunk), 'org policy body must include domain - without it every org policy defaults to payment');
+});

package/src/tests/simulate.test.js

@@ -0,0 +1,127 @@
+// Field-name correctness for the five checkpoint-simulate commands added
+// alongside `troxy pay` (send/signin/action/model-call/scan). A typo'd field
+// name here is invisible until someone reads the JSON: the request still
+// posts, the checkpoint still answers, and it just never matches the policy
+// it was meant to test - the same "saves fine, never fires" failure this
+// whole session has been chasing on the dashboard and backend sides.
+//
+// Body-building is exported separately from the network call specifically so
+// this is checkable without a live login session (see simulate.js's own note
+// on why).
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { _sendBody, _signinBody, _actionBody, _modelCallBody, _scanBody, _policyName } from '../simulate.js';
+
+function _expectExit(fn) {
+  const orig = process.exit;
+  process.exit = (code) => { throw new Error(`__EXIT_${code}__`); };
+  try {
+    fn();
+    throw new Error('expected process.exit to be called, but it was not');
+  } catch (e) {
+    if (!/^__EXIT_\d+__$/.test(e.message)) throw e;
+  } finally {
+    process.exit = orig;
+  }
+}
+
+test('send builds the exact fields /evaluate/email expects', () => {
+  const b = _sendBody({ recipient: 'jane@acme.com', subject: 'Q3', body: 'attached', channel: 'slack' });
+  assert.deepStrictEqual(b.recipient, 'jane@acme.com');
+  assert.deepStrictEqual(b.recipients, ['jane@acme.com']);
+  assert.strictEqual(b.subject, 'Q3');
+  assert.strictEqual(b.body, 'attached');
+  assert.strictEqual(b.channel, 'slack');
+});
+
+test('send defaults channel to email and merges --recipient with --recipients', () => {
+  const b = _sendBody({ recipient: 'a@x.com', recipients: 'b@x.com, c@x.com' });
+  assert.strictEqual(b.channel, 'email');
+  assert.deepStrictEqual(b.recipients, ['a@x.com', 'b@x.com', 'c@x.com']);
+});
+
+test('send requires a recipient', () => {
+  _expectExit(() => _sendBody({}));
+});
+
+test('signin builds login_action, not a made-up "type" field the backend does not read', () => {
+  const b = _signinBody({ site: 'coinbase.com', type: 'signup' });
+  assert.strictEqual(b.site, 'coinbase.com');
+  assert.strictEqual(b.login_action, 'signup');
+  assert.ok(!('type' in b), 'the CLI flag is --type but the wire field is login_action - both must not leak through');
+});
+
+test('signin defaults to login and rejects anything else', () => {
+  assert.strictEqual(_signinBody({ site: 'x.com' }).login_action, 'login');
+  _expectExit(() => _signinBody({ site: 'x.com', type: 'signin' })); // not a real value
+});
+
+test('action builds action_verb/item_count/reversible, not verb/items/reversible', () => {
+  const b = _actionBody({ verb: 'delete', resource: 'prod users table', items: '500', reversible: 'false' });
+  assert.strictEqual(b.action_verb, 'delete');
+  assert.strictEqual(b.resource, 'prod users table');
+  assert.strictEqual(b.item_count, 500);
+  assert.strictEqual(b.reversible, false);
+});
+
+test('action defaults item_count to 1 and reversible to false', () => {
+  const b = _actionBody({ verb: 'share', resource: 'doc' });
+  assert.strictEqual(b.item_count, 1);
+  assert.strictEqual(b.reversible, false);
+  assert.ok(!('destination' in b), 'destination should be omitted, not sent as undefined, when not given');
+});
+
+test('action requires verb and resource', () => {
+  _expectExit(() => _actionBody({ resource: 'x' }));
+  _expectExit(() => _actionBody({ verb: 'delete' }));
+});
+
+test('model-call builds estimated_cost, not "cost"', () => {
+  const b = _modelCallBody({ model: 'claude-opus-5', provider: 'anthropic', cost: '4.50', tokens: '900000', effort: 'high' });
+  assert.strictEqual(b.estimated_cost, 4.5);
+  assert.strictEqual(b.tokens, 900000);
+  assert.strictEqual(b.effort, 'high');
+  assert.ok(!('cost' in b), 'the CLI flag is --cost but the wire field is estimated_cost');
+});
+
+test('model-call defaults estimated_cost to 0 and omits tokens/effort when not given', () => {
+  const b = _modelCallBody({ model: 'x', provider: 'y' });
+  assert.strictEqual(b.estimated_cost, 0);
+  assert.ok(!('tokens' in b));
+  assert.ok(!('effort' in b));
+});
+
+test('scan builds content_type and action, not type and do', () => {
+  const b = _scanBody({ content: 'AWS_KEY=abc', destination: 'public', do: 'push', type: 'code' });
+  assert.strictEqual(b.content, 'AWS_KEY=abc');
+  assert.strictEqual(b.destination, 'public');
+  assert.strictEqual(b.action, 'push');
+  assert.strictEqual(b.content_type, 'code');
+  assert.ok(!('do' in b) && !('type' in b), 'the CLI flags are --do/--type but the wire fields are action/content_type');
+});
+
+test('scan defaults destination to public, action to send, content_type to message', () => {
+  const b = _scanBody({ content: 'hi' });
+  assert.strictEqual(b.destination, 'public');
+  assert.strictEqual(b.action, 'send');
+  assert.strictEqual(b.content_type, 'message');
+});
+
+test('scan requires content', () => {
+  _expectExit(() => _scanBody({}));
+});
+
+// ── _policyName: reads `policy` where present, else parses `reason` ────────
+
+test('prefers the top-level policy field when present (the payment checkpoint shape)', () => {
+  assert.strictEqual(_policyName({ policy: 'Block over $100', reason: 'irrelevant' }), 'Block over $100');
+});
+
+test('falls back to parsing the reason sentence (every other checkpoint\'s shape)', () => {
+  assert.strictEqual(_policyName({ reason: "Matched policy 'Escalate every signup'." }), 'Escalate every signup');
+});
+
+test('returns null rather than a wrong guess when nothing matched', () => {
+  assert.strictEqual(_policyName({ reason: 'No secrets policy matched; default for high severity is BLOCK.' }), null);
+  assert.strictEqual(_policyName({}), null);
+});

package/src/tests/templates.test.js

@@ -0,0 +1,46 @@
+// The vendored templates (src/data/templates.json) are only useful if every
+// one of them is a condition the backend will actually accept - a template
+// that fails this is a customer's first "troxy policies create --template"
+// saving a rule that never fires, the exact class of bug this whole spec-
+// vendoring pattern exists to catch before it ships.
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { validateCondition } from '../policy-fields.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const { templates } = JSON.parse(readFileSync(join(__dirname, '..', 'data', 'templates.json'), 'utf8'));
+
+test('every vendored template has at least one condition or is a deliberate catch-all', () => {
+  assert.ok(templates.length >= 60, `expected ~69 templates, found ${templates.length} - did export-templates.mjs run against a stale/empty index.html?`);
+});
+
+test('every condition in every template validates against the field spec', () => {
+  const failures = [];
+  for (const t of templates) {
+    const allConds = [
+      ...t.conditions,
+      ...t.or_conditions.flatMap(b => b.conditions),
+    ];
+    for (const c of allConds) {
+      const err = validateCondition(t.domain, c.field, c.operator, c.value, c.value2);
+      if (err) failures.push(`"${t.label}" (${t.domain}): ${c.field} ${c.operator} ${c.value} -> ${err}`);
+    }
+  }
+  assert.deepStrictEqual(failures, [], failures.join('\n'));
+});
+
+test('every template action is one the engine recognizes', () => {
+  const VALID = new Set(['ALLOW', 'BLOCK', 'ESCALATE', 'NOTIFY']);
+  const bad = templates.filter(t => !VALID.has(t.action));
+  assert.deepStrictEqual(bad.map(t => t.label), []);
+});
+
+test('a template can be found by exact label', () => {
+  const t = templates.find(t => t.label === 'Block all destructive actions');
+  assert.ok(t, 'expected the destructive catch-all template to be present');
+  assert.strictEqual(t.domain, 'destructive');
+  assert.strictEqual(t.conditions.length, 0);
+});

package/src/tool_detect.js

@@ -0,0 +1,179 @@
+import fs       from 'fs';
+import os       from 'os';
+import path     from 'path';
+import readline from 'readline';
+import { execSync } from 'child_process';
+import { api }   from './api.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();
+
+function binExists(cmd) {
+  try { execSync(cmd, { stdio: 'ignore' }); return true; } catch { return false; }
+}
+
+function anyPathExists(paths) {
+  return paths.some(p => { try { return fs.existsSync(p); } catch { return false; } });
+}
+
+export const TOOLS = [
+  {
+    slug: 'claude_code',
+    name: 'Claude Code',
+    detect: () => binExists('claude --version'),
+    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: 'not_sure', label: 'Not sure' },
+    ],
+  },
+];
+
+export function detectAiTools() {
+  return TOOLS.map(t => ({ slug: t.slug, name: t.name, installed: !!t.detect() }));
+}
+
+function _prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans.trim()); }));
+}
+
+// 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);
+}