@lifeaitools/clauth 1.31.1 → 2.0.0

package/cli/supervisor-registry.js

@@ -7,7 +7,12 @@ import { spawnSync } from "node:child_process";
 const SCHEMA = "lifeai.plugin.v1";
 const DEFAULT_TIMEOUT_MS = 3000;
 const DEFAULT_SUPERVISOR_PORT = 52439;
-const DESTINATIONS = new Set(["local/clauth/pm2", "vultr/clauth/pm2", "coolify/clauth/docker"]);
+// local/clauth/daemon: for a surface that is not a separately-startable
+// process at all, but literally embedded in the clauth daemon itself (e.g.
+// fs-mcp) — distinct from local/clauth/pm2 (a separate local process clauth
+// manages via pm2) because there is nothing for a surface action to
+// start/stop/restart; the daemon's own lifecycle IS the surface's lifecycle.
+const DESTINATIONS = new Set(["local/clauth/pm2", "local/clauth/daemon", "vultr/clauth/pm2", "coolify/clauth/docker"]);
 const OWNERS = new Set(["clauth", "plugin", "external"]);
 const ACTIONS = new Set(["start", "stop", "restart", "reconcile", "test", "promote", "rollback"]);
 const DEFAULT_HEALTH_RECONCILE_INTERVAL_MS = 10000;
@@ -162,7 +167,26 @@ function normalizeCommand(command, field) {
   const [cmd, ...args] = command;
   if (typeof cmd !== "string" || !cmd.trim()) throw new Error(`${field}[0] is required`);
   if (/[;&|<>]/.test(cmd)) throw new Error(`${field}[0] must be an executable path/name, not shell syntax`);
-  return [cmd, ...args.map(String)];
+  const normalizedArgs = args.map(String);
+  // shell:true (Windows-only, see execute() in runSurfaceAction) hands each
+  // arg to cmd.exe verbatim — a shell metacharacter in an arg is exactly as
+  // exploitable as one in cmd[0]. A legitimate CLI arg for the pm2/node
+  // invocations this schema targets never needs raw shell syntax.
+  for (const [i, arg] of normalizedArgs.entries()) {
+    if (/[;&|<>]/.test(arg)) throw new Error(`${field}[${i + 1}] must not contain shell syntax`);
+  }
+  return [cmd, ...normalizedArgs];
+}
+
+// Quotes a value for cmd.exe /c when shell:true is active and the value
+// contains whitespace — spawnSync does NOT auto-quote in that mode, so an
+// absolute path like "C:\Program Files\nodejs\node.exe" (or any arg with a
+// space) breaks at the first space unless the caller quotes it. Idempotent:
+// an already-quoted value is left as-is rather than double-quoted.
+export function shellQuote(value, useShell) {
+  if (!useShell || !/\s/.test(value)) return value;
+  if (value.startsWith('"') && value.endsWith('"')) return value;
+  return `"${value}"`;
 }
 
 function expandPathToken(value) {
@@ -224,7 +248,7 @@ function localhostHealth(pathOrUrl, port) {
 function normalizeSurface(surface, plugin) {
   if (!surface || typeof surface !== "object") throw new Error("surface must be an object");
   const id = String(surface.id || "").trim();
-  if (!/^[a-zA-Z0-9_.-]+$/.test(id)) throw new Error("surface.id may contain only letters, numbers, dot, underscore, and dash");
+  if (!/^[a-zA-Z0-9_.-]+$/.test(id) || /^\.+$/.test(id)) throw new Error("surface.id may contain only letters, numbers, dot, underscore, and dash, and may not be all dots");
   const destination = normalizeDestination(surface.destination || plugin.destination);
   const lifecycle_owner = normalizeLifecycleOwner(surface.lifecycle_owner || plugin.lifecycle_owner);
   const port = surface.port === undefined || surface.port === null || surface.port === "auto" ? surface.port ?? null : Number(surface.port);
@@ -249,7 +273,7 @@ export function validatePluginManifest(manifest, sourcePath = "") {
   if (!manifest || typeof manifest !== "object") throw new Error("manifest must be an object");
   if (manifest.schema !== SCHEMA) throw new Error(`schema must be ${SCHEMA}`);
   const id = String(manifest.id || "").trim();
-  if (!/^[a-zA-Z0-9_.-]+$/.test(id)) throw new Error("id may contain only letters, numbers, dot, underscore, and dash");
+  if (!/^[a-zA-Z0-9_.-]+$/.test(id) || /^\.+$/.test(id)) throw new Error("id may contain only letters, numbers, dot, underscore, and dash, and may not be all dots");
   const version = String(manifest.version || "").trim();
   if (!version) throw new Error("version is required");
   const plugin = {
@@ -301,6 +325,17 @@ function findManifestFiles(root) {
   for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
     const full = path.join(root, entry.name);
     if (entry.isDirectory()) {
+      // A scoped npm package (@lifeaitools/fs-mcp) installs two levels deep
+      // under node_modules/@scope/pkg-name/ — descend one extra level only
+      // for @scope directories. Unscoped layout (one level) is unchanged.
+      if (entry.name.startsWith("@")) {
+        for (const scopedEntry of fs.readdirSync(full, { withFileTypes: true })) {
+          if (!scopedEntry.isDirectory()) continue;
+          const scopedCandidate = path.join(full, scopedEntry.name, "clauth-plugin.json");
+          if (fs.existsSync(scopedCandidate)) out.push(scopedCandidate);
+        }
+        continue;
+      }
       const candidate = path.join(full, "clauth-plugin.json");
       if (fs.existsSync(candidate)) out.push(candidate);
     } else if (entry.isFile() && entry.name === "clauth-plugin.json") {
@@ -389,6 +424,65 @@ export function discoverPlugins() {
   return { plugins, surfaces, events };
 }
 
+// Registers one plugin manifest into the managed-plugins root, then runs
+// discovery so it's picked up immediately. This is the entry point a product
+// repo's own install/deploy step calls to self-register — the mechanism the
+// PLUGIN-ARCHITECTURE-DECISION.md "each MCP ships its own clauth-plugin.json"
+// model needs for a monorepo workspace member (no npm install lifecycle hook
+// to piggyback on, unlike a standalone published package with postinstall.js).
+// Idempotent: re-registering unchanged content is a safe no-op re-affirm.
+export function registerPlugin(manifestPath, actor = "localhost") {
+  let raw;
+  try {
+    raw = fs.readFileSync(manifestPath, "utf8");
+  } catch (error) {
+    return operation("plugin.register", { manifest_path: manifestPath }, null, {
+      ok: false, state: "manifest_unreadable", error: error instanceof Error ? error.message : String(error),
+    }, actor);
+  }
+  let manifest;
+  try {
+    manifest = validatePluginManifest(JSON.parse(raw), manifestPath);
+  } catch (error) {
+    return operation("plugin.register", { manifest_path: manifestPath }, null, {
+      ok: false, state: "manifest_invalid", error: error instanceof Error ? error.message : String(error),
+    }, actor);
+  }
+  const [{ root: managedRoot }] = rootEntries();
+  const resolvedRoot = path.resolve(managedRoot);
+  const targetDir = path.resolve(managedRoot, manifest.id);
+  // Belt-and-braces: the id regex already rejects traversal-shaped ids, but
+  // this asserts containment at the actual write site so a future regex
+  // relaxation can't silently reopen a path escape out of the managed root —
+  // this is a credential vault writing files from parsed manifest content.
+  if (targetDir !== resolvedRoot && !targetDir.startsWith(resolvedRoot + path.sep)) {
+    return operation("plugin.register", { manifest_path: manifestPath, plugin_id: manifest.id }, null, {
+      ok: false, state: "manifest_invalid", error: "plugin id escapes the managed plugin root",
+    }, actor);
+  }
+  const targetPath = path.join(targetDir, "clauth-plugin.json");
+  const priorRaw = fs.existsSync(targetPath) ? fs.readFileSync(targetPath, "utf8") : null;
+  const unchanged = priorRaw !== null && sha256(priorRaw) === sha256(raw);
+  if (!unchanged) {
+    try {
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(targetPath, raw, "utf8");
+    } catch (error) {
+      return operation("plugin.register", { manifest_path: manifestPath, plugin_id: manifest.id }, null, {
+        ok: false, state: "write_failed", error: error instanceof Error ? error.message : String(error),
+      }, actor);
+    }
+  }
+  const discovery = discoverPlugins();
+  const registered = discovery.plugins.find((plugin) => plugin.id === manifest.id);
+  return operation("plugin.register", { manifest_path: manifestPath, plugin_id: manifest.id }, null, {
+    ok: Boolean(registered) && registered.state !== "manifest_invalid",
+    state: unchanged ? "unchanged" : "registered",
+    plugin_state: registered?.state || "not_found",
+    surfaces: registered?.surfaces?.map((surface) => surface.id) || [],
+  }, actor);
+}
+
 export function listPlugins() {
   return loadSupervisorState().plugins || [];
 }
@@ -417,7 +511,7 @@ export function readSupervisorEvents(limit = 100) {
   });
 }
 
-function operation(action, target, prior, result, actor = "localhost") {
+export function operation(action, target, prior, result, actor = "localhost") {
   const receipt = {
     operationId: crypto.randomUUID(),
     actor,
@@ -517,10 +611,22 @@ export function runSurfaceAction(id, action, actor = "localhost") {
   }
   const execute = (selectedCommand) => {
     const [cmd, ...args] = selectedCommand;
-    return spawnSync(cmd, args, {
+    const useShell = process.platform === "win32";
+    // With shell:true on Windows, spawnSync hands cmd/args to cmd.exe /c
+    // verbatim and does NOT auto-quote — an absolute path or arg containing
+    // a space (e.g. "C:\Program Files\nodejs\node.exe") breaks at the first
+    // space unless quoted. Bare shim names (pm2, npm) never contain spaces,
+    // so this only ever affects absolute-path values, and only on Windows.
+    const resolvedCmd = shellQuote(cmd, useShell);
+    const resolvedArgs = args.map((arg) => shellQuote(arg, useShell));
+    return spawnSync(resolvedCmd, resolvedArgs, {
       cwd: surface.cwd || undefined,
       env: { ...process.env, CLAUTH_PM2_HOME: getClauthPm2Home(), PM2_HOME: getClauthPm2Home() },
       windowsHide: true,
+      // Windows resolves CLI shims (pm2, npm, etc.) to .cmd files that
+      // spawnSync cannot exec directly without a shell — ENOENT otherwise.
+      // POSIX targets (Vultr/Coolify) need no shell and keep prior behavior.
+      shell: useShell,
       encoding: "utf8",
       timeout: Number(surface.timeoutMs || 30000),
     });

package/cli/supervisor-registry.test.js

@@ -11,10 +11,12 @@ import {
   listPlugins,
   listSurfaces,
   reconcileSurfaceHealth,
+  registerPlugin,
   runPluginAction,
   runSurfaceAction,
   removeTunnelRoute,
   setPluginEnabled,
+  shellQuote,
   supervisorHealth,
   validatePluginManifest,
 } from "./supervisor-registry.js";
@@ -50,6 +52,15 @@ function writePlugin(root, source, id, manifest) {
   return dir;
 }
 
+// A scoped npm package installs at <root>/@scope/pkg-name/clauth-plugin.json —
+// two levels deep, mirroring node_modules/@lifeaitools/<pkg>/.
+function writeScopedPlugin(root, source, scope, id, manifest) {
+  const dir = path.join(root, source, scope, id);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, "clauth-plugin.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+  return dir;
+}
+
 function baseManifest(id, overrides = {}) {
   return {
     schema: "lifeai.plugin.v1",
@@ -94,6 +105,32 @@ test("validatePluginManifest accepts empty test command arrays from the v1 templ
   assert.equal(plugin.test.port, "auto");
 });
 
+test("shellQuote quotes a whitespace-bearing value only when shell is active, and is idempotent", () => {
+  assert.equal(shellQuote("pm2", true), "pm2");
+  assert.equal(shellQuote("C:/Program Files/nodejs/node.exe", true), '"C:/Program Files/nodejs/node.exe"');
+  assert.equal(shellQuote("C:/Program Files/nodejs/node.exe", false), "C:/Program Files/nodejs/node.exe");
+  assert.equal(shellQuote("one two", false), "one two");
+  assert.equal(shellQuote('"already quoted value"', true), '"already quoted value"');
+});
+
+test("validatePluginManifest rejects shell metacharacters in command ARGS, not just command[0]", () => {
+  // The [;&|<>] guard on command[0] alone is defeated by moving the payload
+  // one index right — args must be validated the same way (verified live
+  // during code review: spawnSync(['cmd','/c','echo','A & echo INJECTED'],
+  // {shell:true}) executed a second command from inside one arg string).
+  assert.throws(() => validatePluginManifest(baseManifest("inject", {
+    surfaces: [{ id: "primary", lifecycle_owner: "clauth", restart: ["pm2", "start svc & calc.exe"] }],
+  })), /shell syntax/);
+  assert.throws(() => validatePluginManifest(baseManifest("inject2", {
+    surfaces: [{ id: "primary", lifecycle_owner: "clauth", restart: ["pm2", "restart", "name; rm -rf /"] }],
+  })), /shell syntax/);
+  // A legitimate arg with no shell metacharacters still passes.
+  const ok = validatePluginManifest(baseManifest("legit", {
+    surfaces: [{ id: "primary", lifecycle_owner: "clauth", restart: ["pm2", "restart", "my-app-name"] }],
+  }), "clauth-plugin.json");
+  assert.deepEqual(ok.surfaces[0].restart, ["pm2", "restart", "my-app-name"]);
+});
+
 test("validatePluginManifest rejects invalid manifests and non-local health URLs", () => {
   assert.throws(() => validatePluginManifest({ ...baseManifest("bad"), schema: "bad" }), /schema/);
   assert.throws(() => validatePluginManifest(baseManifest("bad", {
@@ -126,6 +163,50 @@ test("discovery merges managed and user roots without silent managed-id shadowin
   assert.match(invalid.error, /shadow/);
 }));
 
+test("discovery finds both a scoped npm-package layout and an unscoped layout from one root", () => 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");
+  // Unscoped: managed/plain-plugin/clauth-plugin.json (one level — existing behavior)
+  writePlugin(root, "managed", "plain-plugin", baseManifest("plain-plugin"));
+  // Scoped: managed/@lifeaitools/fs-mcp/clauth-plugin.json (two levels — the WP-1 fix)
+  writeScopedPlugin(root, "managed", "@lifeaitools", "fs-mcp", baseManifest("fs-mcp"));
+
+  const result = discoverPlugins();
+  const plain = result.plugins.find((plugin) => plugin.id === "plain-plugin");
+  const scoped = result.plugins.find((plugin) => plugin.id === "fs-mcp");
+  assert.ok(plain, "unscoped layout must still be discovered");
+  assert.equal(plain.state, "awaiting_enable");
+  assert.ok(scoped, "scoped @scope/pkg layout must now be discovered");
+  assert.equal(scoped.state, "awaiting_enable");
+  assert.equal(scoped.manifest_hash?.length > 0, true);
+}));
+
+test("discovery skips a malformed manifest without aborting the rest of the scan", () => 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", "good-plugin", baseManifest("good-plugin"));
+  const brokenDir = path.join(managed, "broken-plugin");
+  fs.mkdirSync(brokenDir, { recursive: true });
+  fs.writeFileSync(path.join(brokenDir, "clauth-plugin.json"), "{ this is not valid json", "utf8");
+  // Also prove a malformed SCOPED manifest doesn't abort the scoped-dir descent either.
+  const brokenScopedDir = path.join(managed, "@lifeaitools", "broken-scoped");
+  fs.mkdirSync(brokenScopedDir, { recursive: true });
+  fs.writeFileSync(path.join(brokenScopedDir, "clauth-plugin.json"), "{ also not valid json", "utf8");
+  writeScopedPlugin(root, "managed", "@lifeaitools", "good-scoped", baseManifest("good-scoped"));
+
+  const result = discoverPlugins();
+  const good = result.plugins.find((plugin) => plugin.id === "good-plugin");
+  const broken = result.plugins.find((plugin) => plugin.id === "broken-plugin");
+  const goodScoped = result.plugins.find((plugin) => plugin.id === "good-scoped");
+  const brokenScoped = result.plugins.find((plugin) => plugin.id === "broken-scoped");
+  assert.equal(good.state, "awaiting_enable");
+  assert.equal(broken.state, "manifest_invalid");
+  assert.equal(goodScoped.state, "awaiting_enable");
+  assert.equal(brokenScoped.state, "manifest_invalid");
+}));
+
 test("trusted managed core plugins auto-enable while user plugins remain opt-in", () => withTempSupervisor((root) => {
   const managed = path.join(root, "managed");
   const user = path.join(root, "user");
@@ -378,6 +459,76 @@ test("supervisor log DTO strips raw operation payloads", () => {
   assert.equal(json.includes("--token"), false);
 });
 
+test("registerPlugin validates, writes into the managed root, and discovers the plugin — idempotent on re-register", () => 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");
+  const sourceDir = fs.mkdtempSync(path.join(os.tmpdir(), "clauth-register-source-"));
+  const manifestPath = path.join(sourceDir, "clauth-plugin.json");
+  fs.writeFileSync(manifestPath, JSON.stringify(baseManifest("registered-demo", { core: true, enable_default: true })), "utf8");
+
+  const first = registerPlugin(manifestPath, "test");
+  assert.equal(first.resulting_state.ok, true);
+  assert.equal(first.resulting_state.state, "registered");
+  assert.equal(first.resulting_state.plugin_state, "current");
+  const written = fs.existsSync(path.join(managed, "registered-demo", "clauth-plugin.json"));
+  assert.equal(written, true);
+  const found = listPlugins().find((plugin) => plugin.id === "registered-demo");
+  assert.equal(found.enabled, true);
+
+  const second = registerPlugin(manifestPath, "test");
+  assert.equal(second.resulting_state.state, "unchanged", "re-registering identical content must be a no-op, not a rewrite");
+
+  fs.rmSync(sourceDir, { recursive: true, force: true });
+}));
+
+test("registerPlugin rejects a plugin id that would escape the managed-plugins root", () => withTempSupervisor((root) => {
+  // Code-review finding (confidence 95, live PoC): manifest.id of ".." passed
+  // the old id regex (dot is in the allowed character class with no
+  // exclusion of all-dots forms) and path.join(managedRoot, "..") wrote
+  // clauth-plugin.json one level ABOVE the managed root. Two independent
+  // fixes now close this: the id regex rejects all-dots ids, and
+  // registerPlugin asserts containment at the write site so a future regex
+  // relaxation can't reopen it.
+  const managed = path.join(root, "managed");
+  process.env.CLAUTH_MANAGED_PLUGIN_ROOTS = managed;
+  process.env.CLAUTH_USER_PLUGIN_ROOTS = path.join(root, "user");
+  const sourceDir = fs.mkdtempSync(path.join(os.tmpdir(), "clauth-register-traversal-"));
+  const manifestPath = path.join(sourceDir, "clauth-plugin.json");
+  fs.writeFileSync(manifestPath, JSON.stringify({ schema: "lifeai.plugin.v1", id: "..", version: "1.0.0", publisher: "t", documentation: { architecture: "a.md" }, surfaces: [] }), "utf8");
+
+  const receipt = registerPlugin(manifestPath, "test");
+  assert.equal(receipt.resulting_state.ok, false);
+  assert.equal(receipt.resulting_state.state, "manifest_invalid");
+  const escapedPath = path.join(managed, "..", "clauth-plugin.json");
+  assert.equal(fs.existsSync(escapedPath), false, "must never write outside the managed-plugins root");
+
+  fs.rmSync(sourceDir, { recursive: true, force: true });
+}));
+
+test("validatePluginManifest rejects an all-dots plugin or surface id", () => {
+  assert.throws(() => validatePluginManifest(baseManifest("..", {}), "clauth-plugin.json"), /may not be all dots/);
+  assert.throws(() => validatePluginManifest(baseManifest("valid-id", {
+    surfaces: [{ id: ".", lifecycle_owner: "clauth" }],
+  }), "clauth-plugin.json"), /may not be all dots/);
+});
+
+test("registerPlugin rejects an invalid manifest without writing anything", () => 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");
+  const sourceDir = fs.mkdtempSync(path.join(os.tmpdir(), "clauth-register-bad-"));
+  const manifestPath = path.join(sourceDir, "clauth-plugin.json");
+  fs.writeFileSync(manifestPath, JSON.stringify({ schema: "wrong", id: "bad" }), "utf8");
+
+  const receipt = registerPlugin(manifestPath, "test");
+  assert.equal(receipt.resulting_state.ok, false);
+  assert.equal(receipt.resulting_state.state, "manifest_invalid");
+  assert.equal(fs.existsSync(path.join(managed, "bad")), false);
+
+  fs.rmSync(sourceDir, { recursive: true, force: true });
+}));
+
 test("tunnel route add and remove produce reversible operation receipts", () => withTempSupervisor((root) => {
   process.env.CLAUTH_MANAGED_PLUGIN_ROOTS = path.join(root, "managed");
   process.env.CLAUTH_USER_PLUGIN_ROOTS = path.join(root, "user");

package/cli/watchdog-registry.js

@@ -178,7 +178,30 @@ export function readWatchdogEvents(limit = 100) {
   }
 }
 
-export function restartWatchdogService(id) {
+async function verifyRestartHealth(service) {
+  if (!service.health?.url) return { ok: true, health_status: "not_configured" };
+
+  const attempts = Number(service.health.readyAttempts || 20);
+  const delayMs = Number(service.health.readyDelayMs || 250);
+  let observed;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    observed = await evaluateWatchdogService(service);
+    if (observed.status === "healthy") {
+      return { ok: true, health_status: observed.status, health_http_status: observed.httpStatus, attempts: attempt };
+    }
+    if (attempt < attempts) await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+  return {
+    ok: false,
+    error: "restart_health_unreachable",
+    health_status: observed?.status || "unknown",
+    health_http_status: observed?.httpStatus,
+    health_error: observed?.error,
+    attempts,
+  };
+}
+
+export async 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" };
@@ -192,18 +215,23 @@ export function restartWatchdogService(id) {
     encoding: "utf8",
     timeout: Number(service.restart.timeoutMs || 30000),
   });
+  const health = result.status === 0 ? await verifyRestartHealth(service) : { ok: false, health_status: "not_checked" };
   const event = {
     kind: "restart",
     service_id: id,
     status: result.status,
+    health_status: health.health_status,
+    health_http_status: health.health_http_status,
+    health_error: health.health_error,
     error: result.error ? result.error.message : undefined,
   };
   appendEvent(event);
   return {
-    ok: result.status === 0,
+    ok: result.status === 0 && health.ok,
     status: result.status,
     stdout: result.stdout,
     stderr: result.stderr,
     error: result.error ? result.error.message : undefined,
+    ...health,
   };
 }

package/cli/watchdog-registry.test.js

@@ -13,12 +13,12 @@ import {
   validateWatchdogService,
 } from "./watchdog-registry.js";
 
-function withTempRegistry(fn) {
+async function withTempRegistry(fn) {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), "clauth-watchdog-"));
   const old = process.env.CLAUTH_WATCHDOG_DIR;
   process.env.CLAUTH_WATCHDOG_DIR = dir;
   try {
-    return fn(dir);
+    return await fn(dir);
   } finally {
     if (old === undefined) delete process.env.CLAUTH_WATCHDOG_DIR;
     else process.env.CLAUTH_WATCHDOG_DIR = old;
@@ -78,12 +78,35 @@ test("registerWatchdogManifest upserts services by id", () => withTempRegistry((
   assert.equal(registry.services.find((service) => service.id === "codeflow").label, "CodeFlow Updated");
 }));
 
-test("restartWatchdogService rejects missing and unapproved services", () => withTempRegistry(() => {
-  assert.deepEqual(restartWatchdogService("missing"), { ok: false, error: "service_not_registered" });
+test("restartWatchdogService rejects missing and unapproved services", async () => withTempRegistry(async () => {
+  assert.deepEqual(await restartWatchdogService("missing"), { ok: false, error: "service_not_registered" });
   registerWatchdogManifest({
     services: [
       { id: "dev-center", label: "Dev Center", kind: "process", restart: { cmd: "node", args: ["--version"] } },
     ],
   });
-  assert.deepEqual(restartWatchdogService("dev-center"), { ok: false, error: "approval_required" });
+  assert.deepEqual(await restartWatchdogService("dev-center"), { ok: false, error: "approval_required" });
+}));
+
+test("restartWatchdogService requires registered health after launching", async () => withTempRegistry(async () => {
+  registerWatchdogManifest({
+    services: [{
+      id: "health-gated",
+      label: "Health gated",
+      kind: "http",
+      health: { url: "http://127.0.0.1:3109/health", readyAttempts: 2, readyDelayMs: 0 },
+      restart: { cmd: process.execPath, args: ["--version"] },
+      approvalRequired: false,
+    }],
+  });
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({ ok: false, status: 503 });
+  try {
+    const result = await restartWatchdogService("health-gated");
+    assert.equal(result.ok, false);
+    assert.equal(result.error, "restart_health_unreachable");
+    assert.equal(result.health_status, "degraded");
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/clauth",
-  "version": "1.31.1",
+  "version": "2.0.0",
   "description": "Hardware-bound credential vault for the LIFEAI infrastructure stack",
   "type": "module",
   "bin": {
@@ -13,7 +13,6 @@
     "test:agent-pool": "node test/agent-pool.test.mjs",
     "test:call-agent-10": "node test/call-agent-10-skills.test.mjs",
     "test:call-agent-guard": "node test/call-agent-guard.test.mjs",
-    "test:tintin-settings": "node test/tintin-settings.test.mjs",
     "postinstall": "node scripts/postinstall.js",
     "worker:start": "node cli/index.js serve",
     "worker:stop": "curl -s http://127.0.0.1:52437/shutdown 2>nul || taskkill /F /IM cloudflared.exe 2>nul & exit 0",
@@ -28,6 +27,7 @@
     "inquirer": "^10.1.0",
     "node-fetch": "^3.3.2",
     "ora": "^8.1.0",
+    "pm2": "^7.0.3",
     "typescript": "^5.9.3"
   },
   "engines": {
@@ -56,6 +56,7 @@
     "scripts/build.mjs",
     "scripts/build.sh",
     "scripts/postinstall.js",
+    "cli/commands/ops-install.js",
     "supabase/",
     ".clauth-skill/",
     "install.sh",