@lifeaitools/clauth 1.30.26 → 2.0.0

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");