@lifeaitools/clauth 1.30.23 → 1.30.24

package/cli/supervisor-ui.test.js

@@ -3,92 +3,14 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { listSurfaces, listPlugins, runSurfaceAction, runPluginAction } from './supervisor-registry.js';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const serveSource = fs.readFileSync(path.join(here, 'commands', 'serve.js'), 'utf8');
 
-// Regression coverage for the 2026-08-06 incident: every surface across every
-// plugin shares the bare id "primary", and the dashboard's onclick handlers
-// sent that bare id instead of the plugin-qualified "plugin_id:id" that
-// findSurface() already supported. The server-side .find() always resolved
-// to the FIRST surface in the array (codeflow-mcp), which unconditionally
-// rejects every action as self-owned -- so all 49 buttons (7 surfaces x 7
-// actions) silently hit the same surface and appeared to do nothing, on
-// every surface, for every action. The prior test in this file only
-// regex-matched that the action-name strings existed in source; it would
-// pass under this exact bug. These tests exercise the real resolution path
-// through the same exported functions the HTTP routes call (POST
-// /v1/surfaces/:id/actions -> runSurfaceAction; POST /v1/plugins/:id/:action
-// -> runPluginAction), which is the same simulate-a-button-click contract as
-// the dashboard onclick handlers use, without needing a browser.
-
-test('the dashboard encodes a plugin-qualified surface id, not the bare (colliding) surface.id', () => {
-  assert.match(
-    serveSource,
-    /jsArg\(surface\.plugin_id \+ ":" \+ surface\.id\)/,
-    'renderSupervisorSurface must send plugin_id:id, not the bare surface.id shared by every surface'
-  );
-});
-
-test('every real surface exists and every surface id collides with at least one other (documents why plugin_id is required)', () => {
-  const surfaces = listSurfaces();
-  assert.ok(surfaces.length > 1, 'expected more than one discovered surface to make this regression possible');
-  const bareIds = new Set(surfaces.map((s) => s.id));
-  assert.equal(bareIds.size, 1, 'expected every discovered surface to share the same bare id ("primary") -- if this ever stops being true, the plugin_id qualifier is still correct but this documentation test should be updated');
-});
-
-test('runSurfaceAction resolves the plugin-qualified id to that exact surface, not a different one', () => {
-  const surfaces = listSurfaces();
-  assert.ok(surfaces.length >= 1, 'no surfaces discovered -- cannot verify resolution');
-  for (const surface of surfaces) {
-    const compositeId = surface.plugin_id + ':' + surface.id;
-    // action "test" is the designed no-op/safe action -- it never touches a
-    // real process, it only records a receipt, which is exactly what a
-    // verification harness should use.
-    const receipt = runSurfaceAction(compositeId, 'test', 'supervisor-ui.test.js');
-    assert.ok(!receipt.error, 'surface ' + compositeId + ' resolution failed: ' + receipt.error);
-    assert.equal(
-      receipt.prior_state?.plugin_id,
-      surface.plugin_id,
-      'requested surface ' + compositeId + ' but runSurfaceAction resolved a different surface owned by "' + receipt.prior_state?.plugin_id + '" -- this is the exact 2026-08-06 regression'
-    );
-    assert.equal(receipt.target.surface_id, compositeId);
-  }
-});
-
-test('bare (unqualified) surface id is ambiguous: it always resolves to the same single surface regardless of which surface was intended', () => {
-  const surfaces = listSurfaces();
-  assert.ok(surfaces.length > 1, 'need multiple surfaces to demonstrate ambiguity');
-  const bareId = surfaces[0].id;
-  const receiptsByBareId = surfaces.map(() => runSurfaceAction(bareId, 'test', 'supervisor-ui.test.js'));
-  const resolvedOwners = new Set(receiptsByBareId.map((r) => r.prior_state?.plugin_id));
-  assert.equal(
-    resolvedOwners.size,
-    1,
-    'expected the bare id to be ambiguous (always resolve to one surface) -- if this now resolves multiple owners, the collision this test guards against has already been fixed at the id level and this test can be removed'
-  );
-});
-
-test('every one of the 7 button actions is exercised end-to-end through runSurfaceAction for every discovered surface', () => {
-  const actions = ['start', 'stop', 'restart', 'reconcile', 'test', 'promote', 'rollback'];
-  const surfaces = listSurfaces();
-  for (const surface of surfaces) {
-    const compositeId = surface.plugin_id + ':' + surface.id;
-    for (const action of actions) {
-      const receipt = runSurfaceAction(compositeId, action, 'supervisor-ui.test.js');
-      assert.notEqual(receipt.error, 'surface_not_found', compositeId + ' / ' + action + ' could not resolve the surface');
-      assert.notEqual(receipt.error, 'invalid_action', compositeId + ' / ' + action + ' is not a recognized action');
-      assert.equal(receipt.prior_state?.plugin_id, surface.plugin_id, compositeId + ' / ' + action + ' resolved the wrong surface');
-    }
+test('clauth supervisor UI exposes every lifecycle action and receipt feedback', () => {
+  for (const action of ['start', 'stop', 'restart', 'reconcile', 'test', 'promote', 'rollback']) {
+    assert.match(serveSource, new RegExp('"' + action + '"'));
   }
+  assert.match(serveSource, /supervisorFeedback\(/);
+  assert.match(serveSource, /supervisor-feedback/);
 });
-
-test('every plugin-level action is reachable through runPluginAction for every discovered plugin', () => {
-  const plugins = listPlugins();
-  assert.ok(plugins.length > 0, 'no plugins discovered');
-  for (const plugin of plugins) {
-    const receipt = runPluginAction(plugin.id, 'test', 'supervisor-ui.test.js');
-    assert.notEqual(receipt.error, 'plugin_not_found', plugin.id + ' could not be resolved by its own id');
-  }
-});

package/cli/watchdog-registry.js

@@ -1,209 +1,209 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { spawnSync } from "child_process";
-
-const DEFAULT_TIMEOUT_MS = 3000;
-const VALID_KINDS = new Set(["http", "process", "pm2", "docker", "hook"]);
-
-export function getWatchdogDir() {
-  if (process.env.CLAUTH_WATCHDOG_DIR) return process.env.CLAUTH_WATCHDOG_DIR;
-  const appdata = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
-  return path.join(appdata, "clauth");
-}
-
-export function getRegistryPath() {
-  return path.join(getWatchdogDir(), "watchdog-services.json");
-}
-
-export function getEventsPath() {
-  return path.join(getWatchdogDir(), "watchdog-events.jsonl");
-}
-
-function readJsonFile(filePath, fallback) {
-  try {
-    if (!fs.existsSync(filePath)) return fallback;
-    return JSON.parse(fs.readFileSync(filePath, "utf8"));
-  } catch {
-    return fallback;
-  }
-}
-
-function writeJsonFile(filePath, value) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-
-function appendEvent(event) {
-  fs.mkdirSync(getWatchdogDir(), { recursive: true });
-  fs.appendFileSync(getEventsPath(), `${JSON.stringify({ ts: new Date().toISOString(), ...event })}\n`, "utf8");
-}
-
-function normalizeCommand(command) {
-  if (!command) return null;
-  if (Array.isArray(command)) {
-    const [cmd, ...args] = command;
-    return { cmd, args: args.map(String) };
-  }
-  if (typeof command === "object" && typeof command.cmd === "string") {
-    return { cmd: command.cmd, args: Array.isArray(command.args) ? command.args.map(String) : [] };
-  }
-  return null;
-}
-
-function validateCommand(command, field) {
-  const normalized = normalizeCommand(command);
-  if (!normalized) return null;
-  const cmd = normalized.cmd.trim();
-  if (!cmd) throw new Error(`${field}.cmd is required`);
-  if (/[;&|<>]/.test(cmd)) throw new Error(`${field}.cmd must be an executable path/name, not shell syntax`);
-  for (const arg of normalized.args) {
-    if (/[<>]/.test(arg)) throw new Error(`${field}.args contains unsupported shell redirection`);
-  }
-  return normalized;
-}
-
-export function validateWatchdogService(service) {
-  if (!service || typeof service !== "object") throw new Error("service must be an object");
-  if (!service.id || typeof service.id !== "string") throw new Error("service.id is required");
-  if (!/^[a-zA-Z0-9_.-]+$/.test(service.id)) throw new Error("service.id may contain only letters, numbers, dot, underscore, and dash");
-  if (!service.label || typeof service.label !== "string") throw new Error("service.label is required");
-  if (!VALID_KINDS.has(service.kind)) throw new Error(`service.kind must be one of ${[...VALID_KINDS].join(", ")}`);
-
-  const restart = validateCommand(service.restart, "service.restart");
-  const start = validateCommand(service.start, "service.start");
-  const health = service.health && typeof service.health === "object" ? service.health : null;
-  if (health?.url && typeof health.url !== "string") throw new Error("service.health.url must be a string");
-  if (health?.url && !/^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(?::\d+)?\//.test(health.url)) {
-    throw new Error("service.health.url must be localhost-only");
-  }
-
-  return {
-    id: service.id,
-    label: service.label,
-    owner: service.owner || "local",
-    kind: service.kind,
-    health,
-    start,
-    restart,
-    logs: Array.isArray(service.logs) ? service.logs.map(String) : [],
-    tags: Array.isArray(service.tags) ? service.tags.map(String) : [],
-    approvalRequired: service.approvalRequired !== false,
-    restartPolicy: service.restartPolicy || "manual",
-  };
-}
-
-export function validateWatchdogManifest(manifest) {
-  if (!manifest || typeof manifest !== "object") throw new Error("manifest must be an object");
-  const services = Array.isArray(manifest.services) ? manifest.services : null;
-  if (!services || services.length === 0) throw new Error("manifest.services must be a non-empty array");
-  return {
-    schema: manifest.schema || "clauth.watchdog.v1",
-    source: manifest.source || "manual",
-    services: services.map(validateWatchdogService),
-  };
-}
-
-export function loadRegistry() {
-  const registry = readJsonFile(getRegistryPath(), { services: [] });
-  return {
-    services: Array.isArray(registry.services) ? registry.services.map(validateWatchdogService) : [],
-  };
-}
-
-export function saveRegistry(registry) {
-  writeJsonFile(getRegistryPath(), { services: registry.services.map(validateWatchdogService) });
-}
-
-export function registerWatchdogManifest(manifest) {
-  const validated = validateWatchdogManifest(manifest);
-  const registry = loadRegistry();
-  const byId = new Map(registry.services.map((service) => [service.id, service]));
-  for (const service of validated.services) byId.set(service.id, service);
-  const next = { services: [...byId.values()].sort((a, b) => a.id.localeCompare(b.id)) };
-  saveRegistry(next);
-  appendEvent({ kind: "register", source: validated.source, service_count: validated.services.length });
-  return { registered: validated.services.length, services: validated.services.map((service) => service.id) };
-}
-
-export async function evaluateWatchdogService(service) {
-  const checkedAt = new Date().toISOString();
-  if (service.health?.url) {
-    const timeoutMs = Number(service.health.timeoutMs || DEFAULT_TIMEOUT_MS);
-    try {
-      const response = await fetch(service.health.url, { signal: AbortSignal.timeout(timeoutMs), cache: "no-store" });
-      return {
-        ...service,
-        status: response.ok ? "healthy" : "degraded",
-        checkedAt,
-        httpStatus: response.status,
-      };
-    } catch (error) {
-      return {
-        ...service,
-        status: "unreachable",
-        checkedAt,
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  }
-  return { ...service, status: "unknown", checkedAt };
-}
-
-export async function getWatchdogStatuses() {
-  const registry = loadRegistry();
-  const services = await Promise.all(registry.services.map(evaluateWatchdogService));
-  return {
-    checkedAt: new Date().toISOString(),
-    total: services.length,
-    healthy: services.filter((service) => service.status === "healthy").length,
-    degraded: services.filter((service) => service.status === "degraded").length,
-    unreachable: services.filter((service) => service.status === "unreachable").length,
-    services,
-  };
-}
-
-export function readWatchdogEvents(limit = 100) {
-  try {
-    if (!fs.existsSync(getEventsPath())) return [];
-    return fs.readFileSync(getEventsPath(), "utf8")
-      .split(/\r?\n/)
-      .filter(Boolean)
-      .slice(-limit)
-      .map((line) => {
-        try { return JSON.parse(line); } catch { return { raw: line }; }
-      });
-  } catch {
-    return [];
-  }
-}
-
-export function restartWatchdogService(id) {
-  const service = loadRegistry().services.find((candidate) => candidate.id === id);
-  if (!service) return { ok: false, error: "service_not_registered" };
-  if (!service.restart) return { ok: false, error: "restart_not_configured" };
-  if (service.approvalRequired && process.env.CLAUTH_WATCHDOG_APPROVED !== "1") {
-    return { ok: false, error: "approval_required" };
-  }
-
-  const result = spawnSync(service.restart.cmd, service.restart.args, {
-    cwd: service.restart.cwd || process.cwd(),
-    windowsHide: true,
-    encoding: "utf8",
-    timeout: Number(service.restart.timeoutMs || 30000),
-  });
-  const event = {
-    kind: "restart",
-    service_id: id,
-    status: result.status,
-    error: result.error ? result.error.message : undefined,
-  };
-  appendEvent(event);
-  return {
-    ok: result.status === 0,
-    status: result.status,
-    stdout: result.stdout,
-    stderr: result.stderr,
-    error: result.error ? result.error.message : undefined,
-  };
-}
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { spawnSync } from "child_process";
+
+const DEFAULT_TIMEOUT_MS = 3000;
+const VALID_KINDS = new Set(["http", "process", "pm2", "docker", "hook"]);
+
+export function getWatchdogDir() {
+  if (process.env.CLAUTH_WATCHDOG_DIR) return process.env.CLAUTH_WATCHDOG_DIR;
+  const appdata = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+  return path.join(appdata, "clauth");
+}
+
+export function getRegistryPath() {
+  return path.join(getWatchdogDir(), "watchdog-services.json");
+}
+
+export function getEventsPath() {
+  return path.join(getWatchdogDir(), "watchdog-events.jsonl");
+}
+
+function readJsonFile(filePath, fallback) {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJsonFile(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function appendEvent(event) {
+  fs.mkdirSync(getWatchdogDir(), { recursive: true });
+  fs.appendFileSync(getEventsPath(), `${JSON.stringify({ ts: new Date().toISOString(), ...event })}\n`, "utf8");
+}
+
+function normalizeCommand(command) {
+  if (!command) return null;
+  if (Array.isArray(command)) {
+    const [cmd, ...args] = command;
+    return { cmd, args: args.map(String) };
+  }
+  if (typeof command === "object" && typeof command.cmd === "string") {
+    return { cmd: command.cmd, args: Array.isArray(command.args) ? command.args.map(String) : [] };
+  }
+  return null;
+}
+
+function validateCommand(command, field) {
+  const normalized = normalizeCommand(command);
+  if (!normalized) return null;
+  const cmd = normalized.cmd.trim();
+  if (!cmd) throw new Error(`${field}.cmd is required`);
+  if (/[;&|<>]/.test(cmd)) throw new Error(`${field}.cmd must be an executable path/name, not shell syntax`);
+  for (const arg of normalized.args) {
+    if (/[<>]/.test(arg)) throw new Error(`${field}.args contains unsupported shell redirection`);
+  }
+  return normalized;
+}
+
+export function validateWatchdogService(service) {
+  if (!service || typeof service !== "object") throw new Error("service must be an object");
+  if (!service.id || typeof service.id !== "string") throw new Error("service.id is required");
+  if (!/^[a-zA-Z0-9_.-]+$/.test(service.id)) throw new Error("service.id may contain only letters, numbers, dot, underscore, and dash");
+  if (!service.label || typeof service.label !== "string") throw new Error("service.label is required");
+  if (!VALID_KINDS.has(service.kind)) throw new Error(`service.kind must be one of ${[...VALID_KINDS].join(", ")}`);
+
+  const restart = validateCommand(service.restart, "service.restart");
+  const start = validateCommand(service.start, "service.start");
+  const health = service.health && typeof service.health === "object" ? service.health : null;
+  if (health?.url && typeof health.url !== "string") throw new Error("service.health.url must be a string");
+  if (health?.url && !/^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(?::\d+)?\//.test(health.url)) {
+    throw new Error("service.health.url must be localhost-only");
+  }
+
+  return {
+    id: service.id,
+    label: service.label,
+    owner: service.owner || "local",
+    kind: service.kind,
+    health,
+    start,
+    restart,
+    logs: Array.isArray(service.logs) ? service.logs.map(String) : [],
+    tags: Array.isArray(service.tags) ? service.tags.map(String) : [],
+    approvalRequired: service.approvalRequired !== false,
+    restartPolicy: service.restartPolicy || "manual",
+  };
+}
+
+export function validateWatchdogManifest(manifest) {
+  if (!manifest || typeof manifest !== "object") throw new Error("manifest must be an object");
+  const services = Array.isArray(manifest.services) ? manifest.services : null;
+  if (!services || services.length === 0) throw new Error("manifest.services must be a non-empty array");
+  return {
+    schema: manifest.schema || "clauth.watchdog.v1",
+    source: manifest.source || "manual",
+    services: services.map(validateWatchdogService),
+  };
+}
+
+export function loadRegistry() {
+  const registry = readJsonFile(getRegistryPath(), { services: [] });
+  return {
+    services: Array.isArray(registry.services) ? registry.services.map(validateWatchdogService) : [],
+  };
+}
+
+export function saveRegistry(registry) {
+  writeJsonFile(getRegistryPath(), { services: registry.services.map(validateWatchdogService) });
+}
+
+export function registerWatchdogManifest(manifest) {
+  const validated = validateWatchdogManifest(manifest);
+  const registry = loadRegistry();
+  const byId = new Map(registry.services.map((service) => [service.id, service]));
+  for (const service of validated.services) byId.set(service.id, service);
+  const next = { services: [...byId.values()].sort((a, b) => a.id.localeCompare(b.id)) };
+  saveRegistry(next);
+  appendEvent({ kind: "register", source: validated.source, service_count: validated.services.length });
+  return { registered: validated.services.length, services: validated.services.map((service) => service.id) };
+}
+
+export async function evaluateWatchdogService(service) {
+  const checkedAt = new Date().toISOString();
+  if (service.health?.url) {
+    const timeoutMs = Number(service.health.timeoutMs || DEFAULT_TIMEOUT_MS);
+    try {
+      const response = await fetch(service.health.url, { signal: AbortSignal.timeout(timeoutMs), cache: "no-store" });
+      return {
+        ...service,
+        status: response.ok ? "healthy" : "degraded",
+        checkedAt,
+        httpStatus: response.status,
+      };
+    } catch (error) {
+      return {
+        ...service,
+        status: "unreachable",
+        checkedAt,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+  return { ...service, status: "unknown", checkedAt };
+}
+
+export async function getWatchdogStatuses() {
+  const registry = loadRegistry();
+  const services = await Promise.all(registry.services.map(evaluateWatchdogService));
+  return {
+    checkedAt: new Date().toISOString(),
+    total: services.length,
+    healthy: services.filter((service) => service.status === "healthy").length,
+    degraded: services.filter((service) => service.status === "degraded").length,
+    unreachable: services.filter((service) => service.status === "unreachable").length,
+    services,
+  };
+}
+
+export function readWatchdogEvents(limit = 100) {
+  try {
+    if (!fs.existsSync(getEventsPath())) return [];
+    return fs.readFileSync(getEventsPath(), "utf8")
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .slice(-limit)
+      .map((line) => {
+        try { return JSON.parse(line); } catch { return { raw: line }; }
+      });
+  } catch {
+    return [];
+  }
+}
+
+export function restartWatchdogService(id) {
+  const service = loadRegistry().services.find((candidate) => candidate.id === id);
+  if (!service) return { ok: false, error: "service_not_registered" };
+  if (!service.restart) return { ok: false, error: "restart_not_configured" };
+  if (service.approvalRequired && process.env.CLAUTH_WATCHDOG_APPROVED !== "1") {
+    return { ok: false, error: "approval_required" };
+  }
+
+  const result = spawnSync(service.restart.cmd, service.restart.args, {
+    cwd: service.restart.cwd || process.cwd(),
+    windowsHide: true,
+    encoding: "utf8",
+    timeout: Number(service.restart.timeoutMs || 30000),
+  });
+  const event = {
+    kind: "restart",
+    service_id: id,
+    status: result.status,
+    error: result.error ? result.error.message : undefined,
+  };
+  appendEvent(event);
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    error: result.error ? result.error.message : undefined,
+  };
+}