@lifeaitools/clauth 2.0.1 → 2.0.3

package/cli/supervisor-registry.js

@@ -167,7 +167,14 @@ 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`);
-  const normalizedArgs = args.map(String);
+  // Expand the same path tokens `cwd` already gets. Until now expandPathToken()
+  // was applied ONLY to cwd, so a manifest naming a root inside a command
+  // argument shipped the literal string to the shell — dev-center's
+  // "$LIFEAI_ENV/services/restart-dev-center.ps1" reached pwsh unexpanded and
+  // exited 64. Expanding here, AFTER the shell-syntax checks on cmd and BEFORE
+  // the per-arg checks below, keeps the injection guard authoritative over the
+  // final value rather than the pre-expansion one.
+  const normalizedArgs = args.map((a) => expandPathToken(String(a)) ?? String(a));
   // 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
@@ -192,13 +199,24 @@ export function shellQuote(value, useShell) {
 function expandPathToken(value) {
   if (!value) return null;
   const root = process.env.REGEN_ROOT || process.env.LIFEAI_REPO_ROOT || "C:/Dev/regen-root";
+  // LIFEAI_ENV is the environment-harness checkout. A manifest that drives a
+  // service through a harness script (dev-center calls
+  // $LIFEAI_ENV/services/restart-dev-center.ps1) had no way to name it, so the
+  // literal token reached the shell and pwsh answered
+  // "not recognized as the name of a script file" with exit 64 — a restart that
+  // fails while the service stays up, which reads as a flaky action rather than
+  // an unresolved path.
+  const envRoot = process.env.LIFEAI_ENV || "C:/Dev/lifeai-env";
   return String(value)
     .replace(/\$\{REGEN_ROOT\}/g, root)
     .replace(/\$REGEN_ROOT/g, root)
     .replace(/%REGEN_ROOT%/gi, root)
     .replace(/\$\{LIFEAI_REPO_ROOT\}/g, root)
     .replace(/\$LIFEAI_REPO_ROOT/g, root)
-    .replace(/%LIFEAI_REPO_ROOT%/gi, root);
+    .replace(/%LIFEAI_REPO_ROOT%/gi, root)
+    .replace(/\$\{LIFEAI_ENV\}/g, envRoot)
+    .replace(/\$LIFEAI_ENV/g, envRoot)
+    .replace(/%LIFEAI_ENV%/gi, envRoot);
 }
 
 function normalizeLifecycleOwner(owner) {
@@ -482,6 +500,23 @@ export function registerPlugin(manifestPath, actor = "localhost") {
       ok: false, state: "manifest_unreadable", error: error instanceof Error ? error.message : String(error),
     }, actor);
   }
+  // ${PACKAGE_ROOT} — "wherever this manifest actually landed" — resolved HERE
+  // and baked into the stored copy, which is the only point at which the true
+  // origin is still known. registerPlugin copies the manifest into the managed
+  // root, so by the time discoverPlugins() re-reads it, sourcePath is the
+  // managed directory and the package's real install location is gone. An npm
+  // package installs at node_modules/@scope/name/, a path nothing can hardcode.
+  //
+  // Without this a shipped manifest had to name an absolute path: rdc-skills
+  // carried cwd "C:/Dev/rdc-skills" with core+enable_default, so `npm i -g` on
+  // any other machine auto-enabled a CORE plugin pointing at a directory that
+  // does not exist there. The token, not the package, was the defect — the
+  // correct value was simply inexpressible.
+  const packageRoot = path.dirname(path.resolve(manifestPath)).replaceAll("\\", "/");
+  raw = raw
+    .replaceAll("${PACKAGE_ROOT}", packageRoot)
+    .replaceAll("$PACKAGE_ROOT", packageRoot)
+    .replace(/%PACKAGE_ROOT%/gi, packageRoot);
   let manifest;
   try {
     manifest = validatePluginManifest(JSON.parse(raw), manifestPath);

package/cli/supervisor-registry.test.js

@@ -887,3 +887,78 @@ test("tunnel route add and remove produce reversible operation receipts", () =>
   assert.equal(removed.resulting_state.ok, true);
   assert.equal(removed.resulting_state.state, "route_removed");
 }));
+
+test("command arguments expand path tokens, not just cwd", () => {
+  // Regression: expandPathToken() was applied ONLY to `cwd`, so a manifest that
+  // named a root inside a COMMAND ARGUMENT shipped the literal string to the
+  // shell. dev-center's restart is
+  // ["pwsh","-NoProfile","-File","$LIFEAI_ENV/services/restart-dev-center.ps1"]
+  // and pwsh answered "not recognized as the name of a script file" with exit
+  // 64 -- a restart that fails while the service stays up, which reads as a
+  // flaky action rather than an unresolved path.
+  const oldEnv = process.env.LIFEAI_ENV;
+  const oldRoot = process.env.REGEN_ROOT;
+  process.env.LIFEAI_ENV = "C:/tmp/env-root";
+  process.env.REGEN_ROOT = "C:/tmp/regen-root";
+  try {
+    const plugin = validatePluginManifest(baseManifest("token-expansion", {
+      surfaces: [{
+        id: "primary",
+        destination: "local/clauth/pm2",
+        lifecycle_owner: "clauth",
+        port: 3003,
+        health: "/health",
+        restart: ["pwsh", "-NoProfile", "-File", "$LIFEAI_ENV/services/restart-dev-center.ps1"],
+        start: ["node", "${REGEN_ROOT}/scripts/start.mjs"],
+      }],
+    }), "clauth-plugin.json");
+    const s = plugin.surfaces[0];
+    assert.ok(!s.restart.some((a) => a.includes("$LIFEAI_ENV")),
+      `LIFEAI_ENV left unexpanded: ${JSON.stringify(s.restart)}`);
+    assert.ok(s.restart.some((a) => a.includes("C:/tmp/env-root")),
+      `LIFEAI_ENV did not expand to its value: ${JSON.stringify(s.restart)}`);
+    assert.ok(s.start.some((a) => a.includes("C:/tmp/regen-root")),
+      `REGEN_ROOT did not expand in a command arg: ${JSON.stringify(s.start)}`);
+  } finally {
+    if (oldEnv === undefined) delete process.env.LIFEAI_ENV; else process.env.LIFEAI_ENV = oldEnv;
+    if (oldRoot === undefined) delete process.env.REGEN_ROOT; else process.env.REGEN_ROOT = oldRoot;
+  }
+});
+
+test("registerPlugin resolves ${PACKAGE_ROOT} to the manifest's real origin", () => withTempSupervisor((root) => {
+  // An npm package installs at node_modules/@scope/name/ — a path no shipped
+  // manifest can hardcode. registerPlugin COPIES the manifest into the managed
+  // root, so by the time discoverPlugins() re-reads it the true origin is gone;
+  // the token therefore has to be resolved at registration and baked in.
+  //
+  // Without it, rdc-skills shipped cwd "C:/Dev/rdc-skills" with core +
+  // enable_default, so `npm i -g` on any other machine auto-enabled a CORE
+  // plugin pointing at a directory that does not exist there.
+  const origin = path.join(root, "pretend-node-modules", "@lifeaitools", "some-mcp");
+  fs.mkdirSync(origin, { recursive: true });
+  const manifestPath = path.join(origin, "clauth-plugin.json");
+  fs.writeFileSync(manifestPath, JSON.stringify(baseManifest("package-root-demo", {
+    surfaces: [{
+      id: "local",
+      destination: "local/clauth/pm2",
+      lifecycle_owner: "clauth",
+      port: 39114,
+      health: "/health",
+      cwd: "${PACKAGE_ROOT}",
+      start: ["node", "${PACKAGE_ROOT}/bin/server.mjs"],
+    }],
+  }), null, 2), "utf8");
+
+  const receipt = registerPlugin(manifestPath, "test");
+  assert.equal(receipt.resulting_state.ok, true, JSON.stringify(receipt.resulting_state));
+
+  const surface = listSurfaces().find((s) => s.plugin_id === "package-root-demo");
+  assert.ok(surface, "surface was not registered");
+  const expected = origin.replaceAll("\\", "/");
+  assert.equal(surface.cwd.replaceAll("\\", "/"), expected,
+    `cwd did not resolve to the manifest origin: ${surface.cwd}`);
+  assert.ok(surface.start.some((a) => a.replaceAll("\\", "/").includes(expected)),
+    `command arg did not resolve to the manifest origin: ${JSON.stringify(surface.start)}`);
+  assert.ok(!JSON.stringify(surface).includes("PACKAGE_ROOT"),
+    "an unexpanded PACKAGE_ROOT token survived into registered state");
+}));

package/package.json

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