troxy-cli 1.21.1 → 1.23.0

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

@@ -0,0 +1,218 @@
+// `policies create` used to know about exactly three fields - amount,
+// merchant_name, tx_per_day - because payment was the whole product when it
+// was written. These tests cover the domain-aware rewrite: every field in
+// every checkpoint should be reachable, a field that belongs to more than one
+// domain should require an explicit --domain rather than guessing, and the
+// three condition-building paths (single/--and/--or, --json, --template)
+// should each produce exactly the request body the server expects - checked
+// directly against the built object, not by diffing console output.
+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 { _buildConditionsFromFlags, _findTemplate } from '../policies.js';
+
+// _buildConditionsFromFlags and _findTemplate call process.exit(1) on a bad
+// input rather than throwing - this makes that path testable without ending
+// the test process, by turning the exit into a catchable error. console.error
+// still prints its message, matching how a user would actually see it.
+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('a payment field with no --domain still infers payment (backward compat)', () => {
+  const r = _buildConditionsFromFlags(
+    { action: 'BLOCK', field: 'amount', operator: 'gt', value: '100' }, {}, { requireAction: true },
+  );
+  assert.strictEqual(r.domain, 'payment');
+  assert.deepStrictEqual(r.conditions, [{ field: 'amount', operator: 'gt', value: '100' }]);
+  assert.deepStrictEqual(r.or_conditions, []);
+});
+
+test('a non-payment field works with an explicit --domain - this is the whole point of the rewrite', () => {
+  const r = _buildConditionsFromFlags(
+    { action: 'ESCALATE', domain: 'access', field: 'login_action', operator: 'eq', value: 'signup' }, {}, { requireAction: true },
+  );
+  assert.strictEqual(r.domain, 'access');
+  assert.deepStrictEqual(r.conditions, [{ field: 'login_action', operator: 'eq', value: 'signup' }]);
+});
+
+test('domain aliases resolve (login -> access, the persisted-column naming trap)', () => {
+  const r = _buildConditionsFromFlags(
+    { action: 'ESCALATE', domain: 'login', field: 'login_action', operator: 'eq', value: 'signup' }, {}, { requireAction: true },
+  );
+  assert.strictEqual(r.domain, 'access');
+});
+
+test('a field shared by two domains (destination) requires an explicit --domain', () => {
+  _expectExit(() => _buildConditionsFromFlags(
+    { action: 'BLOCK', field: 'destination', operator: 'eq', value: 'public' }, {}, { requireAction: true },
+  ));
+});
+
+test('an operator the field does not support is rejected before it reaches the server', () => {
+  _expectExit(() => _buildConditionsFromFlags(
+    { action: 'BLOCK', domain: 'payment', field: 'amount', operator: 'contains', value: '100' }, {}, { requireAction: true },
+  ));
+});
+
+test('a boolean field rejects anything but true/false', () => {
+  _expectExit(() => _buildConditionsFromFlags(
+    { action: 'BLOCK', domain: 'secrets', field: 'has_api_key', operator: 'eq', value: 'yes' }, {}, { requireAction: true },
+  ));
+});
+
+test('an enum field rejects a value the checkpoint never reports', () => {
+  _expectExit(() => _buildConditionsFromFlags(
+    { action: 'BLOCK', domain: 'access', field: 'login_action', operator: 'eq', value: 'signin' }, {}, { requireAction: true },
+  ));
+});
+
+test('repeated --and builds one AND block, no branches', () => {
+  const r = _buildConditionsFromFlags(
+    { action: 'BLOCK', domain: 'destructive', field: 'action_verb', operator: 'eq', value: 'export' },
+    { and: ['field=resource,operator=contains,value=customer'] },
+    { requireAction: true },
+  );
+  assert.deepStrictEqual(r.conditions, [
+    { field: 'action_verb', operator: 'eq', value: 'export' },
+    { field: 'resource', operator: 'contains', value: 'customer' },
+  ]);
+  assert.deepStrictEqual(r.or_conditions, []);
+});
+
+test('repeated --or builds one branch per alternative, sharing --action', () => {
+  const r = _buildConditionsFromFlags(
+    { action: 'BLOCK', domain: 'comms' },
+    { or: [
+      'field=recipient_domain,operator=contains,value=gmail.com',
+      'field=recipient_domain,operator=contains,value=yahoo.com',
+    ] },
+    { requireAction: true },
+  );
+  assert.strictEqual(r.conditions.length, 0);
+  assert.strictEqual(r.or_conditions.length, 2);
+  assert.deepStrictEqual(r.or_conditions[0], { action: 'BLOCK', conditions: [{ field: 'recipient_domain', operator: 'contains', value: 'gmail.com' }] });
+  assert.deepStrictEqual(r.or_conditions[1], { action: 'BLOCK', conditions: [{ field: 'recipient_domain', operator: 'contains', value: 'yahoo.com' }] });
+});
+
+test('--and conditions apply to every --or branch, not just the first', () => {
+  const r = _buildConditionsFromFlags(
+    { action: 'BLOCK', domain: 'destructive', field: 'action_verb', operator: 'eq', value: 'delete' },
+    { or: ['field=resource,operator=contains,value=prod', 'field=resource,operator=contains,value=staging'] },
+    { requireAction: true },
+  );
+  assert.strictEqual(r.or_conditions.length, 2);
+  for (const branch of r.or_conditions) {
+    assert.ok(branch.conditions.some(c => c.field === 'action_verb'), 'the AND condition must be present in every branch');
+  }
+});
+
+test('a malformed --and (missing operator=) is rejected with a clear error, not a silent partial condition', () => {
+  _expectExit(() => _buildConditionsFromFlags(
+    { action: 'BLOCK', domain: 'payment' }, { and: ['field=amount,value=100'] }, { requireAction: true },
+  ));
+});
+
+test('--json is a full escape hatch and is still domain-validated', () => {
+  const r = _buildConditionsFromFlags(
+    { action: 'ESCALATE', domain: 'model', json: JSON.stringify({ conditions: [{ field: 'output_price', operator: 'gt', value: '10' }] }) },
+    {}, { requireAction: true },
+  );
+  assert.strictEqual(r.domain, 'model');
+  assert.deepStrictEqual(r.conditions, [{ field: 'output_price', operator: 'gt', value: '10' }]);
+});
+
+test('--json rejects a condition the field spec would reject', () => {
+  _expectExit(() => _buildConditionsFromFlags(
+    { action: 'BLOCK', domain: 'model', json: JSON.stringify({ conditions: [{ field: 'output_price', operator: 'contains', value: '10' }] }) },
+    {}, { requireAction: true },
+  ));
+});
+
+test('--json cannot be combined with --field', () => {
+  _expectExit(() => _buildConditionsFromFlags(
+    { action: 'BLOCK', domain: 'payment', field: 'amount', operator: 'gt', value: '1', json: '{}' }, {}, { requireAction: true },
+  ));
+});
+
+test('--template applies the template\'s own domain, action and conditions', () => {
+  const r = _buildConditionsFromFlags({ template: 'Block all destructive actions' }, {}, { requireAction: true });
+  assert.strictEqual(r.domain, 'destructive');
+  assert.strictEqual(r.action, 'BLOCK');
+  assert.deepStrictEqual(r.conditions, []);
+  assert.deepStrictEqual(r.or_conditions, []);
+});
+
+test('--template --value overrides the threshold on a single-condition template', () => {
+  const r = _buildConditionsFromFlags({ template: 'Block models over $10/MTok output', value: '25' }, {}, { requireAction: true });
+  assert.strictEqual(r.conditions[0].value, '25');
+  assert.strictEqual(r.conditions[0].field, 'output_price'); // unchanged
+});
+
+test('--template --value is refused on a template with more than one condition', () => {
+  _expectExit(() => _buildConditionsFromFlags({ template: 'Escalate making a file public', value: '5' }, {}, { requireAction: true }));
+});
+
+test('--template --action overrides the template default', () => {
+  const r = _buildConditionsFromFlags({ template: 'Escalate making a file public', action: 'BLOCK' }, {}, { requireAction: true });
+  assert.strictEqual(r.action, 'BLOCK');
+});
+
+test('--template cannot be combined with --field', () => {
+  _expectExit(() => _buildConditionsFromFlags(
+    { template: 'Block all destructive actions', field: 'amount', operator: 'gt', value: '1' }, {}, { requireAction: true },
+  ));
+});
+
+test('an unknown template name exits with suggestions rather than a stack trace', () => {
+  _expectExit(() => _findTemplate('Block all destructve actions')); // typo
+});
+
+test('a template is found case-insensitively', () => {
+  const t = _findTemplate('block all destructive actions');
+  assert.strictEqual(t.label, 'Block all destructive actions');
+});
+
+// ── _displayAction: the raw `action` column is stale on essentially every
+// dashboard-built policy; effective_action (added server-side, see
+// troxy-tf-live's policies.py _effective_action) is the resolved value. This
+// is only a fallback for a server that hasn't deployed the field yet.
+
+test('_displayAction prefers effective_action when present', async () => {
+  const { _displayAction } = await import('../policies.js');
+  assert.strictEqual(_displayAction({ action: 'ESCALATE', effective_action: 'BLOCK' }), 'BLOCK');
+});
+
+test('_displayAction falls back to the raw action against an older server', async () => {
+  const { _displayAction } = await import('../policies.js');
+  assert.strictEqual(_displayAction({ action: 'BLOCK' }), 'BLOCK');
+});
+
+// ── --describe: handle_ai_policy only knows a binary payment/comms allowlist,
+// gated on is_email. Source-inspection style, matching model-checkpoint.test.js -
+// this branch needs a live login session + org AI key to drive end to end.
+
+test('--describe sends is_email when --domain comms is requested', () => {
+  const src = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'policies.js'), 'utf8');
+  const start = src.indexOf('if (flags.describe)');
+  const chunk = src.slice(start, start + 2000);
+  assert.ok(
+    /is_email:\s*describeDomain\s*===\s*'comms'/.test(chunk),
+    '--describe must forward is_email to api.aiPolicy, or every request silently uses the payment field allowlist regardless of what was described',
+  );
+  assert.ok(
+    /\['payment', 'comms'\]\.includes\(describeDomain\)/.test(chunk),
+    '--describe must reject any domain the AI builder does not actually support, rather than silently mis-drafting against the payment allowlist',
+  );
+});

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);
+});