unbound-cli 1.17.0 → 1.19.0

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

package/test/tool-health.test.js

@@ -1085,3 +1085,34 @@ test('isUnboundKeyHelper: a helper under a relocated CLAUDE_CONFIG_DIR is still
     delete require.cache[require.resolve('../src/toolHealth')];
   }
 });
+
+// The per-tool env check accepts the shared UNBOUND_DEVICE_TOKEN or the per-tool name from older installs.
+function claudeWithEnv(env) {
+  return withHome((tmp, th) => {
+    writeFile(path.join(tmp, '.claude', 'settings.json'), JSON.stringify({ hooks: { x: [{ command: path.join(tmp, '.claude', 'hooks', 'unbound.py') }] } }));
+    writeFile(path.join(tmp, '.claude', 'hooks', 'unbound.py'), '#');
+    const names = ['UNBOUND_DEVICE_TOKEN', 'UNBOUND_CLAUDE_API_KEY'];
+    const saved = names.map((n) => process.env[n]);
+    names.forEach((n) => delete process.env[n]);
+    Object.assign(process.env, env);
+    try {
+      return th.detectTools({ apiKey: 'k' }).find((x) => x.family === 'claude-code');
+    } finally {
+      names.forEach((n, i) => { if (saved[i] === undefined) delete process.env[n]; else process.env[n] = saved[i]; });
+    }
+  });
+}
+
+test('claude-code: UNBOUND_DEVICE_TOKEN alone → healthy', () => {
+  assert.equal(claudeWithEnv({ UNBOUND_DEVICE_TOKEN: 'k' }).status, 'healthy');
+});
+
+test('claude-code: only the per-tool UNBOUND_CLAUDE_API_KEY → healthy', () => {
+  assert.equal(claudeWithEnv({ UNBOUND_CLAUDE_API_KEY: 'k' }).status, 'healthy');
+});
+
+test('claude-code: neither env set → tampered, naming UNBOUND_DEVICE_TOKEN', () => {
+  const t = claudeWithEnv({});
+  assert.equal(t.status, 'tampered');
+  assert.ok(t.checks.some((c) => !c.ok && /UNBOUND_DEVICE_TOKEN is not set/.test(c.detail)));
+});