chainlesschain 0.165.5 → 0.165.8

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

@@ -37,7 +37,9 @@ export function collectPluginSettings(opts = {}) {
   } catch {
     return { env: {}, model: null, sources: [] };
   }
-  const { trusted, skipped } = partitionByTrust(plugins);
+  const { trusted, skipped } = partitionByTrust(plugins, {
+    workspaceRoot: opts.cwd,
+  });
   warnUntrustedOnce(
     skipped.filter((p) => p.manifest?.components?.settings).map((p) => p.name),
     "settings",

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

@@ -22,12 +22,21 @@
  */
 
 import path from "path";
+import { createHash } from "node:crypto";
 import { getElectronUserDataDir } from "../paths.js";
 import { withFileLock } from "../with-file-lock.js";
 import {
   mutateSecurityStore,
   readSecurityStore,
 } from "../durable-security-store.js";
+import {
+  checkRecordedWorkspaceTrust,
+  evaluateWorkspaceTrustDecision,
+  projectWorkspaceTrustAudit,
+  recordWorkspaceTrustConsent,
+  resolveCanonicalWorkspaceRepoIdentity,
+  revokeRecordedWorkspaceTrust,
+} from "../workspace-trust.js";
 
 export const _deps = {
   now: () => new Date().toISOString(),
@@ -35,10 +44,16 @@ export const _deps = {
   // Path of the trust store; injectable so unit tests never touch the real
   // user-data dir.
   storePath: () => path.join(getElectronUserDataDir(), "plugin-trust.json"),
+  // Test-only seam. Production uses workspace-trust.js's one shared ledger.
+  workspaceTrustStorePath: () => null,
 };
 
 const AUTO_TRUSTED_SCOPES = new Set(["user", "local"]);
 
+function defaultPluginTrustStorePath() {
+  return path.join(getElectronUserDataDir(), "plugin-trust.json");
+}
+
 export function loadTrustStore() {
   return readSecurityStore(_deps.storePath(), "plugin trust");
 }
@@ -47,26 +62,228 @@ function trustKey(scope, name) {
   return `${scope}:${name}`;
 }
 
+const PLUGIN_WORKSPACE_TRUST_SOURCE = "plugin";
+
+function workspaceTrustStoreOptions(options = {}) {
+  const sourceStore = options.storePath || _deps.storePath();
+  let usesDefaultSourceStore = false;
+  try {
+    usesDefaultSourceStore =
+      path.resolve(sourceStore) === path.resolve(defaultPluginTrustStorePath());
+  } catch {
+    // Let the source-specific mutation/check fail closed later. This helper
+    // must not turn an invalid custom path into the production shared ledger.
+  }
+  const store =
+    options.workspaceTrustStorePath ||
+    process.env.CC_WORKSPACE_TRUST_STORE ||
+    _deps.workspaceTrustStorePath() ||
+    (!usesDefaultSourceStore && typeof sourceStore === "string"
+      ? path.join(path.dirname(sourceStore), "workspace-trust-v1.json")
+      : null);
+  return store ? { storePath: store } : {};
+}
+
+function pluginWorkspaceRoot(plugin, options = {}) {
+  return (
+    options.workspaceRoot ||
+    plugin?.workspaceRoot ||
+    plugin?.projectRoot ||
+    plugin?.cwd ||
+    process.cwd()
+  );
+}
+
+function pluginWorkspaceTrustContext(plugin, options = {}) {
+  const scope = String(plugin?.scope || "");
+  const name = String(plugin?.name || "");
+  const version = String(plugin?.version || "");
+  if (!scope || !name || !version) {
+    throw new Error("plugin trust requires scope, name, and version");
+  }
+  const identity = resolveCanonicalWorkspaceRepoIdentity(
+    pluginWorkspaceRoot(plugin, options),
+  );
+  const subject = `${scope}:${name}`;
+  const fingerprint = createHash("sha256")
+    .update(`${scope}\0${name}\0${version}`, "utf8")
+    .digest("hex");
+  return { identity, subject, fingerprint };
+}
+
+function workspaceTrustKey(plugin, context) {
+  const nameDigest = createHash("sha256")
+    .update(String(plugin.name), "utf8")
+    .digest("hex");
+  return `workspace-v1:${context.identity.workspaceId}:${nameDigest}`;
+}
+
+function pluginDecision(status, context, consent = "explicit") {
+  const decision = evaluateWorkspaceTrustDecision({
+    identity: context.identity,
+    evidence: [
+      {
+        source: PLUGIN_WORKSPACE_TRUST_SOURCE,
+        consent,
+        fingerprint: context.fingerprint,
+        decision:
+          status === "trusted"
+            ? "allow"
+            : status === "first-use"
+              ? "ask"
+              : "deny",
+      },
+    ],
+  });
+  return Object.freeze({
+    status,
+    decision: decision.decision,
+    audit: projectWorkspaceTrustAudit(decision),
+  });
+}
+
 /**
- * May this plugin's code-bearing components run?
- * @param {{ scope, name, version }} plugin
+ * Evaluate one plugin against the shared canonical workspace trust lattice.
+ * User/local scope keeps its established local-install consent model; project
+ * scope requires both the source-specific record and the shared v1 record.
  */
-export function isPluginTrusted(plugin) {
-  if (!plugin || !plugin.name) return false;
-  if (AUTO_TRUSTED_SCOPES.has(plugin.scope)) return true;
+export function checkPluginWorkspaceTrust(plugin, options = {}) {
+  if (!plugin || !plugin.name) {
+    return Object.freeze({
+      status: "changed",
+      decision: "deny",
+      audit: projectWorkspaceTrustAudit(null),
+    });
+  }
+  const scope = String(plugin.scope || "");
   try {
-    const entry = loadTrustStore()[trustKey(plugin.scope, plugin.name)];
-    return Boolean(entry && entry.version === plugin.version);
+    const context = pluginWorkspaceTrustContext(plugin, options);
+    if (AUTO_TRUSTED_SCOPES.has(scope)) {
+      return pluginDecision("trusted", context, "scope-default");
+    }
+    if (scope !== "project") return pluginDecision("changed", context);
+
+    const store = loadTrustStore();
+    const record = store[workspaceTrustKey(plugin, context)];
+    const legacy = store[trustKey(scope, plugin.name)];
+    if (!record || typeof record !== "object" || Array.isArray(record)) {
+      // Old scope:name records have no canonical workspace identity.  They
+      // remain visible to listTrust(), but require explicit re-consent.
+      const shared = checkRecordedWorkspaceTrust({
+        identity: context.identity,
+        source: PLUGIN_WORKSPACE_TRUST_SOURCE,
+        subject: context.subject,
+        evidenceFingerprint: context.fingerprint,
+        ...workspaceTrustStoreOptions(options),
+      });
+      if (shared.status === "changed") {
+        return Object.freeze({
+          status: "changed",
+          decision: shared.decision,
+          audit: shared.audit,
+        });
+      }
+      if (legacy?.version) {
+        // Match the shared migration contract: a legacy allow is downgraded
+        // to `ask`, never silently reused. `isPluginTrusted` still refuses to
+        // run it until trustPlugin writes canonical v1 consent.
+        return Object.freeze({
+          ...pluginDecision("first-use", context, "legacy"),
+          status: "changed",
+        });
+      }
+      return Object.freeze({
+        status: "first-use",
+        decision: shared.decision,
+        audit: shared.audit,
+      });
+    }
+    const binding = record.workspaceTrust;
+    if (
+      record.version !== plugin.version ||
+      !binding ||
+      binding.workspaceId !== context.identity.workspaceId ||
+      binding.repositoryId !== context.identity.repositoryId ||
+      binding.subject !== context.subject
+    ) {
+      return pluginDecision("changed", context);
+    }
+    const shared = checkRecordedWorkspaceTrust({
+      identity: context.identity,
+      source: PLUGIN_WORKSPACE_TRUST_SOURCE,
+      subject: context.subject,
+      evidenceFingerprint: context.fingerprint,
+      ...workspaceTrustStoreOptions(options),
+    });
+    return Object.freeze({
+      status: shared.status === "trusted" ? "trusted" : "changed",
+      decision: shared.decision,
+      audit: shared.audit,
+    });
   } catch {
-    // Project code must stay disabled when the trust store is unavailable.
-    return false;
+    return Object.freeze({
+      status: "changed",
+      decision: "deny",
+      audit: projectWorkspaceTrustAudit(null),
+    });
   }
 }
 
+/**
+ * May this plugin's code-bearing components run?
+ * @param {{ scope, name, version }} plugin
+ */
+export function isPluginTrusted(plugin) {
+  return checkPluginWorkspaceTrust(plugin).decision === "allow";
+}
+
 /** Trust a plugin (records the exact version). */
-export function trustPlugin(name, { scope = "project", version } = {}) {
+export function trustPlugin(
+  name,
+  { scope = "project", version, workspaceRoot, workspaceTrustStorePath } = {},
+) {
   if (!version) throw new Error("trustPlugin requires a version");
   const file = _deps.storePath();
+  const plugin = { scope, name, version, workspaceRoot };
+  if (scope === "project") {
+    const context = pluginWorkspaceTrustContext(plugin, { workspaceRoot });
+    recordWorkspaceTrustConsent({
+      identity: context.identity,
+      source: PLUGIN_WORKSPACE_TRUST_SOURCE,
+      subject: context.subject,
+      evidenceFingerprint: context.fingerprint,
+      consent: "explicit",
+      ...workspaceTrustStoreOptions({
+        workspaceTrustStorePath,
+        storePath: file,
+      }),
+    });
+    return mutateSecurityStore(
+      file,
+      "plugin trust",
+      (store) => {
+        store[workspaceTrustKey(plugin, context)] = {
+          name,
+          scope,
+          version,
+          trustedAt: _deps.now(),
+          workspaceTrust: {
+            schemaVersion: context.identity.schemaVersion,
+            workspaceId: context.identity.workspaceId,
+            repositoryId: context.identity.repositoryId,
+            subject: context.subject,
+          },
+        };
+        return {
+          name,
+          scope,
+          version,
+          workspaceId: context.identity.workspaceId,
+        };
+      },
+      { lock: _deps.withFileLock },
+    );
+  }
   return mutateSecurityStore(
     file,
     "plugin trust",
@@ -79,8 +296,38 @@ export function trustPlugin(name, { scope = "project", version } = {}) {
 }
 
 /** Revoke trust for a plugin at a scope. */
-export function untrustPlugin(name, { scope = "project" } = {}) {
+export function untrustPlugin(
+  name,
+  { scope = "project", workspaceRoot, workspaceTrustStorePath } = {},
+) {
   const file = _deps.storePath();
+  if (scope === "project") {
+    const plugin = { scope, name, version: "trust-revocation", workspaceRoot };
+    const context = pluginWorkspaceTrustContext(plugin, { workspaceRoot });
+    const result = mutateSecurityStore(
+      file,
+      "plugin trust",
+      (store) => {
+        const key = workspaceTrustKey(plugin, context);
+        const existed = Object.prototype.hasOwnProperty.call(store, key);
+        delete store[key];
+        return { name, scope, removed: existed };
+      },
+      { lock: _deps.withFileLock },
+    );
+    // Local removal happens first, so a shared-ledger write failure cannot
+    // leave the code-bearing plugin authorized.
+    revokeRecordedWorkspaceTrust({
+      identity: context.identity,
+      source: PLUGIN_WORKSPACE_TRUST_SOURCE,
+      subject: context.subject,
+      ...workspaceTrustStoreOptions({
+        workspaceTrustStorePath,
+        storePath: file,
+      }),
+    });
+    return result;
+  }
   return mutateSecurityStore(
     file,
     "plugin trust",
@@ -97,12 +344,23 @@ export function untrustPlugin(name, { scope = "project" } = {}) {
 /** All trust entries (for `cc plugin trust --list`). */
 export function listTrust() {
   return Object.entries(loadTrustStore()).map(([key, v]) => {
+    if (key.startsWith("workspace-v1:") && v?.workspaceTrust) {
+      return {
+        scope: "project",
+        name: typeof v.name === "string" ? v.name : null,
+        version: v?.version || null,
+        trustedAt: v?.trustedAt || null,
+        workspaceId: v.workspaceTrust.workspaceId || null,
+        repositoryId: v.workspaceTrust.repositoryId || null,
+      };
+    }
     const idx = key.indexOf(":");
     return {
       scope: key.slice(0, idx),
       name: key.slice(idx + 1),
       version: v?.version || null,
       trustedAt: v?.trustedAt || null,
+      legacy: key.startsWith("project:"),
     };
   });
 }
@@ -111,11 +369,14 @@ export function listTrust() {
  * Split discovered plugins into those whose code may run and those gated out.
  * @returns {{ trusted: any[], skipped: any[] }}
  */
-export function partitionByTrust(plugins) {
+export function partitionByTrust(plugins, options = {}) {
   const trusted = [];
   const skipped = [];
   for (const p of plugins || []) {
-    (isPluginTrusted(p) ? trusted : skipped).push(p);
+    (checkPluginWorkspaceTrust(p, options).decision === "allow"
+      ? trusted
+      : skipped
+    ).push(p);
   }
   return { trusted, skipped };
 }