context-mode 1.0.111 → 1.0.113

package/build/util/claude-config.js

@@ -0,0 +1,91 @@
+/**
+ * Claude Code config directory resolver — single source of truth.
+ *
+ * Issue #460 follow-up: every Claude-aware reader (adapters, security policy
+ * loader, hook helpers) MUST agree on where global settings live. Hardcoding
+ * `~/.claude` in any one reader silently breaks `CLAUDE_CONFIG_DIR` for that
+ * code path, producing policy drift that is invisible until a user sets the
+ * env var and watches their settings get ignored.
+ *
+ * Mirrors the contract of `hooks/session-helpers.mjs::resolveConfigDir` and
+ * `ClaudeCodeAdapter.getConfigDir`:
+ *   - env unset, empty string, or whitespace-only → ~/.claude
+ *   - env starts with `~`, `~/`, or `~\` → expanded against homedir()
+ *   - otherwise → resolved to absolute (relative paths anchor to cwd)
+ *
+ * Whitespace guard: shells that quote-pad the env value (`CLAUDE_CONFIG_DIR=" "`)
+ * would otherwise resolve to `cwd/<spaces>` — silently writing settings into
+ * the project tree. Trim before the truthy check so quote-padding falls back
+ * to `~/.claude` like a sane default.
+ *
+ * Cross-platform note: tilde regex strips a single leading `/` OR `\` so
+ * `~\Users\foo` works on Windows. `path.resolve` handles drive-letter joining.
+ */
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { createRequire } from "node:module";
+export function resolveClaudeConfigDir(env = process.env) {
+    const envVal = env.CLAUDE_CONFIG_DIR;
+    if (envVal && envVal.trim() !== "") {
+        if (envVal.startsWith("~")) {
+            return resolve(homedir(), envVal.replace(/^~[/\\]?/, ""));
+        }
+        return resolve(envVal);
+    }
+    return resolve(homedir(), ".claude");
+}
+/** Resolve the global settings.json path, honoring CLAUDE_CONFIG_DIR. */
+export function resolveClaudeGlobalSettingsPath(env = process.env) {
+    return resolve(resolveClaudeConfigDir(env), "settings.json");
+}
+/**
+ * Issue #451 round-3: cross-adapter deny-policy parity.
+ *
+ * `resolveClaudeGlobalSettingsPath` hardcodes the `.claude` segment, so
+ * non-Claude adapters (cursor, codex, qwen-code, gemini-cli, jetbrains-copilot,
+ * vscode-copilot, etc.) never had their global settings consulted by the
+ * security policy reader. This helper returns the union of:
+ *
+ *   1. The currently-detected adapter's home-rooted settings.json (when the
+ *      adapter is non-claude — claude is already covered by entry 2).
+ *   2. The claude global settings.json (always — defense in depth).
+ *
+ * Lazy import of `./adapters/detect.js` keeps this file free of any direct
+ * adapter dependency: the detect module itself only `import type`s adapter
+ * types at the top level (concrete adapters are loaded dynamically inside
+ * `getAdapter()`), so a static import is safe — but we use `createRequire`
+ * to make the dependency direction crystal clear and to avoid surprising
+ * future maintainers who add eager adapter imports to detect.ts.
+ *
+ * The returned array is deduplicated and order-stable: adapter-specific path
+ * first (most specific), claude global second (fallback).
+ */
+export function resolveAdapterGlobalSettingsPaths(env = process.env) {
+    const paths = [];
+    // Lazy-load detect module to avoid any chance of an adapter import cycle.
+    // `detect.ts` exports pure functions — `detectPlatform` (env-driven) and
+    // `getSessionDirSegments` (sync map). Neither instantiates an adapter.
+    let detected = null;
+    let segmentsFor = null;
+    try {
+        const lazyRequire = createRequire(import.meta.url);
+        const detect = lazyRequire("../adapters/detect.js");
+        detected = detect.detectPlatform();
+        segmentsFor = detect.getSessionDirSegments;
+    }
+    catch {
+        // If detection fails for any reason, fall back to claude-only behavior.
+    }
+    if (detected && segmentsFor && detected.platform !== "claude-code") {
+        const segments = segmentsFor(detected.platform);
+        if (segments && segments.length > 0) {
+            paths.push(resolve(homedir(), ...segments, "settings.json"));
+        }
+    }
+    // Always include claude global as fallback (defense in depth).
+    const claudePath = resolveClaudeGlobalSettingsPath(env);
+    if (!paths.includes(claudePath)) {
+        paths.push(claudePath);
+    }
+    return paths;
+}

package/build/util/hook-config.d.ts

@@ -0,0 +1,4 @@
+import type { HookAdapter } from "../adapters/types.js";
+export declare function getCommandsFromHookEntry(entry: unknown): string[];
+export declare function extractHookScriptPath(command: string): string | null;
+export declare function getHookScriptPaths(adapter: HookAdapter, pluginRoot: string): string[];

package/build/util/hook-config.js

@@ -0,0 +1,39 @@
+export function getCommandsFromHookEntry(entry) {
+    const commands = [];
+    if (entry && typeof entry === "object") {
+        const command = entry.command;
+        if (typeof command === "string")
+            commands.push(command);
+        const hooks = entry.hooks;
+        if (Array.isArray(hooks)) {
+            for (const hook of hooks) {
+                if (hook && typeof hook === "object") {
+                    const nestedCommand = hook.command;
+                    if (typeof nestedCommand === "string")
+                        commands.push(nestedCommand);
+                }
+            }
+        }
+    }
+    return commands;
+}
+export function extractHookScriptPath(command) {
+    const match = command.match(/(?:"([^"]+\.mjs)"|'([^']+\.mjs)'|(\S+\.mjs))/);
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+export function getHookScriptPaths(adapter, pluginRoot) {
+    const paths = new Set();
+    const hookConfig = adapter.generateHookConfig(pluginRoot);
+    for (const entries of Object.values(hookConfig)) {
+        if (!Array.isArray(entries))
+            continue;
+        for (const entry of entries) {
+            for (const command of getCommandsFromHookEntry(entry)) {
+                const scriptPath = extractHookScriptPath(command);
+                if (scriptPath)
+                    paths.add(scriptPath);
+            }
+        }
+    }
+    return [...paths];
+}

package/build/util/project-dir.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Project-dir resolution helpers — shared between `start.mjs` (the MCP entry
+ * point) and `src/server.ts getProjectDir()` (the consumer).
+ *
+ * Background: when Claude Code runs `/ctx-upgrade`, it kills + respawns the
+ * MCP server. The respawn happens with `cwd` set to the plugin install
+ * directory (`~/.claude/plugins/cache/context-mode/context-mode/<version>/`).
+ * The legacy `start.mjs` then set `CLAUDE_PROJECT_DIR = originalCwd`, which
+ * poisoned every downstream `ctx_stats` / SessionDB / hash computation —
+ * sessions silently re-rooted under the plugin install path.
+ *
+ * Defense-in-depth fix (v1.0.113):
+ *   - `start.mjs` calls `isPluginInstallPath(originalCwd)` and skips the env
+ *     auto-set when true (no poisoning at the source).
+ *   - `getProjectDir()` calls `resolveProjectDir(...)` which rejects plugin-
+ *     pathed env vars and the plugin cwd, preferring `process.env.PWD`
+ *     (shell-set, survives `process.chdir`) before falling back.
+ */
+/**
+ * Detect whether a path lives inside the Claude Code plugin install tree —
+ * specifically `<home>/.claude/plugins/cache/<plugin>/<plugin>/<version>/`
+ * or the marketplace mirror `<home>/.claude/plugins/marketplaces/...`.
+ *
+ * Cross-OS: matches both POSIX (`/`) and Windows (`\`) path separators.
+ * Independent of `home` location — we only care about the `.claude/plugins/`
+ * suffix pattern.
+ */
+export declare function isPluginInstallPath(p: string): boolean;
+/**
+ * Pure project-dir resolver. Mirror of the env-var chain inside
+ * `src/server.ts getProjectDir()`, but takes its inputs explicitly so the
+ * resolver can be exercised under test without process-level mutation.
+ *
+ * Resolution order:
+ *   1. Adapter-priority env vars (CLAUDE / GEMINI / VSCODE / OPENCODE / PI /
+ *      IDEA / CONTEXT_MODE) — first non-empty AND non-plugin-path wins.
+ *   2. `process.env.PWD` — shell-set, NOT updated by `process.chdir()`, so
+ *      it survives the `start.mjs` chdir into the plugin dir. Skipped if
+ *      it too points at a plugin install path.
+ *   3. `cwd` — last resort. Returned even if it is a plugin path; the
+ *      caller is responsible for rendering a graceful "no project context"
+ *      message rather than panicking. Keeping the function total preserves
+ *      operation of project-independent tools (sandbox execute, fetch).
+ */
+export declare function resolveProjectDir(opts: {
+    env: Record<string, string | undefined>;
+    cwd: string;
+    pwd: string | undefined;
+}): string;

package/build/util/project-dir.js

@@ -0,0 +1,67 @@
+/**
+ * Project-dir resolution helpers — shared between `start.mjs` (the MCP entry
+ * point) and `src/server.ts getProjectDir()` (the consumer).
+ *
+ * Background: when Claude Code runs `/ctx-upgrade`, it kills + respawns the
+ * MCP server. The respawn happens with `cwd` set to the plugin install
+ * directory (`~/.claude/plugins/cache/context-mode/context-mode/<version>/`).
+ * The legacy `start.mjs` then set `CLAUDE_PROJECT_DIR = originalCwd`, which
+ * poisoned every downstream `ctx_stats` / SessionDB / hash computation —
+ * sessions silently re-rooted under the plugin install path.
+ *
+ * Defense-in-depth fix (v1.0.113):
+ *   - `start.mjs` calls `isPluginInstallPath(originalCwd)` and skips the env
+ *     auto-set when true (no poisoning at the source).
+ *   - `getProjectDir()` calls `resolveProjectDir(...)` which rejects plugin-
+ *     pathed env vars and the plugin cwd, preferring `process.env.PWD`
+ *     (shell-set, survives `process.chdir`) before falling back.
+ */
+/**
+ * Detect whether a path lives inside the Claude Code plugin install tree —
+ * specifically `<home>/.claude/plugins/cache/<plugin>/<plugin>/<version>/`
+ * or the marketplace mirror `<home>/.claude/plugins/marketplaces/...`.
+ *
+ * Cross-OS: matches both POSIX (`/`) and Windows (`\`) path separators.
+ * Independent of `home` location — we only care about the `.claude/plugins/`
+ * suffix pattern.
+ */
+export function isPluginInstallPath(p) {
+    if (!p)
+        return false;
+    return /[/\\]\.claude[/\\]plugins[/\\](cache|marketplaces)[/\\]/.test(p);
+}
+/**
+ * Pure project-dir resolver. Mirror of the env-var chain inside
+ * `src/server.ts getProjectDir()`, but takes its inputs explicitly so the
+ * resolver can be exercised under test without process-level mutation.
+ *
+ * Resolution order:
+ *   1. Adapter-priority env vars (CLAUDE / GEMINI / VSCODE / OPENCODE / PI /
+ *      IDEA / CONTEXT_MODE) — first non-empty AND non-plugin-path wins.
+ *   2. `process.env.PWD` — shell-set, NOT updated by `process.chdir()`, so
+ *      it survives the `start.mjs` chdir into the plugin dir. Skipped if
+ *      it too points at a plugin install path.
+ *   3. `cwd` — last resort. Returned even if it is a plugin path; the
+ *      caller is responsible for rendering a graceful "no project context"
+ *      message rather than panicking. Keeping the function total preserves
+ *      operation of project-independent tools (sandbox execute, fetch).
+ */
+export function resolveProjectDir(opts) {
+    const { env, cwd, pwd } = opts;
+    const candidates = [
+        env.CLAUDE_PROJECT_DIR,
+        env.GEMINI_PROJECT_DIR,
+        env.VSCODE_CWD,
+        env.OPENCODE_PROJECT_DIR,
+        env.PI_PROJECT_DIR,
+        env.IDEA_INITIAL_DIRECTORY,
+        env.CONTEXT_MODE_PROJECT_DIR,
+    ];
+    for (const c of candidates) {
+        if (c && !isPluginInstallPath(c))
+            return c;
+    }
+    if (pwd && !isPluginInstallPath(pwd))
+        return pwd;
+    return cwd;
+}