unbound-cli 1.18.0 → 1.20.0

package/test/pack-remote.test.js

@@ -0,0 +1,179 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+
+// Stub the HTTP layer before pack-remote loads it.
+const calls = [];
+const stub = {
+  get: async (p, opts) => { calls.push(['GET', p, opts]); return stub.onGet(p, opts); },
+  post: async (p, opts) => { calls.push(['POST', p, opts]); return stub.onPost(p, opts); },
+  put: async (p, opts) => { calls.push(['PUT', p, opts]); return stub.onPut(p, opts); },
+  del: async (p, opts) => { calls.push(['DELETE', p, opts]); return stub.onDel(p, opts); },
+  onGet: async () => ({}),
+  onPost: async () => ({ id: '99' }),
+  onPut: async () => ({}),
+  onDel: async () => ({}),
+};
+require.cache[require.resolve('../src/api')] = { id: path.resolve(__dirname, '../src/api.js'), filename: path.resolve(__dirname, '../src/api.js'), loaded: true, exports: stub };
+const remote = require('../src/lib/pack-remote');
+
+function reset() {
+  calls.length = 0;
+  stub.onGet = async () => ({});
+  stub.onPost = async () => ({ id: '99' });
+  stub.onPut = async () => ({});
+  stub.onDel = async () => ({});
+}
+
+test('replaceRow creates under a temporary name before deleting the old row', async () => {
+  reset();
+  await remote.replaceRow('tool', { id: '11', name: 'Block x' }, { name: 'Block x', policy_type: 'MCP_TOOL', code_pack: 'base', code_slug: 'x' });
+  assert.deepEqual(calls.map((c) => c[0]), ['POST', 'DELETE', 'PUT']);
+  assert.match(calls[0][2].body.name, /^Block x-replacing-/);
+  assert.equal(calls[1][1], '/api/v1/command-policies/11/');
+  assert.deepEqual(calls[2], ['PUT', '/api/v1/command-policies/99/', { body: { name: 'Block x', code_pack: 'base', code_slug: 'x', origin: 'CODE' } }]);
+});
+
+test('replaceRow: a failed create leaves the old row in place', async () => {
+  reset();
+  stub.onPost = async () => { throw new Error('boom'); };
+  await assert.rejects(() => remote.replaceRow('generic', { id: 5, name: 'base/y' }, { name: 'base/y', type: 'COST' }), /boom/);
+  assert.deepEqual(calls.map((c) => c[0]), ['POST'], 'no delete after a failed create');
+});
+
+test('replaceRow reads the id from the generic {policy: ...} envelope', async () => {
+  reset();
+  stub.onPost = async () => ({ policy: { id: 42 } });
+  await remote.replaceRow('generic', { id: 5, name: 'base/y' }, { name: 'base/y', type: 'COST' });
+  assert.equal(calls[2][1], '/api/v1/policies/42/');
+});
+
+test('writeOps never throws for one failed op and reports every outcome', async () => {
+  reset();
+  stub.onPut = async () => { throw new Error('nope'); };
+  const results = await remote.writeOps([
+    { op: 'create', table: 'generic', body: { name: 'base/a' } },
+    { op: 'update', table: 'tool', row: { id: '1' }, body: { action: 'AUDIT' } },
+    { op: 'unchanged', table: 'tool', row: { id: '2' } },
+  ]);
+  assert.deepEqual(results.map((r) => r.status), ['ok', 'failed', 'skipped']);
+  assert.equal(results[1].error, 'nope');
+});
+
+test('fetchManaged asks for the pack by identity and splits unsupported types', async () => {
+  reset();
+  stub.onGet = async (p) => {
+    if (p.startsWith('/api/v1/command-policies/')) {
+      return { policies: [
+        { id: '1', name: 'Audit pushes', policy_type: 'TERMINAL_COMMAND', origin: 'CODE', code_pack: 'base', code_slug: 'a' },
+        { id: '2', name: 'Skill', policy_type: 'SKILL_INJECTION', origin: 'CODE', code_pack: 'base', code_slug: 'skill' },
+        { id: '3', name: 'base/a', policy_type: 'TERMINAL_COMMAND', origin: 'MANUAL' },
+      ], total_pages: 1 };
+    }
+    return { policies: [
+      { id: 10, name: 'Cap', type: 'COST', origin: 'CODE', code_pack: 'base', code_slug: 'cost' },
+      { id: 11, name: 'Repo', type: 'REPO', origin: 'CODE', code_pack: 'base', code_slug: 'repo' },
+      { id: 12, name: 'Other', type: 'COST', origin: 'CODE', code_pack: 'other', code_slug: 'x' },
+    ] };
+  };
+  const live = await remote.fetchManaged('base');
+  assert.deepEqual(live.tool.map((r) => r.name), ['Audit pushes'], 'a MANUAL row named like a pack policy is not managed');
+  assert.deepEqual(live.generic.map((r) => r.name), ['Cap'], 'a row of another pack is not managed');
+  assert.deepEqual(live.unsupported.map((u) => u.row.name), ['Skill', 'Repo']);
+  assert.deepEqual(calls[0][2].query, { code_pack: 'base', origin: 'CODE', page: 1, page_size: 200 });
+  assert.deepEqual(calls[1][2].query, { code_pack: 'base', origin: 'CODE' });
+});
+
+test('fetchAllGrouped walks every page and groups by code_pack', async () => {
+  reset();
+  stub.onGet = async (p, opts) => {
+    if (p.startsWith('/api/v1/command-policies/')) {
+      const page = opts.query.page;
+      return { policies: [{ id: String(page), name: `policy ${page}`, policy_type: 'MCP_TOOL', origin: 'CODE', code_pack: `p${page}`, code_slug: 'a' }], total_pages: 2 };
+    }
+    return { policies: [{ id: 1, name: 'loose', type: 'COST', origin: 'MANUAL' }] };
+  };
+  const { packs, unmanaged } = await remote.fetchAllGrouped();
+  assert.deepEqual([...packs.keys()].sort(), ['p1', 'p2']);
+  assert.equal(unmanaged.length, 1);
+});
+
+test('replaceRow uses a temporary name and identity and rolls back when the old delete fails', async () => {
+  reset();
+  const slug = remote.tempSlug('a-very-long-policy-identifier-that-is-close-to-the-sixty-four-limit');
+  assert.ok(/^[a-z0-9-]{1,64}$/.test(slug), slug);
+  assert.match(remote.tempName('Block rm'), /^Block rm-replacing-/);
+  stub.onDel = async (p) => { if (p.endsWith('/11/')) throw new Error('old delete failed'); return {}; };
+  await assert.rejects(() => remote.replaceRow('tool', { id: '11', name: 'x' }, { name: 'x', code_pack: 'base', code_slug: 'x' }), /old delete failed/);
+  assert.deepEqual(calls.map((c) => [c[0], c[1]]), [['POST', '/api/v1/command-policies/'], ['DELETE', '/api/v1/command-policies/11/'], ['DELETE', '/api/v1/command-policies/99/']]);
+  assert.match(calls[0][2].body.code_slug, /^x-replacing-/);
+  assert.equal(calls[0][2].body.code_pack, 'base');
+});
+
+test('createdId tolerates the response envelopes the CLI accepts', () => {
+  assert.equal(remote.createdId('tool', { id: '7', name: 'x' }), '7');
+  assert.equal(remote.createdId('tool', { command_policy: { id: '8' } }), '8');
+  assert.equal(remote.createdId('tool', { policy: { id: '9' } }), '9');
+  assert.equal(remote.createdId('generic', { policy: { id: 10 } }), 10);
+  assert.equal(remote.createdId('generic', {}), null);
+  assert.equal(remote.createdId('generic', null), null);
+});
+
+test('findByExactName tags rows of unmanaged types as unsupported', async () => {
+  reset();
+  stub.onGet = async (p) => (p.startsWith('/api/v1/command-policies/')
+    ? { policies: [{ id: '1', name: 'Skill', policy_type: 'SKILL_INJECTION' }, { id: '2', name: 'Skill2', policy_type: 'MCP_TOOL' }], total_pages: 1 }
+    : { policies: [] });
+  const hits = await remote.findByExactName('Skill');
+  assert.equal(hits.length, 1);
+  assert.equal(hits[0].supported, false);
+  const ok = await remote.findByExactName('Skill2');
+  assert.equal(ok[0].supported, true);
+});
+
+test('every write declares origin CODE; delete carries it as a query parameter', async () => {
+  reset();
+  await remote.createRow('tool', { name: 'base/x', action: 'AUDIT' });
+  await remote.updateRow('generic', 23, { enabled: true });
+  await remote.deleteRow('tool', '11');
+  assert.deepEqual(calls[0], ['POST', '/api/v1/command-policies/', { body: { name: 'base/x', action: 'AUDIT', origin: 'CODE' } }]);
+  assert.deepEqual(calls[1], ['PUT', '/api/v1/policies/23/', { body: { enabled: true, origin: 'CODE' } }]);
+  assert.deepEqual(calls[2], ['DELETE', '/api/v1/command-policies/11/', { query: { origin: 'CODE' } }]);
+});
+
+test('loadReference records why the MCP catalogue is missing instead of hiding it', async () => {
+  reset();
+  remote.resetReference();
+  stub.onGet = async (p) => {
+    if (p.includes('mcp-servers')) throw new Error('503 from gateway-data');
+    if (p.includes('labels')) return { labels: [] };
+    return { user_groups: [], guardrails: [], ai_models: [], tool_types: [] };
+  };
+  const ref = await remote.loadReference({ mcp: true });
+  assert.deepEqual(ref.mcpServers, []);
+  assert.match(ref.mcpServersError, /503 from gateway-data/);
+  remote.resetReference();
+});
+
+test('a backend without the origin field is refused before any write', async () => {
+  reset();
+  stub.onGet = async (p) => (p.startsWith('/api/v1/command-policies/')
+    ? { policies: [{ id: '1', name: 'Block rm', policy_type: 'TERMINAL_COMMAND' }], total_pages: 1 }
+    : { policies: [{ id: 10, name: 'Cap', type: 'COST' }] });
+  await assert.rejects(() => remote.fetchManaged('base'), /newer server release/);
+  await assert.rejects(() => remote.fetchAllGrouped(), /newer server release/);
+  // An empty org cannot be told apart and simply has nothing to manage yet.
+  stub.onGet = async () => ({ policies: [], total_pages: 1 });
+  const live = await remote.fetchManaged('base');
+  assert.deepEqual(live, { tool: [], generic: [], unsupported: [] });
+});
+
+test('fetchAllNames maps every live name to its owner', async () => {
+  reset();
+  stub.onGet = async (p) => (p.startsWith('/api/v1/command-policies/')
+    ? { policies: [{ id: '1', name: 'Block rm', policy_type: 'TERMINAL_COMMAND', origin: 'MANUAL' }], total_pages: 1 }
+    : { policies: [{ id: 10, name: 'Cap', type: 'COST', origin: 'CODE', code_pack: 'base', code_slug: 'cap' }] });
+  const names = await remote.fetchAllNames();
+  assert.deepEqual(names.get('Block rm'), { table: 'tool', id: '1', code_pack: null, code_slug: null });
+  assert.deepEqual(names.get('Cap'), { table: 'generic', id: 10, code_pack: 'base', code_slug: 'cap' });
+});

package/test/pack-schema.test.js

@@ -0,0 +1,144 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const schema = require('../src/lib/pack-schema');
+
+const BASE = `
+apiVersion: unbound.security/v1
+kind: PolicyPack
+metadata:
+  name: k8s-baseline
+  version: 1.2.0
+defaults:
+  scope:
+    userGroups: [Engineering]
+policies:
+  - id: block-secret-reads
+    kind: tool
+    type: TERMINAL_COMMAND
+    action: BLOCK
+    commandFamily: custom
+    customMessage: Reading cluster secrets is blocked.
+    config:
+      command: "regex:kubectl\\\\s+get\\\\s+secrets?"
+  - id: github-writes
+    kind: tool
+    type: MCP_TOOL
+    action: REQUIRE_SLACK_APPROVAL
+    mcp:
+      server: github
+      tools: [create_pull_request, push_files]
+    scope:
+      userGroups: [Contractors]
+  - id: pii-guard
+    kind: security
+    priority: 10
+    guardrails:
+      - name: PII
+        action: BLOCK
+        threshold: 5
+  - id: monthly-cap
+    kind: cost
+    enabled: false
+    config:
+      monthly_budget: 5000
+`;
+
+function load(text, file = 'pack.yaml') {
+  return schema.validatePack(schema.parsePackText(text, file), file);
+}
+
+test('validatePack: happy path merges defaults and builds server names', () => {
+  const pack = load(BASE);
+  assert.equal(pack.name, 'k8s-baseline');
+  assert.equal(pack.version, '1.2.0');
+  assert.equal(pack.policies.length, 4);
+  const [terminal, mcp, security, cost] = pack.policies;
+  assert.equal(terminal.serverName, 'block-secret-reads');
+  assert.equal(terminal.enabled, true);
+  assert.deepEqual(terminal.scope, { userGroups: ['Engineering'] });
+  assert.deepEqual(mcp.scope, { userGroups: ['Contractors'] }, 'policy scope wins over defaults');
+  assert.equal(security.priority, 10);
+  assert.equal(cost.enabled, false);
+});
+
+test('parsePackText: JSON by extension, YAML otherwise', () => {
+  const doc = { apiVersion: 'unbound.security/v1', kind: 'PolicyPack', metadata: { name: 'p', version: '1' }, policies: [{ id: 'a', kind: 'cost', config: { monthly_budget: 1 } }] };
+  assert.deepEqual(schema.parsePackText(JSON.stringify(doc), 'p.json'), doc);
+  assert.deepEqual(schema.parsePackText('a: 1\n', 'p.yaml'), { a: 1 });
+  assert.throws(() => schema.parsePackText('a: [\n', 'bad.yaml'), (err) => err instanceof schema.PackError && err.exitCode === 2);
+  assert.throws(() => schema.parsePackText('a: 1\n---\nb: 2\n', 'two.yaml'), /exactly one YAML document/);
+});
+
+test('validatePack: rejects wrong apiVersion and kind', () => {
+  assert.throws(() => load(BASE.replace('unbound.security/v1', 'unbound.security/v2')), /apiVersion must be/);
+  assert.throws(() => load(BASE.replace('kind: PolicyPack', 'kind: Pack')), /kind must be/);
+});
+
+test('validatePack: unknown keys fail at every level', () => {
+  assert.throws(() => load(`${BASE}\nextra: 1\n`), /top level: unknown key "extra"/);
+  assert.throws(() => load(BASE.replace('  version: 1.2.0', '  version: 1.2.0\n  author: x')), /metadata: unknown key "author"/);
+  assert.throws(() => load(BASE.replace('    kind: cost', '    kind: cost\n    colour: red')), /unknown key "colour"/);
+  assert.throws(() => load(BASE.replace('      server: github', '      server: github\n      port: 1')), /mcp: unknown key "port"/);
+});
+
+test('validatePack: slug rules and duplicate ids', () => {
+  assert.throws(() => load(BASE.replace('name: k8s-baseline', 'name: K8s Baseline')), /metadata.name/);
+  assert.throws(() => load(BASE.replace('id: monthly-cap', 'id: Monthly Cap')), /policies\[3\].id/);
+  assert.throws(() => load(BASE.replace('id: monthly-cap', 'id: pii-guard')), /used twice/);
+});
+
+test('validatePack: kind-specific keys are enforced', () => {
+  // tool-only key on a generic policy
+  assert.throws(() => load(BASE.replace('    kind: cost', '    kind: cost\n    action: BLOCK')), /unknown key "action"/);
+  // generic-only key on a tool policy
+  assert.throws(() => load(BASE.replace('    kind: tool\n    type: TERMINAL_COMMAND', '    kind: tool\n    priority: 1\n    type: TERMINAL_COMMAND')), /unknown key "priority"/);
+  // toolTypes scope only on generic
+  assert.throws(() => load(BASE.replace('      userGroups: [Contractors]', '      toolTypes: [cursor]')), /scope.toolTypes applies to/);
+  // guardrails only on security
+  assert.throws(() => load(BASE.replace('    kind: cost', '    kind: cost\n    guardrails: []')), /unknown key "guardrails"/);
+});
+
+test('validatePack: tool policy rules', () => {
+  assert.throws(() => load(BASE.replace('action: BLOCK\n    commandFamily', 'action: DENY\n    commandFamily')), /action must be one of/);
+  assert.throws(() => load(BASE.replace('    customMessage: Reading cluster secrets is blocked.\n', '')), /customMessage is required when action is BLOCK or WARN/);
+  assert.throws(() => load(BASE.replace('    commandFamily: custom\n', '')), /commandFamily is required/);
+  assert.throws(() => load(BASE.replace('      tools: [create_pull_request, push_files]', '      tool: a\n      actionType: write')), /exactly one of tool, tools or actionType/);
+  assert.throws(() => load(BASE.replace('      tools: [create_pull_request, push_files]', '      actionType: nuke')), /actionType must be one of/);
+});
+
+test('validatePack: generic policy rules', () => {
+  assert.throws(() => load(BASE.replace('        threshold: 5', '        threshold: 500')), /threshold must be an integer from 1 to 100/);
+  assert.throws(() => load(BASE.replace('        action: BLOCK\n        threshold: 5', '        action: ROUTE\n')), /routeModel is required when action is ROUTE/);
+  assert.throws(() => load(BASE.replace('    config:\n      monthly_budget: 5000', '    config: {}')), /cost policy needs a config/);
+  assert.throws(() => load(BASE.replace('    priority: 10', '    priority: 10\n    config:\n      guardrails: []')), /either guardrails or config.guardrails/);
+  const modelBad = BASE.replace('    kind: cost\n    enabled: false\n    config:\n      monthly_budget: 5000', '    kind: model\n    models:\n      allowed: [a]\n      allowAll: true');
+  assert.throws(() => load(modelBad), /allowed cannot be combined/);
+});
+
+test('validatePack: policies must be a non-empty list', () => {
+  assert.throws(() => load(BASE.replace(/policies:[\s\S]*$/, 'policies: []\n')), /non-empty list/);
+});
+
+test('slugify turns a console name into a policy id', () => {
+  assert.equal(schema.slugify('Block kubectl secrets!'), 'block-kubectl-secrets');
+  assert.equal(schema.slugify('   '), null);
+});
+
+test('validatePack: name is optional free text, unique within the pack', () => {
+  const base = { apiVersion: 'unbound.security/v1', kind: 'PolicyPack', metadata: { name: 'p', version: '1' } };
+  const ok = schema.validatePack({ ...base, policies: [
+    { id: 'a', name: 'Monthly cap for engineering', kind: 'cost', config: { monthly_budget: 1 } },
+    { id: 'b', kind: 'cost', config: { monthly_budget: 2 } },
+  ] }, 'p.yaml');
+  assert.deepEqual(ok.policies.map((x) => x.serverName), ['Monthly cap for engineering', 'b']);
+  assert.throws(() => schema.validatePack({ ...base, policies: [{ id: 'a', name: '  ', kind: 'cost', config: { monthly_budget: 1 } }] }, 'p.yaml'), /name must be a non-empty string/);
+  assert.throws(() => schema.validatePack({ ...base, policies: [
+    { id: 'a', name: 'Same', kind: 'cost', config: { monthly_budget: 1 } }, { id: 'b', name: 'Same', kind: 'cost', config: { monthly_budget: 2 } },
+  ] }, 'p.yaml'), /"Same" is used twice/);
+});
+
+test('validatePack: description is a tool-policy key only', () => {
+  assert.throws(() => load(BASE.replace('    kind: cost', '    kind: cost\n    description: dropped')), /unknown key "description"/);
+  assert.doesNotThrow(() => load(BASE.replace('    kind: tool\n    type: TERMINAL_COMMAND', '    kind: tool\n    description: kept\n    type: TERMINAL_COMMAND')));
+});