unbound-cli 1.16.10 → 1.16.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unbound-cli",
-  "version": "1.16.10",
+  "version": "1.16.11",
   "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/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;
+  }
+});