chainlesschain 0.162.181 → 0.162.182

package/src/lib/plugin-runtime/manifest.js

@@ -199,14 +199,15 @@ export function parsePluginManifest(root) {
     warnings,
     manifestSandboxPolicy,
   );
-  c.bin = resolveBin(abs, manifest, safeResolve, warnings);
+  c.bin = resolveBin(
+    abs,
+    manifest,
+    safeResolve,
+    errors,
+    warnings,
+    manifestSandboxPolicy,
+  );
   c.settings = resolveSettings(abs, manifest, safeResolve);
-  if (manifestSandboxPolicy && c.bin.length > 0) {
-    errors.push(
-      "manifest.sandboxPolicy cannot currently protect plugin bin executables; " +
-        "top-level sandbox requirements with bin are not supported",
-    );
-  }
 
   // ── declared capabilities + options schema (P1) ──
   const hasPermissions =
@@ -451,10 +452,17 @@ function resolveLsp(
   return out;
 }
 
-function resolveBin(root, manifest, safeResolve, warnings) {
+function resolveBin(
+  root,
+  manifest,
+  safeResolve,
+  errors,
+  warnings,
+  manifestSandboxPolicy,
+) {
   const out = [];
   const seen = new Set();
-  const push = (name, rel) => {
+  const push = (name, rel, descriptorPolicy = null) => {
     const absPath = safeResolve(rel, `bin["${name}"]`);
     if (!absPath) return;
     if (!_deps.existsSync(absPath)) {
@@ -462,8 +470,29 @@ function resolveBin(root, manifest, safeResolve, warnings) {
       return;
     }
     if (seen.has(name)) return;
+    let sandboxPolicy;
+    try {
+      sandboxPolicy = mergePluginSandboxPolicies(
+        manifestSandboxPolicy,
+        descriptorPolicy,
+      );
+    } catch (err) {
+      errors.push(`bin "${name}": ${err.message}`);
+      return;
+    }
+    if (sandboxPolicy && !/^[A-Za-z0-9._-]+$/.test(name)) {
+      errors.push(
+        `bin alias "${name}" with sandboxPolicy contains unsupported characters; use letters, numbers, dot, underscore, or hyphen`,
+      );
+      return;
+    }
     seen.add(name);
-    out.push({ name, path: rel, absPath });
+    out.push({
+      name,
+      path: rel,
+      absPath,
+      ...(sandboxPolicy ? { sandboxPolicy } : {}),
+    });
   };
 
   if (
@@ -471,8 +500,35 @@ function resolveBin(root, manifest, safeResolve, warnings) {
     typeof manifest.bin === "object" &&
     !Array.isArray(manifest.bin)
   ) {
-    for (const [name, rel] of Object.entries(manifest.bin)) {
-      if (typeof rel === "string") push(name, rel);
+    for (const [name, descriptor] of Object.entries(manifest.bin)) {
+      if (typeof descriptor === "string") {
+        push(name, descriptor);
+        continue;
+      }
+      if (
+        descriptor &&
+        typeof descriptor === "object" &&
+        !Array.isArray(descriptor)
+      ) {
+        const unsupported = Object.keys(descriptor).filter(
+          (key) => !["path", "sandboxPolicy"].includes(key),
+        );
+        if (unsupported.length > 0) {
+          errors.push(
+            `bin "${name}" contains unsupported field: ${unsupported[0]}`,
+          );
+          continue;
+        }
+        if (typeof descriptor.path !== "string") {
+          errors.push(`bin "${name}".path must be a non-empty string`);
+          continue;
+        }
+        push(name, descriptor.path, descriptor.sandboxPolicy);
+        continue;
+      }
+      errors.push(
+        `bin "${name}" must be a path string or { path, sandboxPolicy } object`,
+      );
     }
     return out;
   }

package/src/lib/plugin-runtime/scopes.js

@@ -136,13 +136,20 @@ export function discoverPlugins(opts = {}) {
   const byName = new Map(); // name → record (later scope overrides earlier)
   for (const scope of scopes) {
     const root = scopeRoot(scope, opts);
-    if (!dirExists(root)) continue;
-    for (const encoded of listDirs(root)) {
+    if (!dirExists(root, opts.strictIo === true)) continue;
+    for (const encoded of listDirs(root, opts.strictIo === true)) {
       const nameDir = path.join(root, encoded);
-      const version = activeVersionForDir(nameDir);
+      const version = activeVersionForDir(nameDir, opts.strictIo === true);
       if (!version) continue;
       const versionDir = path.join(nameDir, version);
       const manifest = parsePluginManifest(versionDir);
+      if (opts.strictIo === true && manifest.ok !== true) {
+        throw new Error(
+          `plugin manifest is not safely loadable at ${versionDir}: ${
+            manifest.errors?.join("; ") || "unknown manifest error"
+          }`,
+        );
+      }
       manifest.scope = scope;
       const name = manifest.metadata?.name || encoded;
       byName.set(name, {
@@ -188,8 +195,8 @@ export function discoverPlugins(opts = {}) {
 
 // ── internals ────────────────────────────────────────────────────────────
 
-function activeVersionForDir(nameDir) {
-  if (!dirExists(nameDir)) return null;
+function activeVersionForDir(nameDir, strictIo = false) {
+  if (!dirExists(nameDir, strictIo)) return null;
   const versions = _deps
     .readdirSync(nameDir, { withFileTypes: true })
     .filter((e) => e.isDirectory())
@@ -202,28 +209,31 @@ function activeVersionForDir(nameDir) {
     try {
       const pinned = _deps.readFileSync(activeFile, "utf8").trim();
       if (versions.includes(pinned)) return pinned;
-    } catch {
+    } catch (error) {
+      if (strictIo) throw error;
       /* fall through */
     }
   }
   return versions[0];
 }
 
-function dirExists(dir) {
+function dirExists(dir, strictIo = false) {
   try {
     return _deps.existsSync(dir) && _deps.statSync(dir).isDirectory();
-  } catch {
+  } catch (error) {
+    if (strictIo) throw error;
     return false;
   }
 }
 
-function listDirs(dir) {
+function listDirs(dir, strictIo = false) {
   try {
     return _deps
       .readdirSync(dir, { withFileTypes: true })
       .filter((e) => e.isDirectory())
       .map((e) => e.name);
-  } catch {
+  } catch (error) {
+    if (strictIo) throw error;
     return [];
   }
 }