chainlesschain 0.162.189 → 0.162.197

package/src/lib/project-instructions.js

@@ -52,7 +52,8 @@ export const LOCAL_FILE_NAMES = ["cc.local.md", "CLAUDE.local.md"];
  * path RELATIVE to the project root, with forward slashes:
  *   - a bare name (`node_modules`, `dist`) matches that segment ANYWHERE;
  *   - a slashed prefix (`packages/legacy`) matches that dir and everything under;
- *   - a glob (`**​/generated/**`, `vendor/*`) matches via `*`/`**`/`?`.
+ *   - a glob (`**` followed by `/generated/**`, or `vendor/*`) matches via
+ *     `*`/`**`/`?`.
  */
 export function normalizeInstructionExcludes(list) {
   if (!Array.isArray(list)) return [];
@@ -534,15 +535,30 @@ export function resolveSubtreeInstructions(opts = {}) {
   // Subtree instructions apply only to DESCENDANTS of baseDir (ancestors were
   // loaded at startup). Reject a target that escapes baseDir or the repo.
   const relFromBase = path.relative(baseDir, target);
-  if (
-    !relFromBase ||
-    relFromBase.startsWith("..") ||
-    path.isAbsolute(relFromBase)
-  ) {
+  if (pathEscapesBoundary(path, relFromBase)) {
+    if (opts.strictBoundary) {
+      throw new SubtreeInstructionBoundaryError({
+        repoRoot,
+        baseDir,
+        targetPath: target,
+      });
+    }
     return [];
   }
   const relFromRoot = path.relative(repoRoot, target);
-  if (relFromRoot.startsWith("..") || path.isAbsolute(relFromRoot)) return [];
+  if (pathEscapesBoundary(path, relFromRoot)) {
+    if (opts.strictBoundary) {
+      throw new SubtreeInstructionBoundaryError({
+        repoRoot,
+        baseDir,
+        targetPath: target,
+      });
+    }
+    return [];
+  }
+  // A path directly in baseDir has no lazy subtree instructions. This is a
+  // valid no-op, not a boundary violation.
+  if (!relFromBase) return [];
 
   // Directories strictly between baseDir (exclusive) and target (inclusive).
   const dirs = [];
@@ -573,43 +589,163 @@ export function resolveSubtreeInstructions(opts = {}) {
 }
 
 /**
- * Stateful companion to `resolveSubtreeInstructions`: tracks which subtree
- * directories have already been injected across a session so a second access to
- * the same subtree is a no-op. `onAccess(path)` returns ONLY the freshly
- * discovered files. Fail-open (any error → []).
+ * Explicit error used by the strict, stateful discovery API. The legacy pure
+ * resolver and `onAccess()` remain fail-open for compatibility, while batching
+ * callers can distinguish an empty discovery from a rejected path traversal.
+ */
+export class SubtreeInstructionBoundaryError extends Error {
+  constructor({ repoRoot, baseDir, targetPath }) {
+    super(
+      `subtree instruction target is outside the allowed project boundary: ${targetPath}`,
+    );
+    this.name = "SubtreeInstructionBoundaryError";
+    this.code = "ERR_SUBTREE_INSTRUCTION_BOUNDARY";
+    this.repoRoot = repoRoot;
+    this.baseDir = baseDir;
+    this.targetPath = targetPath;
+  }
+}
+
+function subtreeInstructionIdentity(path, filePath) {
+  const absolute = path.resolve(filePath);
+  // Windows paths are case-insensitive. Normalising case makes discoveries for
+  // source + target paths safe to merge by identity even if callers use
+  // different drive-letter/path casing.
+  return path.sep === "\\" ? absolute.toLowerCase() : absolute;
+}
+
+function pathEscapesBoundary(path, relativePath) {
+  return (
+    relativePath === ".." ||
+    relativePath.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relativePath)
+  );
+}
+
+/**
+ * Stateful companion to `resolveSubtreeInstructions`. `discover(path)` returns
+ * uncommitted candidates carrying stable identities; `commit()` / `markLoaded()`
+ * acknowledge only candidates that the caller successfully read and parsed.
+ * `onAccess()` retains the previous fail-open convenience behavior.
  */
 export class SubtreeInstructionLoader {
   constructor(opts = {}) {
     const path = opts.deps?.path || pathDefault;
     this._opts = opts;
-    this._loadedDirs = new Set();
-    this._loadedFiles = new Set(
-      (opts.alreadyLoaded || []).map((p) => path.resolve(p)),
-    );
+    this._path = path;
+    this._loadedFiles = new Map();
+    for (const filePath of opts.alreadyLoaded || []) {
+      const absolute = path.resolve(filePath);
+      this._loadedFiles.set(
+        subtreeInstructionIdentity(path, absolute),
+        absolute,
+      );
+    }
   }
 
-  /** @returns {Array<{path:string, scope:"project", dir:string}>} newly injected */
+  /**
+   * Discover every applicable instruction file not yet committed. Discovery is
+   * intentionally repeatable and does not mutate loaded state.
+   *
+   * @returns {Array<{path:string, scope:"project", dir:string, identity:string}>}
+   * @throws {SubtreeInstructionBoundaryError} when targetPath escapes base/repo
+   */
+  discover(targetPath) {
+    const found = resolveSubtreeInstructions({
+      ...this._opts,
+      accessedPath: targetPath,
+      alreadyLoaded: [],
+      strictBoundary: true,
+    });
+    return found
+      .map((candidate) => ({
+        ...candidate,
+        identity: subtreeInstructionIdentity(this._path, candidate.path),
+      }))
+      .filter((candidate) => !this._loadedFiles.has(candidate.identity));
+  }
+
+  /**
+   * Mark successfully read/parsed/injected discoveries as loaded. Callers may
+   * pass one candidate or a source+target batch deduped by `identity`.
+   *
+   * @returns {number} number of newly committed instruction files
+   */
+  commit(discoveries) {
+    const batch = Array.isArray(discoveries) ? discoveries : [discoveries];
+    const validated = new Map();
+    for (const candidate of batch) {
+      const candidatePath =
+        typeof candidate === "string"
+          ? candidate
+          : candidate?.path || candidate?.identity;
+      if (typeof candidatePath !== "string") continue;
+      const absolute = this._path.resolve(candidatePath);
+      const identity = subtreeInstructionIdentity(this._path, absolute);
+      if (
+        typeof candidate !== "string" &&
+        candidate.identity &&
+        candidate.identity !== identity
+      ) {
+        throw new TypeError(
+          `subtree instruction identity does not match its path: ${candidate.identity}`,
+        );
+      }
+
+      // A caller may commit a source+target batch assembled across discover()
+      // calls. Recheck its lexical boundary before mutating loaded state.
+      const repoRoot = this._path.resolve(
+        this._opts.repoRoot || this._opts.baseDir || process.cwd(),
+      );
+      const baseDir = this._path.resolve(this._opts.baseDir || repoRoot);
+      const relativeToBase = this._path.relative(baseDir, absolute);
+      const relativeToRoot = this._path.relative(repoRoot, absolute);
+      if (
+        pathEscapesBoundary(this._path, relativeToBase) ||
+        pathEscapesBoundary(this._path, relativeToRoot)
+      ) {
+        throw new SubtreeInstructionBoundaryError({
+          repoRoot,
+          baseDir,
+          targetPath: absolute,
+        });
+      }
+      validated.set(identity, absolute);
+    }
+
+    // Validate the complete source+target batch before mutating loaded state.
+    let committed = 0;
+    for (const [identity, absolute] of validated) {
+      if (!this._loadedFiles.has(identity)) {
+        this._loadedFiles.set(identity, absolute);
+        committed++;
+      }
+    }
+    return committed;
+  }
+
+  /** Alias for callers that prefer acknowledgement terminology. */
+  markLoaded(discoveries) {
+    return this.commit(discoveries);
+  }
+
+  /**
+   * Legacy discover+commit convenience. New read/parse callers should use the
+   * two phases directly so a transient failure remains retryable.
+   */
   onAccess(accessedPath) {
     try {
-      const found = resolveSubtreeInstructions({
-        ...this._opts,
-        accessedPath,
-        alreadyLoaded: this._loadedFiles,
-      });
-      const fresh = found.filter((f) => !this._loadedDirs.has(f.dir));
-      for (const f of fresh) {
-        this._loadedDirs.add(f.dir);
-        this._loadedFiles.add(f.path);
-      }
-      return fresh;
+      const found = this.discover(accessedPath);
+      this.commit(found);
+      return found;
     } catch {
       return [];
     }
   }
 
-  /** Absolute paths injected so far (startup set + every onAccess discovery). */
+  /** Absolute paths injected so far (startup set + every committed discovery). */
   loadedFiles() {
-    return [...this._loadedFiles];
+    return [...this._loadedFiles.values()];
   }
 }
 

package/src/lib/project-mcp-trust.js

@@ -14,6 +14,7 @@
  */
 
 import path from "node:path";
+import fs from "node:fs";
 import { createHash } from "node:crypto";
 import { getHomeDir } from "./paths.js";
 import { withFileLock } from "./with-file-lock.js";
@@ -23,6 +24,7 @@ import {
 } from "./durable-security-store.js";
 
 export const _deps = { withFileLock };
+const workspaceAuthorities = new WeakMap();
 
 function storePath(opts = {}) {
   return (
@@ -36,6 +38,71 @@ export function projectMcpFingerprint(content) {
   return createHash("sha256").update(String(content), "utf-8").digest("hex");
 }
 
+/**
+ * Issue an in-process authority only after the caller has verified the exact
+ * project file fingerprint. Plain config fields cannot forge this token.
+ */
+export function issueProjectMcpWorkspaceAuthority({
+  file,
+  content,
+  workspaceRoot,
+  serverName,
+  config = {},
+}) {
+  const canonicalFile = fs.realpathSync.native(path.resolve(file));
+  const canonicalRoot = fs.realpathSync.native(path.resolve(workspaceRoot));
+  const token = Object.freeze({});
+  workspaceAuthorities.set(
+    token,
+    Object.freeze({
+      file: canonicalFile,
+      fingerprint: projectMcpFingerprint(content),
+      workspaceRoot: canonicalRoot,
+      serverName: String(serverName || ""),
+      url: typeof config.url === "string" ? config.url : "",
+      transport: typeof config.transport === "string" ? config.transport : "",
+      headersHelper:
+        typeof config.headersHelper === "string" ? config.headersHelper : "",
+    }),
+  );
+  return token;
+}
+
+/** Resolve a collector-issued project authority against the exact config. */
+export function resolveProjectMcpWorkspaceAuthority(token, expected = {}) {
+  const record = workspaceAuthorities.get(token);
+  if (!record) return null;
+  let expectedFile;
+  try {
+    expectedFile = fs.realpathSync.native(
+      path.resolve(String(expected.configSource || "")),
+    );
+  } catch {
+    return null;
+  }
+  let currentFingerprint;
+  try {
+    currentFingerprint = projectMcpFingerprint(
+      fs.readFileSync(expectedFile, "utf8"),
+    );
+  } catch {
+    return null;
+  }
+  if (
+    record.file !== expectedFile ||
+    record.fingerprint !== currentFingerprint ||
+    record.serverName !== String(expected.serverName || "") ||
+    record.url !== (typeof expected.url === "string" ? expected.url : "") ||
+    record.transport !==
+      (typeof expected.transport === "string" ? expected.transport : "") ||
+    record.headersHelper !==
+      (typeof expected.headersHelper === "string" ? expected.headersHelper : "")
+  ) {
+    return null;
+  }
+  return record.workspaceRoot;
+}
+
 function readStore(opts) {
   return readSecurityStore(storePath(opts), "project MCP trust");
 }

package/src/lib/public-ide-capability-manifest.js

@@ -0,0 +1,278 @@
+/**
+ * Canonical, public (secret-free) IDE capability manifest.
+ *
+ * Host runtimes intentionally keep their native registration formats
+ * (VS Code package.json/registerCommand, JetBrains plugin.xml/actions and the
+ * existing Desktop keyboard-shortcut registry).  This manifest is the single
+ * reviewable contract those public surfaces are validated against.
+ */
+
+import { buildCompatFixture } from "./capability-manifest.js";
+
+const freeze = (value) => {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) {
+    return value;
+  }
+  for (const child of Object.values(value)) freeze(child);
+  return Object.freeze(value);
+};
+
+const BRIDGE_TOOL_FEATURES = [
+  ["getSelection", "selection"],
+  ["getActiveFile", "active_file"],
+  ["getDiagnostics", "diagnostics"],
+  ["getOpenEditors", "open_editors"],
+  ["openDiff", "native_diff"],
+  ["openMultiDiff", "multi_file_diff"],
+  ["getTerminalOutput", "terminal_output"],
+  ["getPreviewState", "preview_state"],
+  ["getTestResults", "test_results"],
+  ["getCoverage", "coverage"],
+  ["getDebugState", "debug_state"],
+  ["executeCode", "notebook_execute"],
+  ["getHover", "semantic_hover"],
+  ["goToDefinition", "semantic_definition"],
+  ["findReferences", "semantic_references"],
+  ["renamePreview", "semantic_rename"],
+  ["getCallHierarchy", "semantic_call_hierarchy"],
+  ["getSymbolInfo", "semantic_symbols"],
+  ["getProjectModel", "project_model"],
+];
+
+const VSCODE_COMMANDS = [
+  "chainlesschain.ide.showStatus",
+  "chainlesschain.ide.restart",
+  "chainlesschain.ide.openDashboard",
+  "chainlesschain.complete.trigger",
+  "chainlesschain.ide.doctor",
+  "chainlesschain.ide.exportDiagnostics",
+  "chainlesschain.team.monitor",
+  "chainlesschain.session.prStatus",
+  "chainlesschain.background.agents",
+  "chainlesschain.sessions.workbench",
+  "chainlesschain.remote.control",
+  "chainlesschain.usage.show",
+  "chainlesschain.plugins.manage",
+  "chainlesschain.worktree.tasks",
+  "chainlesschain.chrome.connector",
+  "chainlesschain.artifacts.show",
+  "chainlesschain.policy.show",
+  "chainlesschain.workspace.scanAutoExec",
+  "chainlesschain.remote.doctor",
+  "chainlesschain.lens.explain",
+  "chainlesschain.lens.refactor",
+  "chainlesschain.diff.accept",
+  "chainlesschain.diff.reject",
+  "chainlesschain.memory.init",
+  "chainlesschain.memory.files",
+  "chainlesschain.llm.configure",
+  "chainlesschain.llm.configureVision",
+  "chainlesschain.chat.insertReference",
+  "chainlesschain.chat.fixDiagnostics",
+  "chainlesschain.chat.explainSelection",
+  "chainlesschain.chat.refactorSelection",
+  "chainlesschain.chat.newConversation",
+  "chainlesschain.chat.reopenClosedSession",
+  "chainlesschain.inlineChat.open",
+  "chainlesschain.inlineChat.explain",
+  "chainlesschain.inlineChat.refactor",
+  "chainlesschain.inlineChat.fix",
+  "chainlesschain.inlineChat.generateDocs",
+  "chainlesschain.inlineChat.generateTests",
+  "chainlesschain.plan.approve",
+  "chainlesschain.plan.requestChanges",
+  "chainlesschain.plan.regenerate",
+  "chainlesschain.plan.reject",
+  "chainlesschain.preview.start",
+  "chainlesschain.preview.stop",
+  "chainlesschain.cli.upgrade",
+  "chainlesschain.cli.checkUpdate",
+  "chainlesschain.cli.whatsNew",
+  "chainlesschain.cli.installManaged",
+  "chainlesschain.cli.rollbackManaged",
+];
+
+const JETBRAINS_ACTIONS = [
+  "chainlesschain.ide.ShowStatus",
+  "chainlesschain.ide.ShowActivity",
+  "chainlesschain.ide.OpenDashboard",
+  "chainlesschain.team.Monitor",
+  "chainlesschain.session.PrStatus",
+  "chainlesschain.bg.Agents",
+  "chainlesschain.remote.Control",
+  "chainlesschain.sessions.Workbench",
+  "chainlesschain.usage.Show",
+  "chainlesschain.artifacts.Browse",
+  "chainlesschain.policy.Viewer",
+  "chainlesschain.plugins.Manage",
+  "chainlesschain.worktree.Tasks",
+  "chainlesschain.chrome.Connector",
+  "chainlesschain.workspace.ScanAutoExec",
+  "chainlesschain.managedCli.Install",
+  "chainlesschain.managedCli.Rollback",
+  "chainlesschain.ide.DiagnoseBridge",
+  "chainlesschain.ide.ExportDiagnostics",
+  "chainlesschain.ide.RestartBridge",
+  "chainlesschain.cli.whatsNew",
+  "chainlesschain.ide.ConfigureLlm",
+  "chainlesschain.ide.ConfigureVisionModel",
+  "chainlesschain.chat.newConversation",
+  "chainlesschain.chat.reopenClosedConversation",
+  "chainlesschain.completion.trigger",
+  "chainlesschain.chat.explainSelection",
+  "chainlesschain.chat.refactorSelection",
+  "chainlesschain.chat.insertFileReference",
+  "chainlesschain.memory.init",
+  "chainlesschain.memory.files",
+  "chainlesschain.preview.start",
+  "chainlesschain.preview.stop",
+];
+
+const DESKTOP_SHORTCUT_KEYS = [
+  "Ctrl+S",
+  "Ctrl+F",
+  "Ctrl+Shift+F",
+  "Ctrl+P",
+  "Ctrl+K",
+  "Ctrl+B",
+  "Ctrl+`",
+  "Ctrl+/",
+  "Ctrl+D",
+  "Ctrl+Shift+K",
+  "Alt+Up",
+  "Alt+Down",
+  "Ctrl+Z",
+  "Ctrl+Shift+Z",
+  "Ctrl+N",
+  "Ctrl+W",
+  "Ctrl+Shift+T",
+  "Ctrl+Tab",
+  "Ctrl+Shift+Tab",
+  "Esc",
+  "F2",
+  "Delete",
+];
+
+export const PUBLIC_IDE_CAPABILITY_MANIFEST = freeze({
+  schema: "chainlesschain.public-ide-capabilities/v1",
+  schemaVersion: 1,
+  minimumCliVersion: "0.162.47",
+  protocol: buildCompatFixture(),
+  bridge: {
+    schemaVersion: 1,
+    toolFeatures: BRIDGE_TOOL_FEATURES,
+  },
+  surfaces: {
+    cli: {
+      commandManifest: "packages/cli/src/command-manifest.json",
+      commandHelpIndex: "packages/cli/src/command-help-index.json",
+      requiredCommands: ["doctor", "ide"],
+      doctorCommands: ["doctor", "ide doctor"],
+    },
+    vscode: {
+      commandContribution: "packages/vscode-extension/package.json",
+      runtimeRegistration: "packages/vscode-extension/src/extension.js",
+      bridgeCapabilities: "packages/vscode-extension/src/ide-capabilities.js",
+      minimumCliVersionSource: "packages/vscode-extension/src/version-check.js",
+      doctorImplementation: "packages/vscode-extension/src/ide-doctor.js",
+      readme: "packages/vscode-extension/README.md",
+      commands: VSCODE_COMMANDS,
+      doctorCommands: [
+        "chainlesschain.ide.doctor",
+        "chainlesschain.remote.doctor",
+      ],
+    },
+    jetbrains: {
+      actionDescriptor:
+        "packages/jetbrains-plugin/src/main/resources/META-INF/plugin.xml",
+      bridgeCapabilities:
+        "packages/jetbrains-plugin/src/main/java/com/chainlesschain/ide/IdeCapabilities.java",
+      minimumCliVersionSource:
+        "packages/jetbrains-plugin/src/main/java/com/chainlesschain/ide/RuntimeCompatibility.java",
+      doctorImplementation:
+        "packages/jetbrains-plugin/src/main/java/com/chainlesschain/ide/intellij/DiagnoseBridgeAction.java",
+      readme: "packages/jetbrains-plugin/README.md",
+      actions: JETBRAINS_ACTIONS,
+      doctorActions: ["chainlesschain.ide.DiagnoseBridge"],
+    },
+    desktop: {
+      commandRegistry:
+        "desktop-app-vue/src/renderer/utils/keyboard-shortcuts.ts",
+      registryConsumer:
+        "desktop-app-vue/src/renderer/components/common/CommandPalette.vue",
+      defaultShortcutKeys: DESKTOP_SHORTCUT_KEYS,
+      registryContract: [
+        "register",
+        "registerMultiple",
+        "getAllCommands",
+        "show-command-palette",
+      ],
+      // These are existing independent surfaces, not new registries. Recording
+      // them keeps this first slice honest while the later P0-0 convergence
+      // work replaces their placeholder handlers with canonical consumers.
+      unconvergedSurfaces: [
+        "desktop-app-vue/src/renderer/shell/CommandPalette.vue",
+        "desktop-app-vue/src/renderer/utils/globalSearchManager.ts",
+      ],
+    },
+  },
+});
+
+export const PUBLIC_IDE_MANIFEST_OUTPUT =
+  "docs/cli/PUBLIC_IDE_CAPABILITY_MANIFEST.generated.json";
+
+export const README_BLOCK_START =
+  "<!-- chainlesschain-public-ide-capabilities:start -->";
+export const README_BLOCK_END =
+  "<!-- chainlesschain-public-ide-capabilities:end -->";
+
+export function renderPublicIdeCapabilityManifest(
+  manifest = PUBLIC_IDE_CAPABILITY_MANIFEST,
+) {
+  return `${JSON.stringify(
+    {
+      _generated:
+        "packages/cli/scripts/gen-public-ide-capability-manifest.mjs - do not edit by hand",
+      ...manifest,
+    },
+    null,
+    2,
+  )}\n`;
+}
+
+export function renderPublicIdeReadmeBlock(
+  host,
+  manifest = PUBLIC_IDE_CAPABILITY_MANIFEST,
+) {
+  const surface = manifest.surfaces[host];
+  if (!surface || (host !== "vscode" && host !== "jetbrains")) {
+    throw new Error(`Unsupported README host: ${host}`);
+  }
+  const entries = host === "vscode" ? surface.commands : surface.actions;
+  const entryLabel =
+    host === "vscode" ? "VS Code commands" : "JetBrains actions";
+  const doctorEntries =
+    host === "vscode" ? surface.doctorCommands : surface.doctorActions;
+  const lines = [
+    README_BLOCK_START,
+    "",
+    "## Public capability contract (generated)",
+    "",
+    "This summary is pinned to the repository's versioned, secret-free",
+    "[`PUBLIC_IDE_CAPABILITY_MANIFEST.generated.json`](../../docs/cli/PUBLIC_IDE_CAPABILITY_MANIFEST.generated.json).",
+    `The base IDE/Doctor contract requires \`cc >= ${manifest.minimumCliVersion}\`; feature-specific sections below may require a newer CLI.`,
+    "",
+    `- ${entryLabel}: **${entries.length}** registered entries`,
+    `- Doctor entries: ${doctorEntries.map((id) => `\`${id}\``).join(", ")}`,
+    `- Bridge capability schema: **v${manifest.bridge.schemaVersion}** (${manifest.bridge.toolFeatures.length} mapped tools)`,
+    "- Drift check: `npm run ide:capabilities:check` from the repository root",
+    "",
+    `<details><summary>${entryLabel}</summary>`,
+    "",
+    ...entries.map((id) => `- \`${id}\``),
+    "",
+    "</details>",
+    README_BLOCK_END,
+  ];
+  return `${lines.join("\n")}\n`;
+}