unbound-cli 1.20.2 → 1.20.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unbound-cli",
-  "version": "1.20.2",
+  "version": "1.20.4",
   "description": "CLI tool for Unbound - AI Gateway management",
   "main": "src/index.js",
   "bin": {

package/src/commands/pack.js

@@ -124,7 +124,7 @@ const ACTION_LABEL = {
   conflict: 'CONFLICT',
 };
 
-function printPlan({ file, pack, ops, live }) {
+function printPlan({ file, pack, ops, live, versionState }) {
   console.log('');
   output.info(`Pack ${pack.name} v${pack.version} (${file})`);
   output.table(ops, [
@@ -143,6 +143,9 @@ function printPlan({ file, pack, ops, live }) {
     output.warn(`${off.length} polic${many ? 'ies are' : 'y is'} off on the server but on in the pack (switched off in the console, or just enabled in the file). Apply turns ${many ? 'them' : 'it'} on; to keep ${many ? 'one' : 'it'} off, set enabled: false in the pack file.`);
   }
   const s = summarize(ops);
+  if (versionState.supported && versionState.version !== pack.version) {
+    output.info(`Stored version: ${versionState.version || 'none'} -> ${pack.version}`);
+  }
   const parts = [];
   if (s.create) parts.push(`${s.create} to create`);
   if (s.update) parts.push(`${s.update} to update`);
@@ -154,12 +157,14 @@ function printPlan({ file, pack, ops, live }) {
   console.log(`  ${parts.join(', ')}`);
 }
 
-function planJson({ file, pack, ops }) {
+function planJson({ file, pack, ops, versionState }) {
+  const summary = summarize(ops);
+  const versionOnly = versionState.supported && versionState.version !== pack.version && !summary.drift;
   return {
     pack: pack.name,
     version: pack.version,
     file,
-    summary: summarize(ops),
+    summary: { ...summary, drift: summary.drift + (versionOnly ? 1 : 0) },
     ops: ops.map((op) => ({
       op: op.op,
       kind: op.kind,
@@ -179,10 +184,21 @@ async function planPack(pack, { prune, names }) {
     throw new PackError(`could not load the MCP server catalogue (${ref.mcpServersError}); this pack uses mcp.actionType, which needs it. Retry, or list mcp.tools explicitly`);
   }
   const desired = toDesired(pack, ref);
+  const versionState = await remote.fetchVersion(pack.name);
   const live = await remote.fetchManaged(pack.name);
   live.names = names || await remote.fetchAllNames();
   const ops = buildPlan(desired, live, { prune });
-  return { ops, live, ref };
+  return { ops, live, ref, versionState };
+}
+
+async function fetchStablePack(name) {
+  const before = await remote.fetchVersion(name);
+  const live = await remote.fetchManaged(name);
+  const after = await remote.fetchVersion(name);
+  if (before.supported !== after.supported || before.version !== after.version) {
+    throw new PackError(`pack "${name}" changed during export; retry`);
+  }
+  return { live, version: after.version };
 }
 
 /**
@@ -207,13 +223,14 @@ async function runApply(target, { dryRun = false, prune = false, yes = false, js
   const names = await remote.fetchAllNames();
   const planned = [];
   for (const { file, pack } of packs) {
-    const { ops, live } = await planPack(pack, { prune, names });
-    planned.push({ file, pack, ops, live });
+    const { ops, live, versionState } = await planPack(pack, { prune, names });
+    planned.push({ file, pack, ops, live, versionState });
   }
 
   const totals = planned.reduce((acc, p) => {
     const s = summarize(p.ops);
     for (const k of Object.keys(s)) acc[k] = (acc[k] || 0) + s[k];
+    if (p.versionState.supported && p.versionState.version !== p.pack.version && !s.drift) acc.drift += 1;
     return acc;
   }, {});
 
@@ -231,12 +248,6 @@ async function runApply(target, { dryRun = false, prune = false, yes = false, js
     return { drift: totals.drift, failed: 0 };
   }
 
-  if (!totals.drift) {
-    if (json) output.json({ mode: label, dryRun: false, packs: planned.map(planJson), results: [] });
-    else output.success('Already in sync.');
-    return { drift: 0, failed: 0 };
-  }
-
   const destructive = totals.delete + totals.replace;
   if (destructive && !yes) {
     const ok = await confirm(`This will delete ${destructive} polic${destructive > 1 ? 'ies' : 'y'} (${totals.delete} delete, ${totals.replace} replace). Continue?`);
@@ -249,6 +260,22 @@ async function runApply(target, { dryRun = false, prune = false, yes = false, js
   const results = [];
   for (const p of planned) {
     const todo = p.ops.filter((op) => ['create', 'update', 'replace', 'delete'].includes(op.op));
+    if (!todo.length && (!p.versionState.supported || p.versionState.version === p.pack.version)) continue;
+    if (p.versionState.supported) {
+      try {
+        await remote.applyPlan(p.pack.name, p.pack.version, todo, {
+          expectedVersion: p.versionState.version,
+        });
+        results.push(...(todo.length ? todo.map((op) => ({ pack: p.pack.name, policy: op.serverName, op: op.op, status: 'ok', error: null }))
+          : [{ pack: p.pack.name, policy: null, op: 'version', status: 'ok', error: null }]));
+      } catch (err) {
+        const message = err && err.message ? err.message : String(err);
+        results.push({ pack: p.pack.name, policy: null, op: 'apply', status: 'failed', error: message });
+        if (!json) output.error(`Pack ${p.pack.name}: ${message}`);
+      }
+      continue;
+    }
+    output.warn('Older backend: applying policies one at a time; this run is not atomic.');
     const packResults = await remote.writeOps(todo, {
       onResult: (r) => {
         if (json) return;
@@ -264,7 +291,8 @@ async function runApply(target, { dryRun = false, prune = false, yes = false, js
     output.json({ mode: label, dryRun: false, packs: planned.map(planJson), results });
   } else {
     console.log('');
-    if (failed) output.warn(`${results.length - failed} succeeded, ${failed} failed. Re-run to retry; every operation is idempotent by name.`);
+    if (failed) output.warn(`${results.length - failed} change(s) succeeded, ${failed} pack or policy write(s) failed. Re-run to retry.`);
+    else if (!results.length) output.success('Already in sync.');
     else output.success(`${results.length} change${results.length > 1 ? 's' : ''} applied.`);
   }
   return { drift: totals.drift, failed };
@@ -384,9 +412,8 @@ Examples:
   $ unbound pack sync policies/ --dry-run
   $ unbound pack sync policies/ --yes
 
-A pack whose file is removed from the folder keeps its policies: the server
-has no record of which packs were applied before. Use \`unbound pack delete <pack>\`
-to remove a whole pack.
+A pack whose file is removed from the folder keeps its policies. Use
+\`unbound pack delete <pack> --pack-version <new-version>\` to remove a whole pack.
 `)
     .action(async (target, opts) => {
       try {
@@ -402,7 +429,7 @@ to remove a whole pack.
     .description('Write the live policies of a pack as a pack file.')
     .option('-o, --out <path>', 'File to write (default: stdout). With --all: a folder, one file per pack')
     .option('--all', 'Export every pack found in the org')
-    .option('--pack-version <version>', 'metadata.version to write (default 1.0.0). Not --version, which prints the CLI version', '1.0.0')
+    .option('--pack-version <version>', 'Override the stored metadata.version')
     .option('--json', 'Write JSON instead of YAML')
     .addHelpText('after', `
 Examples:
@@ -426,13 +453,14 @@ Examples:
             output.info('No pack-managed policies found in this org.');
           }
           fs.mkdirSync(opts.out, { recursive: true });
-          for (const [name, live] of [...packs.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+          for (const name of [...packs.keys()].sort((a, b) => a.localeCompare(b))) {
+            const { live, version } = await fetchStablePack(name);
             for (const { row } of live.unsupported) output.warn(`${row.name}: unsupported policy type, not exported.`);
             if (!live.tool.length && !live.generic.length) {
               output.warn(`pack "${name}": only unsupported policies, no file written.`);
               continue;
             }
-            const doc = liveToPack(name, live, ref, { version: opts.packVersion });
+            const doc = liveToPack(name, live, ref, { version: opts.packVersion || version || '1.0.0' });
             writeOrPrint(serialize(doc), path.join(opts.out, `${name}${ext}`));
           }
           if (unmanaged.length) {
@@ -441,14 +469,14 @@ Examples:
           return;
         }
 
-        const live = await remote.fetchManaged(packName);
+        const { live, version } = await fetchStablePack(packName);
         for (const { row } of live.unsupported) output.warn(`${row.name}: unsupported policy type, not exported.`);
         if (!live.tool.length && !live.generic.length) {
           throw new PackError(live.unsupported.length
             ? `pack "${packName}" only has policies of types this CLI version does not manage; nothing to export`
             : `pack "${packName}" manages no policies in this org`);
         }
-        const doc = liveToPack(packName, live, ref, { version: opts.packVersion });
+        const doc = liveToPack(packName, live, ref, { version: opts.packVersion || version || '1.0.0' });
         writeOrPrint(serialize(doc), opts.out);
       } catch (err) {
         fail(err);
@@ -462,7 +490,7 @@ Examples:
     .option('--id <slug>', 'Id to use (only with a single --from). Default: a slug of the policy name')
     .option('--yes', 'Skip the confirmation prompt')
     .option('-o, --out <path>', 'Write the resulting pack file here (default: stdout; progress goes to stderr)')
-    .option('--pack-version <version>', 'metadata.version for the printed pack file (default 1.0.0)', '1.0.0')
+    .option('--pack-version <version>', 'New version for the pack and printed file (required when the pack already has a stored version)')
     .addHelpText('after', `
 Examples:
   $ unbound pack adopt k8s-baseline --from "Block kubectl secrets"
@@ -499,6 +527,11 @@ manage the pack with apply.
         const dupes = adoptions.map((r) => r.id).filter((id, i, all) => all.indexOf(id) !== i);
         if (dupes.length) throw new PackError(`two policies would get the same id: ${[...new Set(dupes)].join(', ')}`);
 
+        const versionState = await remote.fetchVersion(packName);
+        if (versionState.supported && versionState.version && !opts.packVersion) {
+          throw new PackError(`pack "${packName}" is at v${versionState.version}; pass --pack-version with a greater version for adoption`);
+        }
+        const packVersion = opts.packVersion || versionState.version || '1.0.0';
         const existing = await remote.fetchManaged(packName);
         for (const r of adoptions) {
           const taken = [...existing.tool, ...existing.generic, ...existing.unsupported.map((u) => u.row)].find((row) => row.code_slug === r.id);
@@ -510,14 +543,21 @@ manage the pack with apply.
           const ok = await confirm(`Mark ${adoptions.length} polic${adoptions.length > 1 ? 'ies' : 'y'} as managed by pack "${packName}"?`);
           if (!ok) { output.warn('Aborted.'); return; }
         }
-        for (const r of adoptions) {
-          await remote.updateRow(r.table, r.row.id, { code_pack: packName, code_slug: r.id });
-          // stderr on purpose: stdout carries only the pack file so it can be redirected.
-          output.info(`Adopted "${r.row.name}" as ${packName}/${r.id}`);
+        if (versionState.supported) {
+          await remote.applyPlan(packName, packVersion, adoptions.map((r) => ({
+            op: 'adopt', table: r.table, row: r.row,
+            body: { origin: 'CODE', code_pack: packName, code_slug: r.id },
+          })), { expectedVersion: versionState.version });
+        } else {
+          output.warn('Older backend: adopting policies one at a time; this run is not atomic.');
+          for (const r of adoptions) await remote.updateRow(r.table, r.row.id, { code_pack: packName, code_slug: r.id });
         }
+        for (const r of adoptions) output.info(`Adopted "${r.row.name}" as ${packName}/${r.id}`);
         const ref = await remote.loadReference();
-        const live = await remote.fetchManaged(packName);
-        writeOrPrint(stringifyPack(liveToPack(packName, live, ref, { version: opts.packVersion })), opts.out);
+        const { live, version } = versionState.supported
+          ? await fetchStablePack(packName)
+          : { live: await remote.fetchManaged(packName), version: packVersion };
+        writeOrPrint(stringifyPack(liveToPack(packName, live, ref, { version: version || packVersion })), opts.out);
       } catch (err) {
         fail(err);
       }
@@ -527,40 +567,52 @@ manage the pack with apply.
     .command('delete <pack>')
     .description('Delete every policy a pack manages.')
     .option('--yes', 'Skip the confirmation prompt')
+    .option('--pack-version <version>', 'New version to store for the deletion (required when the pack has a stored version)')
     .action(async (packName, opts) => {
       try {
         requireLogin();
         if (!SLUG_RE.test(packName)) throw new PackError('pack name must match [a-z0-9][a-z0-9-]{0,63}');
+        const versionState = await remote.fetchVersion(packName);
         const live = await remote.fetchManaged(packName);
         const rows = [
           ...live.tool.map((row) => ({ table: 'tool', row })),
           ...live.generic.map((row) => ({ table: 'generic', row })),
         ];
+        if (versionState.supported && live.unsupported.length) {
+          throw new PackError(`pack "${packName}" has ${live.unsupported.length} policy type(s) this CLI cannot manage; update the CLI before deleting the pack`);
+        }
         for (const { row } of live.unsupported) output.warn(`${row.name}: unsupported policy type, left untouched; delete it in the console.`);
-        if (!rows.length) {
+        if (!rows.length && (!versionState.supported || !versionState.version)) {
           output.info(`Pack "${packName}" manages no policies of a managed type in this org.`);
           return;
         }
+        if (versionState.supported && versionState.version && !opts.packVersion) {
+          throw new PackError(`pack "${packName}" is at v${versionState.version}; pass --pack-version with a greater version for deletion`);
+        }
         for (const { row } of rows) console.log(`  ${row.name}`);
-        if (!opts.yes) {
+        if (!opts.yes && rows.length) {
           const ok = await confirm(`Delete these ${rows.length} polic${rows.length > 1 ? 'ies' : 'y'}?`);
           if (!ok) { output.warn('Aborted.'); return; }
         }
-        let failed = 0;
-        for (const { table, row } of rows) {
-          try {
-            await remote.deleteRow(table, row.id);
-            output.success(`Deleted ${row.name}`);
-          } catch (err) {
-            failed += 1;
-            output.error(`${row.name}: ${err.message}`);
+        if (versionState.supported) {
+          await remote.applyPlan(packName, opts.packVersion || versionState.version || '1.0.0',
+            rows.map(({ table, row }) => ({ op: 'delete', table, row })),
+            { deletePack: true, expectedVersion: versionState.version });
+          for (const { row } of rows) output.success(`Deleted ${row.name}`);
+          if (!rows.length) output.success(`Pack "${packName}" has no policies; stored version advanced.`);
+        } else {
+          output.warn('Older backend: deleting policies one at a time; this run is not atomic.');
+          const results = await remote.writeOps(rows.map(({ table, row }) => ({ op: 'delete', table, row })));
+          for (const result of results) {
+            if (result.status === 'ok') output.success(`Deleted ${result.op.row.name}`);
+            else output.error(`${result.op.row.name}: ${result.error}`);
           }
+          if (results.some((result) => result.status === 'failed')) process.exitCode = 1;
         }
-        if (failed) process.exitCode = 1;
       } catch (err) {
         fail(err);
       }
     });
 }
 
-module.exports = { register, _internals: { loadPackFiles, changeText, runApply, confirm } };
+module.exports = { register, _internals: { loadPackFiles, changeText, runApply, fetchStablePack, confirm } };

package/src/lib/pack-remote.js

@@ -8,6 +8,7 @@ const { PackError, TOOL_TYPES, GENERIC_KINDS } = require('./pack-schema');
 const TOOL_PATH = '/api/v1/command-policies/';
 const GENERIC_PATH = '/api/v1/policies/';
 const PAGE_SIZE = 200;
+const PACK_PATH = (name) => `/api/v1/packs/${encodeURIComponent(name)}/`;
 
 // Every write declares itself as the code path. The server marks the row
 // `origin: CODE` (so the console only lets people switch it on or off) and lets
@@ -193,6 +194,35 @@ async function deleteRow(table, id) {
   return api.del(pathFor(table, id), { query: { origin: CODE_ORIGIN } });
 }
 
+async function fetchVersion(name) {
+  try {
+    const result = await api.get(PACK_PATH(name));
+    return { supported: true, version: result.version || null };
+  } catch (err) {
+    if (err && err.statusCode === 404) return { supported: false, version: null };
+    throw err;
+  }
+}
+
+async function applyPlan(name, version, ops, { deletePack = false, expectedVersion = null } = {}) {
+  const operations = ops.map((op) => {
+    const operation = { op: op.op, table: op.table };
+    if (op.row) operation.id = op.row.id;
+    if (op.body) {
+      operation.body = {
+        ...op.body,
+        origin: CODE_ORIGIN,
+        code_pack: name,
+        code_slug: op.desired ? op.desired.id : op.body.code_slug,
+      };
+    }
+    return operation;
+  });
+  return api.post(`${PACK_PATH(name)}apply/`, {
+    body: { version, expected_version: expectedVersion, operations, delete_pack: deletePack },
+  });
+}
+
 /**
  * Id of a freshly created row. The generic endpoint wraps in {policy}, the
  * command-policies endpoint returns the row unwrapped today; both envelopes
@@ -305,4 +335,6 @@ module.exports = {
   tempSlug,
   createdId,
   writeOps,
+  fetchVersion,
+  applyPlan,
 };

package/src/toolHealth.js

@@ -206,12 +206,27 @@ function envKeyCheck(label, name, kind = 'aux') {
   };
 }
 
-// Setup writes UNBOUND_DEVICE_TOKEN; installs from before it carry only the per-tool name.
+function configDeviceToken() {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.unbound', 'config.json'), 'utf8'));
+    return cfg.api_key || cfg.device_token || null;
+  } catch {
+    return null;
+  }
+}
+
+// Env wins when present so a stale exported key is still validated; setup keeps the token in ~/.unbound/config.json and removes the env var.
 function deviceTokenCheck(legacyName) {
   const check = envKeyCheck('API key env', 'UNBOUND_DEVICE_TOKEN');
   if (check.ok) return check;
   const legacy = envKeyCheck('API key env', legacyName);
-  return legacy.ok ? legacy : check;
+  if (legacy.ok) return legacy;
+  const value = configDeviceToken();
+  if (!value) return check;
+  return {
+    name: 'API key env', ok: true, kind: 'aux', detail: 'device token set (config.json)', summary: 'API key set',
+    keyCheck: true, envName: 'device token', value, candidates: [value],
+  };
 }
 
 function envCheck(label, name, expected, kind = 'aux') {

package/test/pack-cli-integration.test.js

@@ -0,0 +1,312 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+function runCli(file, port, home, args = ['apply', '-f', file, '--yes']) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.resolve(__dirname, '../src/index.js'),
+      'pack', ...args], {
+      env: {
+        ...process.env, HOME: home, UNBOUND_TOKEN: 'test-token',
+        UNBOUND_API_URL: `http://127.0.0.1:${port}`,
+        UNBOUND_NO_UPDATE_CHECK: '1', UNBOUND_TELEMETRY: '0',
+      },
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', reject);
+    child.on('close', (code) => resolve({ code, stdout, stderr }));
+  });
+}
+
+test('two CLI applies produce one success and one clear lock conflict', async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'pack-cli-'));
+  const file = path.join(home, 'pack.yaml');
+  fs.writeFileSync(file, [
+    'apiVersion: unbound.security/v1',
+    'kind: PolicyPack',
+    'metadata:',
+    '  name: sample',
+    '  version: 1.0.0',
+    'policies:',
+    '  - id: budget',
+    '    kind: cost',
+    '    config:',
+    '      monthly_budget: 500',
+    '',
+  ].join('\n'));
+
+  let versionReads = [];
+  let applying = false;
+  let liveRows = 0;
+  const server = http.createServer((req, res) => {
+    const send = (status, body) => {
+      res.writeHead(status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(body));
+    };
+    if (req.method === 'GET' && req.url.startsWith('/api/v1/policies/form_data/')) {
+      return send(200, { user_groups: [], guardrails: [], ai_models: [], tool_types: [] });
+    }
+    if (req.method === 'GET' && req.url.startsWith('/api/v1/labels/')) return send(200, { labels: [] });
+    if (req.method === 'GET' && req.url.startsWith('/api/v1/command-policies/')) return send(200, { policies: [], total_pages: 1 });
+    if (req.method === 'GET' && req.url.startsWith('/api/v1/policies/')) return send(200, { policies: [] });
+    if (req.method === 'GET' && req.url === '/api/v1/packs/sample/') {
+      versionReads.push(res);
+      if (versionReads.length === 2) {
+        for (const pending of versionReads) {
+          pending.writeHead(200, { 'Content-Type': 'application/json' });
+          pending.end(JSON.stringify({ name: 'sample', version: null }));
+        }
+        versionReads = [];
+      }
+      return;
+    }
+    if (req.method === 'POST' && req.url === '/api/v1/packs/sample/apply/') {
+      if (applying) return send(409, { error: 'another apply is running, retry' });
+      applying = true;
+      return setTimeout(() => {
+        liveRows = 1;
+        applying = false;
+        send(200, { name: 'sample', version: '1.0.0', operations_applied: 1 });
+      }, 250);
+    }
+    return send(404, { error: 'not found' });
+  });
+  try {
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const port = server.address().port;
+    const results = await Promise.all([runCli(file, port, home), runCli(file, port, home)]);
+    assert.deepEqual(results.map((result) => result.code).sort(), [0, 1]);
+    assert.equal(liveRows, 1);
+    assert.match(results.find((result) => result.code === 1).stderr, /another apply is running, retry/i);
+  } finally {
+    server.close();
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('folder apply continues after one pack fails atomically', async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'pack-folder-'));
+  for (const name of ['alpha', 'beta']) {
+    fs.writeFileSync(path.join(home, `${name}.yaml`), [
+      'apiVersion: unbound.security/v1', 'kind: PolicyPack', 'metadata:',
+      `  name: ${name}`, '  version: 1.0.0', 'policies:',
+      `  - id: ${name}-budget`, '    kind: cost', '    config:', '      monthly_budget: 500', '',
+    ].join('\n'));
+  }
+  const posts = [];
+  const server = http.createServer((req, res) => {
+    const send = (status, body) => {
+      res.writeHead(status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(body));
+    };
+    if (req.url.startsWith('/api/v1/policies/form_data/')) {
+      return send(200, { user_groups: [], guardrails: [], ai_models: [], tool_types: [] });
+    }
+    if (req.url.startsWith('/api/v1/labels/')) return send(200, { labels: [] });
+    if (req.url.startsWith('/api/v1/command-policies/')) return send(200, { policies: [], total_pages: 1 });
+    if (req.url.startsWith('/api/v1/policies/')) return send(200, { policies: [] });
+    const match = req.url.match(/^\/api\/v1\/packs\/(alpha|beta)\/(apply\/)?$/);
+    if (match && req.method === 'GET') return send(200, { name: match[1], version: null });
+    if (match && req.method === 'POST') {
+      posts.push(match[1]);
+      return match[1] === 'alpha'
+        ? send(409, { error: 'another apply is running, retry' })
+        : send(200, { name: 'beta', version: '1.0.0', operations_applied: 1 });
+    }
+    return send(404, { error: 'not found' });
+  });
+  try {
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const result = await runCli(home, server.address().port, home);
+    assert.equal(result.code, 1);
+    assert.deepEqual(posts, ['alpha', 'beta']);
+    assert.match(result.stderr, /another apply is running, retry/i);
+  } finally {
+    server.close();
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('in-sync apply avoids an empty write', async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'pack-noop-'));
+  const file = path.join(home, 'sample.yaml');
+  fs.writeFileSync(file, [
+    'apiVersion: unbound.security/v1', 'kind: PolicyPack', 'metadata:',
+    '  name: sample', '  version: 1.0.0', 'policies:',
+    '  - id: budget', '    kind: cost', '    config:', '      monthly_budget: 500', '',
+  ].join('\n'));
+  let posts = 0;
+  const row = {
+    id: 5, name: 'budget', type: 'COST', origin: 'CODE', code_pack: 'sample',
+    code_slug: 'budget', enabled: true, status: 'ACTIVE', config: { monthly_budget: 500 },
+    scope_user_groups: [], scope_tool_types: [], labels: [],
+  };
+  const server = http.createServer((req, res) => {
+    const send = (status, body) => {
+      res.writeHead(status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(body));
+    };
+    if (req.url.startsWith('/api/v1/policies/form_data/')) {
+      return send(200, { user_groups: [], guardrails: [], ai_models: [], tool_types: [] });
+    }
+    if (req.url.startsWith('/api/v1/labels/')) return send(200, { labels: [] });
+    if (req.url.startsWith('/api/v1/command-policies/')) return send(200, { policies: [], total_pages: 1 });
+    if (req.url.startsWith('/api/v1/policies/')) return send(200, { policies: [row] });
+    if (req.url === '/api/v1/packs/sample/') return send(200, { name: 'sample', version: '1.0.0' });
+    if (req.method === 'POST') posts += 1;
+    return send(404, { error: 'not found' });
+  });
+  try {
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const result = await runCli(file, server.address().port, home);
+    assert.equal(result.code, 0, result.stderr);
+    assert.equal(posts, 0);
+  } finally {
+    server.close();
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('delete requires a new version before prompting', async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'pack-delete-version-'));
+  const row = {
+    id: 5, name: 'budget', type: 'COST', origin: 'CODE', code_pack: 'sample',
+    code_slug: 'budget', enabled: true, status: 'ACTIVE', config: { monthly_budget: 500 },
+  };
+  const server = http.createServer((req, res) => {
+    const send = (status, body) => {
+      res.writeHead(status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(body));
+    };
+    if (req.url.startsWith('/api/v1/command-policies/')) return send(200, { policies: [], total_pages: 1 });
+    if (req.url.startsWith('/api/v1/policies/')) return send(200, { policies: [row] });
+    if (req.url === '/api/v1/packs/sample/') return send(200, { name: 'sample', version: '1.0.0' });
+    return send(404, { error: 'not found' });
+  });
+  try {
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const result = await runCli(null, server.address().port, home, ['delete', 'sample']);
+    assert.equal(result.code, 2);
+    assert.match(result.stderr, /pass --pack-version/);
+    assert.doesNotMatch(result.stdout, /Delete these/);
+  } finally {
+    server.close();
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('version-only apply stores the new version with an empty plan', async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'pack-version-only-'));
+  const file = path.join(home, 'sample.yaml');
+  fs.writeFileSync(file, [
+    'apiVersion: unbound.security/v1', 'kind: PolicyPack', 'metadata:',
+    '  name: sample', '  version: 2.0.0', 'policies:',
+    '  - id: budget', '    kind: cost', '    config:', '      monthly_budget: 500', '',
+  ].join('\n'));
+  const row = {
+    id: 5, name: 'budget', type: 'COST', origin: 'CODE', code_pack: 'sample',
+    code_slug: 'budget', enabled: true, status: 'ACTIVE', config: { monthly_budget: 500 },
+    scope_user_groups: [], scope_tool_types: [], labels: [],
+  };
+  let version = '1.0.0';
+  const writes = [];
+  const server = http.createServer((req, res) => {
+    const send = (status, body) => {
+      res.writeHead(status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(body));
+    };
+    if (req.url.startsWith('/api/v1/policies/form_data/')) return send(200, { user_groups: [], guardrails: [], ai_models: [], tool_types: [] });
+    if (req.url.startsWith('/api/v1/labels/')) return send(200, { labels: [] });
+    if (req.url.startsWith('/api/v1/command-policies/')) return send(200, { policies: [], total_pages: 1 });
+    if (req.url.startsWith('/api/v1/policies/')) return send(200, { policies: [row] });
+    if (req.url === '/api/v1/packs/sample/' && req.method === 'GET') return send(200, { name: 'sample', version });
+    if (req.url === '/api/v1/packs/sample/apply/' && req.method === 'POST') {
+      req.on('data', (chunk) => writes.push(chunk));
+      req.on('end', () => { version = '2.0.0'; send(200, { name: 'sample', version, operations_applied: 0 }); });
+      return;
+    }
+    return send(404, { error: 'not found' });
+  });
+  try {
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const diff = await runCli(file, server.address().port, home, ['diff', '-f', file, '--json']);
+    assert.equal(diff.code, 1, diff.stderr);
+    assert.equal(JSON.parse(diff.stdout).packs[0].summary.drift, 1);
+    const result = await runCli(file, server.address().port, home);
+    assert.equal(result.code, 0, result.stderr);
+    assert.equal(version, '2.0.0');
+    assert.deepEqual(JSON.parse(Buffer.concat(writes).toString()).operations, []);
+  } finally {
+    server.close();
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('empty pack delete sends a versioned delete plan', async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'pack-empty-delete-'));
+  let body;
+  const server = http.createServer((req, res) => {
+    const send = (status, data) => {
+      res.writeHead(status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(data));
+    };
+    if (req.url.startsWith('/api/v1/command-policies/')) return send(200, { policies: [], total_pages: 1 });
+    if (req.url.startsWith('/api/v1/policies/')) return send(200, { policies: [] });
+    if (req.url === '/api/v1/packs/sample/' && req.method === 'GET') return send(200, { name: 'sample', version: '1.0.0' });
+    if (req.url === '/api/v1/packs/sample/apply/' && req.method === 'POST') {
+      const chunks = [];
+      req.on('data', (chunk) => chunks.push(chunk));
+      req.on('end', () => { body = JSON.parse(Buffer.concat(chunks).toString()); send(200, { name: 'sample', version: '2.0.0', operations_applied: 0 }); });
+      return;
+    }
+    return send(404, { error: 'not found' });
+  });
+  try {
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const result = await runCli(null, server.address().port, home, ['delete', 'sample', '--pack-version', '2.0.0']);
+    assert.equal(result.code, 0, result.stderr);
+    assert.deepEqual(body, { version: '2.0.0', expected_version: '1.0.0', operations: [], delete_pack: true });
+  } finally {
+    server.close();
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('adopt refuses to print a pack changed during the final read', async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'pack-adopt-race-'));
+  let versionReads = 0;
+  const row = { id: 5, name: 'Budget', type: 'COST', origin: 'MANUAL', enabled: true, status: 'ACTIVE', config: { monthly_budget: 500 } };
+  const server = http.createServer((req, res) => {
+    const send = (status, data) => {
+      res.writeHead(status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(data));
+    };
+    if (req.url.startsWith('/api/v1/policies/form_data/')) return send(200, { user_groups: [], guardrails: [], ai_models: [], tool_types: [] });
+    if (req.url.startsWith('/api/v1/labels/')) return send(200, { labels: [] });
+    if (req.url.startsWith('/api/v1/command-policies/')) return send(200, { policies: [], total_pages: 1 });
+    if (req.url.startsWith('/api/v1/policies/')) return send(200, { policies: [row] });
+    if (req.url === '/api/v1/packs/sample/' && req.method === 'GET') {
+      versionReads += 1;
+      return send(200, { name: 'sample', version: versionReads === 1 ? '1.0.0' : versionReads === 2 ? '2.0.0' : '3.0.0' });
+    }
+    if (req.url === '/api/v1/packs/sample/apply/' && req.method === 'POST') return send(200, { name: 'sample', version: '2.0.0', operations_applied: 1 });
+    return send(404, { error: 'not found' });
+  });
+  try {
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const result = await runCli(null, server.address().port, home, ['adopt', 'sample', '--from', 'Budget', '--pack-version', '2.0.0', '--yes']);
+    assert.equal(result.code, 2);
+    assert.match(result.stderr, /changed during export; retry/);
+    assert.equal(result.stdout, '');
+  } finally {
+    server.close();
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});

package/test/pack-confirm.test.js

@@ -2,7 +2,8 @@ const test = require('node:test');
 const assert = require('node:assert/strict');
 const { PassThrough } = require('node:stream');
 
-const { confirm } = require('../src/commands/pack')._internals;
+const { confirm, fetchStablePack } = require('../src/commands/pack')._internals;
+const remote = require('../src/lib/pack-remote');
 
 test('confirm fails closed when stdin is not a TTY', () => {
   const stdin = new PassThrough();
@@ -25,3 +26,31 @@ test('confirm resolves true on y', async () => {
   stdin.write('y\n');
   assert.equal(await p, true);
 });
+
+test('export refuses rows read across a stored version change', async () => {
+  const fetchVersion = remote.fetchVersion;
+  const fetchManaged = remote.fetchManaged;
+  let reads = 0;
+  remote.fetchVersion = async () => ({ supported: true, version: ++reads === 1 ? '1.0.0' : '2.0.0' });
+  remote.fetchManaged = async () => ({ generic: [{ id: 1 }], tool: [], unsupported: [] });
+  try {
+    await assert.rejects(() => fetchStablePack('sample'), /changed during export; retry/);
+  } finally {
+    remote.fetchVersion = fetchVersion;
+    remote.fetchManaged = fetchManaged;
+  }
+});
+
+test('export accepts rows bracketed by the same stored version', async () => {
+  const fetchVersion = remote.fetchVersion;
+  const fetchManaged = remote.fetchManaged;
+  const live = { generic: [{ id: 1 }], tool: [], unsupported: [] };
+  remote.fetchVersion = async () => ({ supported: true, version: '2.0.0' });
+  remote.fetchManaged = async () => live;
+  try {
+    assert.deepEqual(await fetchStablePack('sample'), { live, version: '2.0.0' });
+  } finally {
+    remote.fetchVersion = fetchVersion;
+    remote.fetchManaged = fetchManaged;
+  }
+});

package/test/pack-remote.test.js

@@ -25,6 +25,48 @@ function reset() {
   stub.onDel = async () => ({});
 }
 
+test('fetchVersion preserves a stored version and only treats 404 as an old backend', async () => {
+  reset();
+  stub.onGet = async () => ({ name: 'base', version: '2.0.0' });
+  assert.deepEqual(await remote.fetchVersion('base'), { supported: true, version: '2.0.0' });
+  stub.onGet = async () => { throw Object.assign(new Error('missing'), { statusCode: 404 }); };
+  assert.deepEqual(await remote.fetchVersion('base'), { supported: false, version: null });
+  stub.onGet = async () => { throw Object.assign(new Error('unavailable'), { statusCode: 503 }); };
+  await assert.rejects(() => remote.fetchVersion('base'), /unavailable/);
+});
+
+test('applyPlan submits all operations in one request with a stored-version check', async () => {
+  reset();
+  await remote.applyPlan('base', '3.0.0', [
+    { op: 'update', table: 'tool', row: { id: 7, code_slug: 'tool' },
+      desired: { id: 'tool' }, body: { action: 'AUDIT' } },
+    { op: 'delete', table: 'generic', row: { id: 9 } },
+  ], { expectedVersion: '2.0.0' });
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0][1], '/api/v1/packs/base/apply/');
+  assert.deepEqual(calls[0][2].body, {
+    version: '3.0.0', expected_version: '2.0.0', delete_pack: false,
+    operations: [
+      { op: 'update', table: 'tool', id: 7, body: {
+        action: 'AUDIT', origin: 'CODE', code_pack: 'base', code_slug: 'tool',
+      } },
+      { op: 'delete', table: 'generic', id: 9 },
+    ],
+  });
+});
+
+test('applyPlan retains the chosen slug when adopting a console policy', async () => {
+  reset();
+  await remote.applyPlan('base', '1.0.0', [{
+    op: 'adopt', table: 'generic', row: { id: 7 },
+    body: { origin: 'CODE', code_pack: 'base', code_slug: 'chosen-id' },
+  }]);
+  assert.deepEqual(calls[0][2].body.operations[0], {
+    op: 'adopt', table: 'generic', id: 7,
+    body: { origin: 'CODE', code_pack: 'base', code_slug: 'chosen-id' },
+  });
+});
+
 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' });

package/test/tool-health.test.js

@@ -1111,6 +1111,31 @@ 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: device token in config.json and no env → healthy', () => {
+  const t = 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'), '#');
+    writeFile(path.join(tmp, '.unbound', 'config.json'), JSON.stringify({ device_token: 'k' }));
+    return th.detectTools({ apiKey: 'k' }).find((x) => x.family === 'claude-code');
+  });
+  assert.equal(t.status, 'healthy');
+});
+
+test('claude-code: an exported key is the one validated even when config.json holds another', () => {
+  process.env.UNBOUND_DEVICE_TOKEN = 'from-env';
+  try {
+    const t = 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'), '#');
+      writeFile(path.join(tmp, '.unbound', 'config.json'), JSON.stringify({ device_token: 'from-config' }));
+      return th.detectTools({ apiKey: 'k' }).find((x) => x.family === 'claude-code');
+    });
+    assert.equal(t.checks.find((c) => c.keyCheck).value, 'from-env');
+  } finally {
+    delete process.env.UNBOUND_DEVICE_TOKEN;
+  }
+});
+
 test('claude-code: neither env set → tampered, naming UNBOUND_DEVICE_TOKEN', () => {
   const t = claudeWithEnv({});
   assert.equal(t.status, 'tampered');