context-mode 1.0.88 → 1.0.90

package/build/adapters/codex/index.js

@@ -9,21 +9,22 @@
  *   - Config: ~/.codex/hooks.json + ~/.codex/config.toml (TOML for MCP/features)
  *   - Session dir: ~/.codex/context-mode/sessions/
  *
- * IMPORTANT: Hook dispatch is NOT yet active in Codex CLI (v0.118.0).
- * codex_hooks feature flag is Stage::UnderDevelopment — hooks are implemented
- * in codex-rs/hooks/ but not wired into the tool execution pipeline.
- * Our adapter is ready; it will work once Codex enables dispatch.
- * Track: https://github.com/openai/codex/issues/16685
+ * Hook dispatch is stable in Codex CLI. PreToolUse deny decisions work,
+ * while input rewriting remains blocked on upstream updatedInput support.
+ * Track: https://github.com/openai/codex/issues/18491
  */
-import { createHash } from "node:crypto";
-import { readFileSync, mkdirSync, copyFileSync, accessSync, constants, } from "node:fs";
-import { resolve, join, dirname } from "node:path";
+import { readFileSync, } from "node:fs";
+import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
+import { BaseAdapter } from "../base.js";
 // ─────────────────────────────────────────────────────────
 // Adapter implementation
 // ─────────────────────────────────────────────────────────
-export class CodexAdapter {
+export class CodexAdapter extends BaseAdapter {
+    constructor() {
+        super([".codex"]);
+    }
     name = "Codex CLI";
     paradigm = "json-stdio";
     capabilities = {
@@ -146,30 +147,11 @@ export class CodexAdapter {
     getSettingsPath() {
         return resolve(homedir(), ".codex", "config.toml");
     }
-    getSessionDir() {
-        const dir = join(homedir(), ".codex", "context-mode", "sessions");
-        mkdirSync(dir, { recursive: true });
-        return dir;
-    }
-    getSessionDBPath(projectDir) {
-        const hash = createHash("sha256")
-            .update(projectDir)
-            .digest("hex")
-            .slice(0, 16);
-        return join(this.getSessionDir(), `${hash}.db`);
-    }
-    getSessionEventsPath(projectDir) {
-        const hash = createHash("sha256")
-            .update(projectDir)
-            .digest("hex")
-            .slice(0, 16);
-        return join(this.getSessionDir(), `${hash}-events.md`);
-    }
     generateHookConfig(pluginRoot) {
         return {
             PreToolUse: [
                 {
-                    matcher: "",
+                    matcher: "local_shell|shell|shell_command|exec_command|container.exec|Bash|Shell|grep_files|mcp__plugin_context-mode_context-mode__ctx_execute|mcp__plugin_context-mode_context-mode__ctx_execute_file|mcp__plugin_context-mode_context-mode__ctx_batch_execute",
                     hooks: [
                         {
                             type: "command",
@@ -225,8 +207,8 @@ export class CodexAdapter {
         return [
             {
                 check: "Hook support",
-                status: "warn",
-                message: "Codex CLI hooks are implemented but dispatch is not yet active (Stage::UnderDevelopment, v0.118.0). Enable flag: [features] codex_hooks = true in ~/.codex/config.toml. Track: openai/codex#16685",
+                status: "pass",
+                message: "Codex CLI hooks are stable. Configure ~/.codex/hooks.json for PreToolUse, PostToolUse, and SessionStart.",
             },
         ];
     }
@@ -275,18 +257,6 @@ export class CodexAdapter {
         // Codex CLI hook configuration is done via hooks.json, not config.toml
         return [];
     }
-    backupSettings() {
-        const settingsPath = this.getSettingsPath();
-        try {
-            accessSync(settingsPath, constants.R_OK);
-            const backupPath = settingsPath + ".bak";
-            copyFileSync(settingsPath, backupPath);
-            return backupPath;
-        }
-        catch {
-            return null;
-        }
-    }
     setHookPermissions(_pluginRoot) {
         // Hook permissions are set during plugin install
         return [];

package/build/adapters/copilot-base.d.ts

@@ -0,0 +1,78 @@
+/**
+ * CopilotBaseAdapter — shared implementation for VS Code Copilot and JetBrains Copilot.
+ *
+ * Both platforms share the SAME Copilot agent runtime:
+ *   - hookSpecificOutput wrapper with hookEventName
+ *   - Same hook events (PreToolUse, PostToolUse, PreCompact, SessionStart)
+ *   - Same .github/hooks/ config location
+ *   - Same configureHooks logic
+ *   - Same generateHookConfig format
+ *   - Same parse/format methods
+ *
+ * Platform-specific differences handled by subclasses:
+ *   - extractSessionId() — different env var fallbacks
+ *   - getProjectDir() — different env vars for project root
+ *   - getSessionDir() — different default session directories
+ *   - checkPluginRegistration() — VS Code reads .vscode/mcp.json, JetBrains uses IDE UI
+ *   - getInstalledVersion() — VS Code checks extensions dir, JetBrains checks hook config
+ *   - validateHooks() — different warning messages
+ */
+import { BaseAdapter } from "./base.js";
+import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse, HookRegistration } from "./types.js";
+export interface CopilotHookInput {
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    tool_output?: string;
+    is_error?: boolean;
+    /** Copilot uses camelCase sessionId (NOT session_id). */
+    sessionId?: string;
+    source?: string;
+}
+export interface CopilotHookModule {
+    HOOK_TYPES: {
+        readonly PRE_TOOL_USE: string;
+        readonly POST_TOOL_USE: string;
+        readonly PRE_COMPACT: string;
+        readonly SESSION_START: string;
+        readonly STOP: string;
+        readonly SUBAGENT_START: string;
+        readonly SUBAGENT_STOP: string;
+    };
+    HOOK_SCRIPTS: Record<string, string>;
+    buildHookCommand: (hookType: any, pluginRoot?: string) => string;
+}
+export declare abstract class CopilotBaseAdapter extends BaseAdapter implements HookAdapter {
+    readonly paradigm: HookParadigm;
+    readonly capabilities: PlatformCapabilities;
+    /** Subclasses must provide their platform name. */
+    abstract readonly name: string;
+    /** Subclasses must provide their hook module (HOOK_TYPES, HOOK_SCRIPTS, buildHookCommand). */
+    protected abstract readonly hookModule: CopilotHookModule;
+    /** Subclasses must provide the hook scripts subdirectory name (e.g., "vscode-copilot"). */
+    protected abstract readonly hookSubdir: string;
+    /** Extract session ID from Copilot hook input — env var fallbacks differ per platform. */
+    protected abstract extractSessionId(input: CopilotHookInput): string;
+    /** Get the project directory — env vars differ per platform. */
+    protected abstract getProjectDir(): string;
+    /** Validate that hooks are properly configured for this platform. */
+    abstract validateHooks(pluginRoot: string): DiagnosticResult[];
+    /** Check if the plugin is registered/enabled on this platform. */
+    abstract checkPluginRegistration(): DiagnosticResult;
+    /** Get the installed version from this platform's registry/marketplace. */
+    abstract getInstalledVersion(): string;
+    parsePreToolUseInput(raw: unknown): PreToolUseEvent;
+    parsePostToolUseInput(raw: unknown): PostToolUseEvent;
+    parsePreCompactInput(raw: unknown): PreCompactEvent;
+    parseSessionStartInput(raw: unknown): SessionStartEvent;
+    formatPreToolUseResponse(response: PreToolUseResponse): unknown;
+    formatPostToolUseResponse(response: PostToolUseResponse): unknown;
+    formatPreCompactResponse(response: PreCompactResponse): unknown;
+    formatSessionStartResponse(response: SessionStartResponse): unknown;
+    getSettingsPath(): string;
+    generateHookConfig(pluginRoot: string): HookRegistration;
+    readSettings(): Record<string, unknown> | null;
+    writeSettings(settings: Record<string, unknown>): void;
+    configureAllHooks(pluginRoot: string): string[];
+    setHookPermissions(pluginRoot: string): string[];
+    updatePluginRegistry(_pluginRoot: string, _version: string): void;
+}

package/build/adapters/copilot-base.js

@@ -0,0 +1,281 @@
+/**
+ * CopilotBaseAdapter — shared implementation for VS Code Copilot and JetBrains Copilot.
+ *
+ * Both platforms share the SAME Copilot agent runtime:
+ *   - hookSpecificOutput wrapper with hookEventName
+ *   - Same hook events (PreToolUse, PostToolUse, PreCompact, SessionStart)
+ *   - Same .github/hooks/ config location
+ *   - Same configureHooks logic
+ *   - Same generateHookConfig format
+ *   - Same parse/format methods
+ *
+ * Platform-specific differences handled by subclasses:
+ *   - extractSessionId() — different env var fallbacks
+ *   - getProjectDir() — different env vars for project root
+ *   - getSessionDir() — different default session directories
+ *   - checkPluginRegistration() — VS Code reads .vscode/mcp.json, JetBrains uses IDE UI
+ *   - getInstalledVersion() — VS Code checks extensions dir, JetBrains checks hook config
+ *   - validateHooks() — different warning messages
+ */
+import { readFileSync, writeFileSync, mkdirSync, accessSync, chmodSync, constants, } from "node:fs";
+import { resolve, join } from "node:path";
+import { BaseAdapter } from "./base.js";
+// ─────────────────────────────────────────────────────────
+// Abstract base adapter for Copilot platforms
+// ─────────────────────────────────────────────────────────
+export class CopilotBaseAdapter extends BaseAdapter {
+    paradigm = "json-stdio";
+    capabilities = {
+        preToolUse: true,
+        postToolUse: true,
+        preCompact: true,
+        sessionStart: true,
+        canModifyArgs: true,
+        canModifyOutput: true,
+        canInjectSessionContext: true,
+    };
+    // ── Input parsing (shared) ─────────────────────────────
+    parsePreToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? "",
+            toolInput: input.tool_input ?? {},
+            sessionId: this.extractSessionId(input),
+            projectDir: this.getProjectDir(),
+            raw,
+        };
+    }
+    parsePostToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? "",
+            toolInput: input.tool_input ?? {},
+            toolOutput: input.tool_output,
+            isError: input.is_error,
+            sessionId: this.extractSessionId(input),
+            projectDir: this.getProjectDir(),
+            raw,
+        };
+    }
+    parsePreCompactInput(raw) {
+        const input = raw;
+        return {
+            sessionId: this.extractSessionId(input),
+            projectDir: this.getProjectDir(),
+            raw,
+        };
+    }
+    parseSessionStartInput(raw) {
+        const input = raw;
+        const rawSource = input.source ?? "startup";
+        let source;
+        switch (rawSource) {
+            case "compact":
+                source = "compact";
+                break;
+            case "resume":
+                source = "resume";
+                break;
+            case "clear":
+                source = "clear";
+                break;
+            default:
+                source = "startup";
+        }
+        return {
+            sessionId: this.extractSessionId(input),
+            source,
+            projectDir: this.getProjectDir(),
+            raw,
+        };
+    }
+    // ── Response formatting (shared) ───────────────────────
+    formatPreToolUseResponse(response) {
+        if (response.decision === "deny") {
+            return {
+                permissionDecision: "deny",
+                reason: response.reason ?? "Blocked by context-mode hook",
+            };
+        }
+        if (response.decision === "modify" && response.updatedInput) {
+            return {
+                hookSpecificOutput: {
+                    hookEventName: this.hookModule.HOOK_TYPES.PRE_TOOL_USE,
+                    updatedInput: response.updatedInput,
+                },
+            };
+        }
+        if (response.decision === "context" && response.additionalContext) {
+            return {
+                hookSpecificOutput: {
+                    hookEventName: this.hookModule.HOOK_TYPES.PRE_TOOL_USE,
+                    additionalContext: response.additionalContext,
+                },
+            };
+        }
+        if (response.decision === "ask") {
+            return {
+                permissionDecision: "deny",
+                reason: response.reason ?? "Action requires user confirmation (security policy)",
+            };
+        }
+        // "allow" — return undefined for passthrough
+        return undefined;
+    }
+    formatPostToolUseResponse(response) {
+        if (response.updatedOutput) {
+            return {
+                hookSpecificOutput: {
+                    hookEventName: this.hookModule.HOOK_TYPES.POST_TOOL_USE,
+                    decision: "block",
+                    reason: response.updatedOutput,
+                },
+            };
+        }
+        if (response.additionalContext) {
+            return {
+                hookSpecificOutput: {
+                    hookEventName: this.hookModule.HOOK_TYPES.POST_TOOL_USE,
+                    additionalContext: response.additionalContext,
+                },
+            };
+        }
+        return undefined;
+    }
+    formatPreCompactResponse(response) {
+        return response.context ?? "";
+    }
+    formatSessionStartResponse(response) {
+        return response.context ?? "";
+    }
+    // ── Configuration (shared) ─────────────────────────────
+    getSettingsPath() {
+        return resolve(".github", "hooks", "context-mode.json");
+    }
+    generateHookConfig(pluginRoot) {
+        const { HOOK_TYPES, buildHookCommand } = this.hookModule;
+        return {
+            [HOOK_TYPES.PRE_TOOL_USE]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand(HOOK_TYPES.PRE_TOOL_USE, pluginRoot),
+                        },
+                    ],
+                },
+            ],
+            [HOOK_TYPES.POST_TOOL_USE]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand(HOOK_TYPES.POST_TOOL_USE, pluginRoot),
+                        },
+                    ],
+                },
+            ],
+            [HOOK_TYPES.PRE_COMPACT]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand(HOOK_TYPES.PRE_COMPACT, pluginRoot),
+                        },
+                    ],
+                },
+            ],
+            [HOOK_TYPES.SESSION_START]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand(HOOK_TYPES.SESSION_START, pluginRoot),
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    readSettings() {
+        // Primary: .github/hooks/context-mode.json
+        try {
+            const raw = readFileSync(this.getSettingsPath(), "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            /* fall through */
+        }
+        // Fallback: .claude/settings.json
+        try {
+            const raw = readFileSync(resolve(".claude", "settings.json"), "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    writeSettings(settings) {
+        const configPath = this.getSettingsPath();
+        mkdirSync(resolve(".github", "hooks"), { recursive: true });
+        writeFileSync(configPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    }
+    // ── Upgrade (shared) ──────────────────────────────────
+    configureAllHooks(pluginRoot) {
+        const changes = [];
+        const settings = this.readSettings() ?? {};
+        const hooks = settings.hooks ?? {};
+        const { HOOK_TYPES, HOOK_SCRIPTS, buildHookCommand } = this.hookModule;
+        const hookTypes = [
+            HOOK_TYPES.PRE_TOOL_USE,
+            HOOK_TYPES.POST_TOOL_USE,
+            HOOK_TYPES.PRE_COMPACT,
+            HOOK_TYPES.SESSION_START,
+        ];
+        for (const hookType of hookTypes) {
+            const script = HOOK_SCRIPTS[hookType];
+            if (!script)
+                continue;
+            hooks[hookType] = [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand(hookType, pluginRoot),
+                        },
+                    ],
+                },
+            ];
+            changes.push(`Configured ${hookType} hook`);
+        }
+        settings.hooks = hooks;
+        this.writeSettings(settings);
+        changes.push(`Wrote hook config to ${this.getSettingsPath()}`);
+        return changes;
+    }
+    setHookPermissions(pluginRoot) {
+        const set = [];
+        const hooksDir = join(pluginRoot, "hooks", this.hookSubdir);
+        for (const scriptName of Object.values(this.hookModule.HOOK_SCRIPTS)) {
+            const scriptPath = resolve(hooksDir, scriptName);
+            try {
+                accessSync(scriptPath, constants.R_OK);
+                chmodSync(scriptPath, 0o755);
+                set.push(scriptPath);
+            }
+            catch {
+                /* skip missing scripts */
+            }
+        }
+        return set;
+    }
+    updatePluginRegistry(_pluginRoot, _version) {
+        // Copilot platforms manage plugins through their own marketplaces.
+        // No manual registry update needed.
+    }
+}

package/build/adapters/cursor/index.d.ts

@@ -4,6 +4,7 @@
  * Native Cursor hooks use lower-camel hook names and flat command entries in
  * `.cursor/hooks.json` / `~/.cursor/hooks.json`.
  */
+import { BaseAdapter } from "../base.js";
 import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, SessionStartResponse, HookRegistration } from "../types.js";
 interface StopEvent {
     sessionId: string;
@@ -12,7 +13,8 @@ interface StopEvent {
     generationId?: string;
     transcriptPath?: string;
 }
-export declare class CursorAdapter implements HookAdapter {
+export declare class CursorAdapter extends BaseAdapter implements HookAdapter {
+    constructor();
     readonly name = "Cursor";
     readonly paradigm: HookParadigm;
     readonly capabilities: PlatformCapabilities;
@@ -30,9 +32,6 @@ export declare class CursorAdapter implements HookAdapter {
         text: string;
     };
     getSettingsPath(): string;
-    getSessionDir(): string;
-    getSessionDBPath(projectDir: string): string;
-    getSessionEventsPath(projectDir: string): string;
     generateHookConfig(_pluginRoot: string): HookRegistration;
     readSettings(): Record<string, unknown> | null;
     writeSettings(settings: Record<string, unknown>): void;
@@ -40,7 +39,6 @@ export declare class CursorAdapter implements HookAdapter {
     checkPluginRegistration(): DiagnosticResult;
     getInstalledVersion(): string;
     configureAllHooks(_pluginRoot: string): string[];
-    backupSettings(): string | null;
     setHookPermissions(pluginRoot: string): string[];
     updatePluginRegistry(_pluginRoot: string, _version: string): void;
     private getCandidateHookConfigPaths;

package/build/adapters/cursor/index.js

@@ -4,14 +4,17 @@
  * Native Cursor hooks use lower-camel hook names and flat command entries in
  * `.cursor/hooks.json` / `~/.cursor/hooks.json`.
  */
-import { createHash } from "node:crypto";
-import { readFileSync, writeFileSync, mkdirSync, copyFileSync, accessSync, chmodSync, constants, existsSync, } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, accessSync, chmodSync, constants, existsSync, } from "node:fs";
 import { execSync } from "node:child_process";
 import { resolve, join } from "node:path";
 import { homedir } from "node:os";
+import { BaseAdapter } from "../base.js";
 import { HOOK_TYPES as CURSOR_HOOK_NAMES, HOOK_SCRIPTS as CURSOR_HOOK_SCRIPTS, PRE_TOOL_USE_MATCHER_PATTERN, REQUIRED_HOOKS, OPTIONAL_HOOKS, isContextModeHook, buildHookCommand, } from "./hooks.js";
 const CURSOR_ENTERPRISE_HOOKS_PATH = "/Library/Application Support/Cursor/hooks.json";
-export class CursorAdapter {
+export class CursorAdapter extends BaseAdapter {
+    constructor() {
+        super([".cursor"]);
+    }
     name = "Cursor";
     paradigm = "json-stdio";
     capabilities = {
@@ -125,25 +128,6 @@ export class CursorAdapter {
     getSettingsPath() {
         return resolve(".cursor", "hooks.json");
     }
-    getSessionDir() {
-        const dir = join(homedir(), ".cursor", "context-mode", "sessions");
-        mkdirSync(dir, { recursive: true });
-        return dir;
-    }
-    getSessionDBPath(projectDir) {
-        const hash = createHash("sha256")
-            .update(projectDir)
-            .digest("hex")
-            .slice(0, 16);
-        return join(this.getSessionDir(), `${hash}.db`);
-    }
-    getSessionEventsPath(projectDir) {
-        const hash = createHash("sha256")
-            .update(projectDir)
-            .digest("hex")
-            .slice(0, 16);
-        return join(this.getSessionDir(), `${hash}-events.md`);
-    }
     generateHookConfig(_pluginRoot) {
         const hooks = {
             [CURSOR_HOOK_NAMES.PRE_TOOL_USE]: [
@@ -355,18 +339,6 @@ export class CursorAdapter {
         changes.push(`Wrote native Cursor hooks to ${this.getSettingsPath()}`);
         return changes;
     }
-    backupSettings() {
-        const settingsPath = this.getSettingsPath();
-        try {
-            accessSync(settingsPath, constants.R_OK);
-            const backupPath = settingsPath + ".bak";
-            copyFileSync(settingsPath, backupPath);
-            return backupPath;
-        }
-        catch {
-            return null;
-        }
-    }
     setHookPermissions(pluginRoot) {
         const set = [];
         const hooksDir = join(pluginRoot, "hooks", "cursor");

package/build/adapters/detect.d.ts

@@ -15,8 +15,15 @@
  *   - Codex CLI:      CODEX_CI, CODEX_THREAD_ID | ~/.codex/
  *   - Cursor:         CURSOR_TRACE_ID (MCP), CURSOR_CLI (terminal) | ~/.cursor/
  *   - VS Code Copilot: VSCODE_PID, VSCODE_CWD | ~/.vscode/
+ *   - JetBrains Copilot: IDEA_INITIAL_DIRECTORY, IDEA_HOME, JETBRAINS_CLIENT_ID | ~/.config/JetBrains/
  */
 import type { PlatformId, DetectionSignal, HookAdapter } from "./types.js";
+/**
+ * High-confidence env vars per platform, checked in priority order.
+ * Single source of truth — consumed by detectPlatform() below and by
+ * tests that need to clear platform-related env vars deterministically.
+ */
+export declare const PLATFORM_ENV_VARS: readonly [readonly ["claude-code", readonly ["CLAUDE_PROJECT_DIR", "CLAUDE_SESSION_ID"]], readonly ["gemini-cli", readonly ["GEMINI_PROJECT_DIR", "GEMINI_CLI"]], readonly ["openclaw", readonly ["OPENCLAW_HOME", "OPENCLAW_CLI"]], readonly ["kilo", readonly ["KILO", "KILO_PID"]], readonly ["opencode", readonly ["OPENCODE", "OPENCODE_PID"]], readonly ["codex", readonly ["CODEX_CI", "CODEX_THREAD_ID"]], readonly ["cursor", readonly ["CURSOR_TRACE_ID", "CURSOR_CLI"]], readonly ["vscode-copilot", readonly ["VSCODE_PID", "VSCODE_CWD"]], readonly ["jetbrains-copilot", readonly ["IDEA_INITIAL_DIRECTORY", "IDEA_HOME", "JETBRAINS_CLIENT_ID"]], readonly ["qwen-code", readonly ["QWEN_PROJECT_DIR", "QWEN_SESSION_ID"]]];
 /**
  * Detect the current platform by checking env vars and config dirs.
  *