@lifeaitools/clauth 1.30.15 → 1.30.17

package/cli/supervisor-registry.js

@@ -82,6 +82,23 @@ function appendSupervisorEvent(event) {
   appendJsonl(file("events.jsonl"), { ts: now(), ...event });
 }
 
+async function probeSurfaceHealth(url, fetchImpl, timeoutMs) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetchImpl(url, { signal: controller.signal });
+      return response?.ok
+        ? { healthy: true, error: null }
+        : { healthy: false, error: `HTTP ${response?.status ?? "unknown"}` };
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch (err) {
+    return { healthy: false, error: err?.name === "AbortError" ? "health timeout" : String(err?.message || err) };
+  }
+}
+
 /**
  * Probe enabled local clauth-owned surfaces and repair an unavailable one via
  * the same governed action path exposed to Dev Center. External/plugin-owned
@@ -95,21 +112,9 @@ export async function reconcileSurfaceHealth({ fetchImpl = globalThis.fetch, tim
     const url = healthUrlForSurface(surface);
     if (!url) continue;
     const observedAt = now();
-    let healthy = false;
-    let error = null;
-    try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), timeoutMs);
-      try {
-        const response = await fetchImpl(url, { signal: controller.signal });
-        healthy = Boolean(response?.ok);
-        if (!healthy) error = `HTTP ${response?.status ?? "unknown"}`;
-      } finally {
-        clearTimeout(timer);
-      }
-    } catch (err) {
-      error = err?.name === "AbortError" ? "health timeout" : String(err?.message || err);
-    }
+    const health = await probeSurfaceHealth(url, fetchImpl, timeoutMs);
+    const healthy = health.healthy;
+    const error = health.error;
 
     if (healthy) {
       updateSurfaceState(id, { state: "current", last_health_at: observedAt, last_health_ok: true, last_health_error: null });
@@ -133,9 +138,18 @@ export async function reconcileSurfaceHealth({ fetchImpl = globalThis.fetch, tim
     });
     appendSupervisorEvent({ kind: "surface_health_failed", surface_id: id, error, health: url });
     const receipt = runSurfaceAction(id, "reconcile", "supervisor-health-loop");
-    const repaired = receipt?.resulting_state?.ok === true;
-    updateSurfaceState(id, { state: repaired ? "current" : "unavailable", last_reconcile_operation_id: receipt?.operationId || null });
-    inspected.push({ surface_id: id, state: repaired ? "reconciled" : "reconcile_failed", error, operation_id: receipt?.operationId || null, observed_at: observedAt });
+    const commandCompleted = receipt?.resulting_state?.ok === true;
+    const postHealth = commandCompleted ? await probeSurfaceHealth(url, fetchImpl, timeoutMs) : { healthy: false, error: receipt?.resulting_state?.state || "reconcile_failed" };
+    const repaired = commandCompleted && postHealth.healthy;
+    updateSurfaceState(id, {
+      state: repaired ? "current" : "unavailable",
+      last_health_at: now(),
+      last_health_ok: repaired,
+      last_health_error: repaired ? null : postHealth.error,
+      last_reconcile_operation_id: receipt?.operationId || null,
+    });
+    appendSupervisorEvent({ kind: repaired ? "surface_reconciled" : "surface_reconcile_failed", surface_id: id, operation_id: receipt?.operationId || null, command_completed: commandCompleted, health_ok: postHealth.healthy, error: postHealth.error || null });
+    inspected.push({ surface_id: id, state: repaired ? "reconciled" : "reconcile_failed", error: postHealth.error || error, operation_id: receipt?.operationId || null, observed_at: observedAt });
   }
   return { inspected };
 }
@@ -480,20 +494,33 @@ export function runSurfaceAction(id, action, actor = "localhost") {
   if (!command || command.length === 0) {
     return operation(action, { surface_id: id }, surface, { ok: false, state: "command_missing" }, actor);
   }
-  const [cmd, ...args] = command;
-  const result = spawnSync(cmd, args, {
-    cwd: surface.cwd || undefined,
-    env: { ...process.env, CLAUTH_PM2_HOME: getClauthPm2Home(), PM2_HOME: getClauthPm2Home() },
-    windowsHide: true,
-    encoding: "utf8",
-    timeout: Number(surface.timeoutMs || 30000),
-  });
+  const execute = (selectedCommand) => {
+    const [cmd, ...args] = selectedCommand;
+    return spawnSync(cmd, args, {
+      cwd: surface.cwd || undefined,
+      env: { ...process.env, CLAUTH_PM2_HOME: getClauthPm2Home(), PM2_HOME: getClauthPm2Home() },
+      windowsHide: true,
+      encoding: "utf8",
+      timeout: Number(surface.timeoutMs || 30000),
+    });
+  };
+  let result = execute(command);
+  let fallbackUsed = false;
+  // PM2 restart returns non-zero when the process was deleted. Reconcile is
+  // allowed to fall back to the declared start command; explicit restart keeps
+  // its strict failure semantics for operator-requested actions.
+  if (action === "reconcile" && result.status !== 0 && Array.isArray(surface.start) && surface.start.length > 0 && command !== surface.start) {
+    const restartStatus = result.status;
+    result = execute(surface.start);
+    fallbackUsed = true;
+    result.stderr = `restart exited ${restartStatus}; start fallback attempted\n${result.stderr || ""}`;
+  }
   return operation(action, { surface_id: id }, surface, {
     ok: result.status === 0,
     state: result.status === 0 ? "operation_completed" : "operation_failed",
     status: result.status,
     stderr: result.stderr?.slice(0, 2000),
-    evidence: [`CLAUTH_PM2_HOME=${getClauthPm2Home()}`],
+    evidence: [`CLAUTH_PM2_HOME=${getClauthPm2Home()}`, ...(fallbackUsed ? ["reconcile_start_fallback=true"] : [])],
   }, actor);
 }
 

package/cli/supervisor-registry.test.js

@@ -174,6 +174,29 @@ test("surface actions use dedicated clauth PM2 home and keep CodeFlow observe-on
   assert.equal(supervisorHealth().surfaces, 2);
 }));
 
+test("reconcile falls back to the declared start command when restart reports a missing process", () => withTempSupervisor((root) => {
+  const managed = path.join(root, "managed");
+  process.env.CLAUTH_MANAGED_PLUGIN_ROOTS = managed;
+  process.env.CLAUTH_USER_PLUGIN_ROOTS = path.join(root, "user");
+  writePlugin(root, "managed", "fallback-demo", baseManifest("fallback-demo", {
+    core: true,
+    enable_default: true,
+    surfaces: [{
+      id: "primary",
+      destination: "local/clauth/pm2",
+      lifecycle_owner: "clauth",
+      port: 39114,
+      health: "/health",
+      start: [process.execPath, "--version"],
+      restart: [process.execPath, "-e", "process.exit(1)"],
+    }],
+  }));
+  discoverPlugins();
+  const receipt = runSurfaceAction("fallback-demo:primary", "reconcile");
+  assert.equal(receipt.resulting_state.ok, true);
+  assert.equal(receipt.resulting_state.evidence.includes("reconcile_start_fallback=true"), true);
+}));
+
 test("surface promote and rollback never fall through to restart commands", () => withTempSupervisor((root) => {
   const managed = path.join(root, "managed");
   process.env.CLAUTH_MANAGED_PLUGIN_ROOTS = managed;
@@ -218,14 +241,46 @@ test("health reconciliation marks a failed clauth surface and repairs it through
       }],
     }));
     discoverPlugins();
+    let healthCalls = 0;
     const result = await reconcileSurfaceHealth({
-      fetchImpl: async () => ({ ok: false, status: 503 }),
+      fetchImpl: async () => ({ ok: ++healthCalls > 1, status: 503 }),
     });
     assert.equal(result.inspected[0].surface_id, "health-demo:primary");
     assert.equal(result.inspected[0].state, "reconciled");
     const surface = listSurfaces().find((item) => item.plugin_id === "health-demo");
     assert.equal(surface.state, "current");
     assert.ok(surface.last_reconcile_operation_id);
+    assert.equal(healthCalls, 2);
+  } finally {
+    if (oldDir === undefined) delete process.env.CLAUTH_SUPERVISOR_DIR;
+    else process.env.CLAUTH_SUPERVISOR_DIR = oldDir;
+    if (oldManaged === undefined) delete process.env.CLAUTH_MANAGED_PLUGIN_ROOTS;
+    else process.env.CLAUTH_MANAGED_PLUGIN_ROOTS = oldManaged;
+    if (oldUser === undefined) delete process.env.CLAUTH_USER_PLUGIN_ROOTS;
+    else process.env.CLAUTH_USER_PLUGIN_ROOTS = oldUser;
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("health reconciliation does not claim current when a successful command leaves health down", async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "clauth-supervisor-post-health-"));
+  const oldDir = process.env.CLAUTH_SUPERVISOR_DIR;
+  const oldManaged = process.env.CLAUTH_MANAGED_PLUGIN_ROOTS;
+  const oldUser = process.env.CLAUTH_USER_PLUGIN_ROOTS;
+  process.env.CLAUTH_SUPERVISOR_DIR = root;
+  process.env.CLAUTH_MANAGED_PLUGIN_ROOTS = path.join(root, "managed");
+  process.env.CLAUTH_USER_PLUGIN_ROOTS = path.join(root, "user");
+  try {
+    writePlugin(root, "managed", "post-health-demo", baseManifest("post-health-demo", {
+      core: true,
+      enable_default: true,
+      surfaces: [{ id: "primary", destination: "local/clauth/pm2", lifecycle_owner: "clauth", port: 39113, health: "/health", restart: [process.execPath, "--version"] }],
+    }));
+    discoverPlugins();
+    const result = await reconcileSurfaceHealth({ fetchImpl: async () => ({ ok: false, status: 503 }) });
+    assert.equal(result.inspected[0].state, "reconcile_failed");
+    assert.equal(listSurfaces()[0].state, "unavailable");
+    assert.equal(listSurfaces()[0].last_health_ok, false);
   } finally {
     if (oldDir === undefined) delete process.env.CLAUTH_SUPERVISOR_DIR;
     else process.env.CLAUTH_SUPERVISOR_DIR = oldDir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/clauth",
-  "version": "1.30.15",
+  "version": "1.30.17",
   "description": "Hardware-bound credential vault for the LIFEAI infrastructure stack",
   "type": "module",
   "bin": {