unbound-cli 1.16.10 → 1.16.12

package/README.md

@@ -254,7 +254,7 @@ Alias: `unbound groups` works the same as `unbound user-groups`.
 | `unbound tools connect <type>` | Connect a tool |
 | `unbound tools approved` | List approved tool types |
 
-Supported tool types: `CLAUDE_CODE`, `UNBOUND_CLAUDE_CODE`, `CURSOR`, `COPILOT`, `AUGMENT_CODE`, `ROO_CODE`, `CLINE`, `GEMINI_CLI`, `CODEX`, `UNBOUND_CODEX`, `KILO_CODE`, `CUSTOM_ACCESS`
+Supported tool types: `CLAUDE_CODE`, `CURSOR`, `COPILOT`, `AUGMENT_CODE`, `ROO_CODE`, `CLINE`, `GEMINI_CLI`, `CODEX`, `KILO_CODE`, `CUSTOM_ACCESS`
 
 ## Configuration
 

package/package.json

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

package/src/commands/discover.js

@@ -1,4 +1,5 @@
-const { spawn, execSync } = require('child_process');
+const childProcess = require('child_process');
+const { spawn } = childProcess;
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -7,7 +8,9 @@ const output = require('../output');
 const telemetry = require('../telemetry');
 const { Option } = require('commander');
 const { shellEscape, downloadToFile, withSecureTempFile, DISCOVER_BASE_URL } = require('../utils');
-const LAUNCH_AGENT_LABEL = 'ai.getunbound.discovery';
+// The scheduled-scan installer (setup-scheduled-scan.sh) registers this LaunchAgent
+// and writes its logs; keep both in sync with that script.
+const LAUNCH_AGENT_LABEL = 'ai.getunbound.scheduled';
 
 // install.sh exits with this code when the OS isn't supported for discovery
 // (e.g. Linux). Treated as a skipped scan, not a failure.
@@ -351,14 +354,14 @@ Examples:
 
       const home = os.homedir();
       const plistPath = path.join(home, 'Library/LaunchAgents', `${LAUNCH_AGENT_LABEL}.plist`);
-      const logPath = path.join(home, 'Library/Logs/unbound/scan.log');
-      const errPath = path.join(home, 'Library/Logs/unbound/scan.err');
+      const logPath = path.join(home, 'Library/Logs/unbound/scheduled.log');
+      const errPath = path.join(home, 'Library/Logs/unbound/scheduled.err');
 
       const plistExists = fs.existsSync(plistPath);
 
       let isLoaded = false;
       try {
-        execSync(`launchctl list "${LAUNCH_AGENT_LABEL}"`, { stdio: 'ignore' });
+        childProcess.execSync(`launchctl list "${LAUNCH_AGENT_LABEL}"`, { stdio: 'ignore' });
         isLoaded = true;
       } catch {
         // not loaded

package/src/commands/tools.js

@@ -12,7 +12,6 @@ const SUPPORTED_TOOL_TYPES = [
   'CLINE',
   'GEMINI_CLI',
   'CODEX',
-  'UNBOUND_CODEX',
   'KILO_CODE',
   'CUSTOM_ACCESS',
 ];
@@ -181,4 +180,4 @@ Examples:
     });
 }
 
-module.exports = { register };
+module.exports = { register, SUPPORTED_TOOL_TYPES };

package/test/discover-exit-code.test.js

@@ -1,7 +1,53 @@
 const { test } = require('node:test');
 const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const { Command } = require('commander');
 const { classifyDiscoveryExit, register } = require('../src/commands/discover');
+const output = require('../src/output');
+
+// `discover status` must point at what the scheduled-scan installer actually
+// creates: the LaunchAgent labelled `ai.getunbound.scheduled` and the
+// scheduled.log / scheduled.err files under ~/Library/Logs/unbound. Otherwise a
+// scheduled scan reports "No schedule". Runs the real status action with the
+// platform stubbed to darwin and output.keyValue captured.
+test('discover status: uses the scheduled-scan LaunchAgent label and log paths', async () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'unbound-discover-status-'));
+  const origHome = process.env.HOME;
+  const origPlatform = process.platform;
+  const origKeyValue = output.keyValue;
+  const origHomedir = os.homedir;
+
+  os.homedir = () => tmp;
+  process.env.HOME = tmp;
+  Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+
+  // Make the plist exist so the "LaunchAgent" row shows its resolved path.
+  const plistPath = path.join(tmp, 'Library/LaunchAgents', 'ai.getunbound.scheduled.plist');
+  fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+  fs.writeFileSync(plistPath, '<plist/>');
+
+  const captured = {};
+  output.keyValue = (pairs) => { for (const [k, v] of pairs) captured[k] = v; };
+
+  try {
+    const program = new Command();
+    register(program);
+    await program.parseAsync(['node', 'x', 'discover', 'status']);
+
+    assert.equal(captured['LaunchAgent'], plistPath);
+    assert.equal(captured['Log file'], path.join(tmp, 'Library/Logs/unbound/scheduled.log'));
+    assert.equal(captured['Error log'], path.join(tmp, 'Library/Logs/unbound/scheduled.err'));
+  } finally {
+    output.keyValue = origKeyValue;
+    os.homedir = origHomedir;
+    Object.defineProperty(process, 'platform', { value: origPlatform, configurable: true });
+    if (origHome === undefined) delete process.env.HOME;
+    else process.env.HOME = origHome;
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+});
 
 // Existing crons can still pass a discovery key. With strict option parsing the
 // CLI would reject an unregistered flag, so discover keeps --discovery-key as an

package/test/discover-status-hardening.test.js

@@ -0,0 +1,165 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { Command } = require('commander');
+const { register } = require('../src/commands/discover');
+const output = require('../src/output');
+
+// Hardening for `discover status`: the command must agree with what the
+// scheduled-scan installer (coding-discovery-tool/setup-scheduled-scan.sh)
+// actually creates — the `ai.getunbound.scheduled` LaunchAgent and the
+// scheduled.log / scheduled.err files — and must degrade cleanly off macOS.
+
+function withDarwinHome(fn) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'unbound-discover-status-'));
+  const origHome = process.env.HOME;
+  const origPlatform = process.platform;
+  const origHomedir = os.homedir;
+  const origKeyValue = output.keyValue;
+  os.homedir = () => tmp;
+  process.env.HOME = tmp;
+  Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+  const captured = {};
+  output.keyValue = (pairs) => { for (const [k, v] of pairs) captured[k] = v; };
+  return (async () => {
+    try {
+      const program = new Command();
+      register(program);
+      await program.parseAsync(['node', 'x', 'discover', 'status']);
+      await fn(tmp, captured);
+    } finally {
+      output.keyValue = origKeyValue;
+      os.homedir = origHomedir;
+      Object.defineProperty(process, 'platform', { value: origPlatform, configurable: true });
+      if (origHome === undefined) delete process.env.HOME;
+      else process.env.HOME = origHome;
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  })();
+}
+
+// Cross-repo contract. The installer's wrapper writes a run marker to
+// scheduled.log in exactly this shape:
+//   log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> scheduled.log; }
+//   log "=== Starting Unbound scheduled run ==="
+// `discover status` parses the last such line into "Last scan". If either side
+// drifts, Last scan silently reverts to "-". This seeds a real installer-format
+// line and asserts the timestamp is recovered.
+test('discover status: parses Last scan from the installer\'s real scheduled.log line', async () => {
+  await withDarwinHome(async (tmp, captured) => {
+    // (setup happens before parseAsync, so write the log then re-run in-band)
+    const logDir = path.join(tmp, 'Library/Logs/unbound');
+    fs.mkdirSync(logDir, { recursive: true });
+    fs.writeFileSync(path.join(logDir, 'scheduled.log'),
+      '[2026-09-20 09:00:01] === Starting Unbound scheduled run ===\n' +
+      'discovered 3 tools\n' +
+      '[2026-09-21 09:00:02] === Starting Unbound scheduled run ===\n' +
+      '[2026-09-21 09:00:04] === Finished ===\n');
+    // Re-run status now that the log exists.
+    const program = new Command();
+    register(program);
+    await program.parseAsync(['node', 'x', 'discover', 'status']);
+    assert.equal(captured['Last scan'], '2026-09-21 09:00:02', 'must report the latest run marker');
+    assert.equal(captured['Log file'], path.join(logDir, 'scheduled.log'));
+  });
+});
+
+// A machine that still has ONLY the stale `ai.getunbound.discovery` plist (never
+// re-ran the migrating installer) must read as unscheduled — the reader is bound
+// to the new label, not the old one.
+test('discover status: a stale ai.getunbound.discovery plist alone reads as Not installed', async () => {
+  await withDarwinHome(async (tmp, captured) => {
+    const laDir = path.join(tmp, 'Library/LaunchAgents');
+    fs.mkdirSync(laDir, { recursive: true });
+    fs.writeFileSync(path.join(laDir, 'ai.getunbound.discovery.plist'), '<plist/>');
+    const program = new Command();
+    register(program);
+    await program.parseAsync(['node', 'x', 'discover', 'status']);
+    assert.equal(captured['Scheduled'], 'No');
+    assert.equal(captured['LaunchAgent'], 'Not installed');
+  });
+});
+
+// Runs `discover status` on darwin with `launchctl` stubbed. `discover.js` calls
+// `childProcess.execSync`, so replacing that method on the shared module object
+// takes effect without re-requiring. `loaded` decides whether `launchctl list
+// <label>` succeeds; `plistLabel` (if set) seeds that LaunchAgent plist. Returns
+// the captured key/values and the exact launchctl command the reader ran.
+async function runStatusWithLaunchctl({ plistLabel, loaded }) {
+  const cp = require('child_process');
+  const orig = {
+    execSync: cp.execSync, home: process.env.HOME, platform: process.platform,
+    homedir: os.homedir, keyValue: output.keyValue,
+  };
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'unbound-discover-status-'));
+  if (plistLabel) {
+    const laDir = path.join(tmp, 'Library/LaunchAgents');
+    fs.mkdirSync(laDir, { recursive: true });
+    fs.writeFileSync(path.join(laDir, `${plistLabel}.plist`), '<plist/>');
+  }
+  let launchctlCmd = '';
+  cp.execSync = (cmd) => { launchctlCmd = cmd; if (loaded) return ''; throw new Error('not loaded'); };
+  os.homedir = () => tmp;
+  process.env.HOME = tmp;
+  Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+  const captured = {};
+  output.keyValue = (pairs) => { for (const [k, v] of pairs) captured[k] = v; };
+  try {
+    const program = new Command();
+    register(program);
+    await program.parseAsync(['node', 'x', 'discover', 'status']);
+    return { captured, launchctlCmd };
+  } finally {
+    cp.execSync = orig.execSync;
+    os.homedir = orig.homedir;
+    Object.defineProperty(process, 'platform', { value: orig.platform, configurable: true });
+    if (orig.home === undefined) delete process.env.HOME; else process.env.HOME = orig.home;
+    output.keyValue = orig.keyValue;
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// The bug was "reports no schedule on a scheduled machine". A machine the
+// installer scheduled must read Scheduled: Yes — which needs both the plist
+// (new label) present AND `launchctl list <label>` to succeed. This asserts the
+// reader queries launchctl under the SAME `ai.getunbound.scheduled` label it
+// reads the plist under, so the two sides can't drift apart into a false "No".
+test('discover status: installed + loaded scheduled agent reads Scheduled: Yes', async () => {
+  const { captured, launchctlCmd } = await runStatusWithLaunchctl({ plistLabel: 'ai.getunbound.scheduled', loaded: true });
+  assert.match(launchctlCmd, /launchctl list "ai\.getunbound\.scheduled"/, 'queries the new label, not the legacy one');
+  assert.equal(captured['Scheduled'], 'Yes (daily at 09:00)');
+});
+
+// The reverse guard: the plist is present but the agent is not loaded, so the
+// scan is not actually scheduled — it must read No, not a false Yes off the plist alone.
+test('discover status: installed but not loaded reads Scheduled: No', async () => {
+  const { captured } = await runStatusWithLaunchctl({ plistLabel: 'ai.getunbound.scheduled', loaded: false });
+  assert.equal(captured['Scheduled'], 'No');
+  assert.match(captured['LaunchAgent'], /ai\.getunbound\.scheduled\.plist$/);
+});
+
+// Off macOS the command must not touch launchd/plist state; it prints guidance
+// pointing at the real Linux timer and Windows scheduled-task names and exits 1.
+test('discover status: non-darwin prints OS guidance and does not read plist state', async () => {
+  const origPlatform = process.platform;
+  const origError = output.error;
+  const origExit = process.exitCode;
+  Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+  let msg = '';
+  output.error = (m) => { msg += m; };
+  try {
+    const program = new Command();
+    register(program);
+    await program.parseAsync(['node', 'x', 'discover', 'status']);
+    assert.match(msg, /only supports macOS/);
+    assert.match(msg, /unbound-scheduled\.timer/, 'points at the real systemd timer');
+    assert.match(msg, /ai\.getunbound\.scheduled/, 'points at the real Windows task name');
+    assert.equal(process.exitCode, 1);
+  } finally {
+    output.error = origError;
+    Object.defineProperty(process, 'platform', { value: origPlatform, configurable: true });
+    process.exitCode = origExit;
+  }
+});

package/test/tools-backend-contract.test.js

@@ -0,0 +1,55 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const { SUPPORTED_TOOL_TYPES } = require('../src/commands/tools');
+
+// Cross-repo contract: every tool type the CLI offers must be one the backend's
+// agents API accepts, or `tools connect` sends a request the backend answers
+// with 400. Rather than mirror the backend list by hand (which silently drifts),
+// this reads the REAL allowlist from ai-gateway-data at
+// webapp/api/v1/agent_handlers.py::SUPPORTED_AGENT_TOOL_TYPES.
+//
+// The backend repo isn't a dependency of the CLI, so when it isn't checked out
+// beside this one the test skips rather than failing — it runs wherever the
+// fleet is present (a dev machine, the cross-repo CI stage) and is a no-op
+// elsewhere. Point it explicitly with AI_GATEWAY_DATA_DIR.
+
+const HANDLERS_REL = 'webapp/api/v1/agent_handlers.py';
+
+function findBackendFile() {
+  const candidates = [];
+  if (process.env.AI_GATEWAY_DATA_DIR) {
+    candidates.push(path.join(process.env.AI_GATEWAY_DATA_DIR, HANDLERS_REL));
+  }
+  // Common layouts: a sibling checkout next to unbound-cli.
+  const repoRoot = path.join(__dirname, '..');
+  candidates.push(path.join(repoRoot, '..', 'ai-gateway-data', HANDLERS_REL));
+  candidates.push(path.join(repoRoot, '..', '..', 'ai-gateway-data', HANDLERS_REL));
+  return candidates.find((p) => { try { return fs.existsSync(p); } catch { return false; } });
+}
+
+function parseBackendAllowlist(file) {
+  const src = fs.readFileSync(file, 'utf8');
+  const m = src.match(/SUPPORTED_AGENT_TOOL_TYPES\s*=\s*\[([\s\S]*?)\]/);
+  assert.ok(m, 'could not locate SUPPORTED_AGENT_TOOL_TYPES in agent_handlers.py');
+  const types = [...m[1].matchAll(/['"]([A-Z_]+)['"]/g)].map((x) => x[1]);
+  assert.ok(types.length > 0, 'parsed an empty backend allowlist');
+  return new Set(types);
+}
+
+const backendFile = findBackendFile();
+
+test('every CLI-offered tool type is in the REAL backend agent_handlers allowlist',
+  { skip: backendFile ? false : 'ai-gateway-data not checked out (set AI_GATEWAY_DATA_DIR)' },
+  () => {
+    const accepted = parseBackendAllowlist(backendFile);
+    for (const type of SUPPORTED_TOOL_TYPES) {
+      assert.ok(accepted.has(type),
+        `CLI offers ${type} but the backend allowlist does not accept it (would 400)`);
+    }
+    // Guard the specific regression: the removed type must be absent from the CLI
+    // list precisely because the backend rejects it.
+    assert.ok(!SUPPORTED_TOOL_TYPES.includes('UNBOUND_CODEX') || accepted.has('UNBOUND_CODEX'),
+      'UNBOUND_CODEX may only be offered if the backend accepts it');
+  });

package/test/tools-supported-types.test.js

@@ -0,0 +1,85 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { Command } = require('commander');
+
+const config = require('../src/config');
+const api = require('../src/api');
+const output = require('../src/output');
+const { register, SUPPORTED_TOOL_TYPES } = require('../src/commands/tools');
+
+// Mirror of ai-gateway-data webapp/api/v1/agent_handlers.py SUPPORTED_AGENT_TOOL_TYPES.
+// `tools connect` must only offer types this backend accepts; anything else gets a 400.
+const BACKEND_ACCEPTED = new Set([
+  'CLAUDE_CODE', 'UNBOUND_CLAUDE_CODE', 'CURSOR', 'COPILOT',
+  'ROO_CODE', 'CLINE', 'GEMINI_CLI', 'CODEX', 'KILO_CODE', 'OPENCLAW',
+  'CUSTOM_ACCESS', 'AUGMENT_CODE',
+]);
+
+// Drive the real `tools connect` action with login + api stubbed. Returns
+// { reachedApi, sentType, errored } so a test can tell a type accepted by the
+// CLI (reaches the connect call) from one the CLI rejects before any request.
+async function connect(toolType) {
+  const orig = {
+    isLoggedIn: config.isLoggedIn,
+    post: api.post,
+    error: output.error,
+    success: output.success,
+    keyValue: output.keyValue,
+    json: output.json,
+    exitCode: process.exitCode,
+  };
+  let reachedApi = false;
+  let sentType = null;
+  let errored = false;
+  let errorMsg = '';
+  config.isLoggedIn = () => true;
+  api.post = async (_path, { body }) => { reachedApi = true; sentType = body.tool_type; return { tool_type: body.tool_type, status: 'connected' }; };
+  output.error = (m) => { errored = true; errorMsg = String(m ?? ''); };
+  output.success = () => {};
+  output.keyValue = () => {};
+  output.json = () => {};
+  try {
+    const program = new Command();
+    register(program);
+    await program.parseAsync(['node', 'x', 'tools', 'connect', toolType]);
+    return { reachedApi, sentType, errored, errorMsg, exitCode: process.exitCode };
+  } finally {
+    config.isLoggedIn = orig.isLoggedIn;
+    api.post = orig.post;
+    output.error = orig.error;
+    output.success = orig.success;
+    output.keyValue = orig.keyValue;
+    output.json = orig.json;
+    process.exitCode = orig.exitCode;
+  }
+}
+
+// The backend rejects UNBOUND_CODEX with a 400, so the CLI must not offer it.
+test('tools connect UNBOUND_CODEX is rejected before any backend call', async () => {
+  const r = await connect('UNBOUND_CODEX');
+  assert.equal(r.reachedApi, false, 'must not send an UNBOUND_CODEX connect request');
+  assert.equal(r.errored, true, 'must report an unsupported-type error');
+  assert.equal(r.exitCode, 1, 'must exit non-zero so scripts see the rejection');
+  // The error points the user at the real types: it names the supported set,
+  // including the correct CODEX to reach for instead.
+  assert.match(r.errorMsg, /Supported types:/);
+  assert.match(r.errorMsg, /\bCODEX\b/);
+});
+
+// A representative valid type still connects.
+test('tools connect CODEX reaches the backend with tool_type CODEX', async () => {
+  const r = await connect('CODEX');
+  assert.equal(r.reachedApi, true);
+  assert.equal(r.sentType, 'CODEX');
+});
+
+// Drive the actual production allowlist: every type the CLI offers must reach the
+// backend and be one the backend accepts. Adding a backend-rejected type to
+// SUPPORTED_TOOL_TYPES would fail here rather than recur as a runtime 400.
+test('every CLI-offered tool type is accepted by the backend', async () => {
+  for (const type of SUPPORTED_TOOL_TYPES) {
+    const r = await connect(type);
+    assert.equal(r.reachedApi, true, `CLI should offer ${type}`);
+    assert.ok(BACKEND_ACCEPTED.has(r.sentType), `CLI offers ${r.sentType} which the backend rejects`);
+  }
+});