@ghl-ai/aw 0.1.51 → 0.1.52

package/integrations/context-mode.mjs

@@ -1,4 +1,4 @@
-import { accessSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { accessSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { constants as fsConstants } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { delimiter, dirname, join } from 'node:path';
@@ -7,6 +7,14 @@ import TOML from '@iarna/toml';
 
 const INTEGRATION_NAME = 'context-mode';
 const BINARY_NAME = 'context-mode';
+const INSTALL_STATE_RELATIVE_PATH = ['.aw', 'context-mode-install-state.json'];
+const INSTALL_STATE_VERSION = 1;
+const CONTEXT_MODE_MCP_SERVER = { command: BINARY_NAME };
+const MCP_TARGETS = {
+  codex: 'codex-config-toml',
+  cursor: 'cursor-mcp-json',
+  claude: 'claude-json',
+};
 
 const CODEX_HOOK_COMMANDS = {
   PreToolUse: 'context-mode hook codex pretooluse',
@@ -17,12 +25,41 @@ const CODEX_HOOK_COMMANDS = {
   Stop: 'context-mode hook codex stop',
 };
 
-const CURSOR_HOOK_COMMANDS = {
-  preToolUse: 'context-mode hook cursor pretooluse',
-  postToolUse: 'context-mode hook cursor posttooluse',
-  stop: 'context-mode hook cursor stop',
+const CODEX_PRE_TOOL_MATCHER = [
+  'local_shell',
+  'shell',
+  'shell_command',
+  'exec_command',
+  'Bash',
+  'Shell',
+  'apply_patch',
+  'Edit',
+  'Write',
+  'grep_files',
+  'ctx_execute',
+  'ctx_execute_file',
+  'ctx_batch_execute',
+  'ctx_fetch_and_index',
+  'ctx_search',
+  'ctx_index',
+  'mcp__',
+].join('|');
+
+const CODEX_HOOK_MATCHERS = {
+  PreToolUse: CODEX_PRE_TOOL_MATCHER,
+  PostToolUse: '*',
+  SessionStart: 'startup|resume',
 };
 
+const CURSOR_HOOK_COMMANDS = [
+  { event: 'beforeShellExecution', command: 'context-mode hook cursor pretooluse' },
+  { event: 'beforeMCPExecution', command: 'context-mode hook cursor pretooluse' },
+  { event: 'afterShellExecution', command: 'context-mode hook cursor posttooluse' },
+  { event: 'afterFileEdit', command: 'context-mode hook cursor posttooluse' },
+  { event: 'afterMCPExecution', command: 'context-mode hook cursor posttooluse' },
+  { event: 'stop', command: 'context-mode hook cursor stop' },
+];
+
 function truthy(value) {
   return ['1', 'true', 'yes', 'on'].includes(String(value || '').trim().toLowerCase());
 }
@@ -55,6 +92,60 @@ function cloneJson(value) {
   return JSON.parse(JSON.stringify(value ?? {}));
 }
 
+function contextModeInstallStatePath(home) {
+  return join(home, ...INSTALL_STATE_RELATIVE_PATH);
+}
+
+function emptyInstallState() {
+  return { version: INSTALL_STATE_VERSION, mcpServers: [] };
+}
+
+function normalizeInstallState(value) {
+  const state = value && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : {};
+  return {
+    version: INSTALL_STATE_VERSION,
+    mcpServers: Array.isArray(state.mcpServers)
+      ? unique(state.mcpServers.filter(item => typeof item === 'string')).sort()
+      : [],
+  };
+}
+
+function readInstallState(home) {
+  const filePath = contextModeInstallStatePath(home);
+  if (!existsSync(filePath)) return emptyInstallState();
+  return normalizeInstallState(readJson(filePath, emptyInstallState()));
+}
+
+function writeInstallStateIfChanged(home, state, dryRun = false) {
+  const filePath = contextModeInstallStatePath(home);
+  const nextState = normalizeInstallState(state);
+  if (nextState.mcpServers.length === 0) {
+    if (!existsSync(filePath)) return false;
+    if (!dryRun) rmSync(filePath, { force: true });
+    return true;
+  }
+
+  return writeJsonIfChanged(filePath, nextState, dryRun);
+}
+
+function ownsMcpTarget(installState, target) {
+  return installState.mcpServers.includes(target);
+}
+
+function markMcpTargetOwned(installState, target) {
+  installState.mcpServers = unique([...installState.mcpServers, target]).sort();
+}
+
+function unmarkMcpTargetOwned(installState, target) {
+  installState.mcpServers = installState.mcpServers.filter(item => item !== target);
+}
+
+function isDesiredMcpServer(value) {
+  return JSON.stringify(value) === JSON.stringify(CONTEXT_MODE_MCP_SERVER);
+}
+
 function parseTomlConfig(filePath, warnings) {
   if (!existsSync(filePath)) return {};
   try {
@@ -102,6 +193,31 @@ function isContextModeCommand(command) {
   return String(command || '').startsWith('context-mode hook ');
 }
 
+function hasHookCommand(entry, command) {
+  return Array.isArray(entry?.hooks)
+    && entry.hooks.some(hook => hook?.command === command);
+}
+
+function hasCanonicalCodexMatcher(entry, phase) {
+  const expectedMatcher = CODEX_HOOK_MATCHERS[phase];
+  return expectedMatcher === undefined
+    ? entry?.matcher === undefined
+    : entry?.matcher === expectedMatcher;
+}
+
+function isCanonicalCodexHookEntry(entry, phase, command) {
+  return hasCanonicalCodexMatcher(entry, phase) && hasHookCommand(entry, command);
+}
+
+function buildCodexHookEntry(phase, command) {
+  const entry = {
+    hooks: [{ type: 'command', command }],
+  };
+  const matcher = CODEX_HOOK_MATCHERS[phase];
+  if (matcher !== undefined) entry.matcher = matcher;
+  return entry;
+}
+
 function ensureObject(parent, key) {
   if (!parent[key] || typeof parent[key] !== 'object' || Array.isArray(parent[key])) {
     parent[key] = {};
@@ -109,7 +225,7 @@ function ensureObject(parent, key) {
   return parent[key];
 }
 
-function mergeJsonMcpServer(filePath, dryRun = false) {
+function mergeJsonMcpServer(filePath, installState, target, dryRun = false) {
   const config = readJson(filePath, {});
   if (!config || typeof config !== 'object' || Array.isArray(config)) {
     throw new Error(`Expected JSON object in ${filePath}`);
@@ -117,26 +233,47 @@ function mergeJsonMcpServer(filePath, dryRun = false) {
 
   const mcpServers = ensureObject(config, 'mcpServers');
   const existing = mcpServers[INTEGRATION_NAME];
-  const desired = { command: BINARY_NAME };
-  if (JSON.stringify(existing) === JSON.stringify(desired)) return false;
+  if (existing && !isDesiredMcpServer(existing)) {
+    throw new Error('Refusing to overwrite existing user-owned context-mode MCP config');
+  }
+  if (existing) return false;
 
-  mcpServers[INTEGRATION_NAME] = desired;
+  mcpServers[INTEGRATION_NAME] = cloneJson(CONTEXT_MODE_MCP_SERVER);
+  markMcpTargetOwned(installState, target);
   return writeJsonIfChanged(filePath, config, dryRun);
 }
 
-function removeJsonMcpServer(filePath, dryRun = false) {
-  if (!existsSync(filePath)) return false;
+function removeJsonMcpServer(filePath, installState, target, warnings, dryRun = false) {
+  if (!ownsMcpTarget(installState, target)) return false;
+  if (!existsSync(filePath)) {
+    unmarkMcpTargetOwned(installState, target);
+    return false;
+  }
   const config = readJson(filePath, {});
-  if (!config?.mcpServers?.[INTEGRATION_NAME]) return false;
+  const existing = config?.mcpServers?.[INTEGRATION_NAME];
+  if (!existing) {
+    unmarkMcpTargetOwned(installState, target);
+    return false;
+  }
+  if (!isDesiredMcpServer(existing)) {
+    warnings.push(`Preserved user-modified context-mode MCP config at ${filePath}`);
+    unmarkMcpTargetOwned(installState, target);
+    return false;
+  }
 
   delete config.mcpServers[INTEGRATION_NAME];
   if (Object.keys(config.mcpServers).length === 0) delete config.mcpServers;
+  unmarkMcpTargetOwned(installState, target);
   return writeJsonIfChanged(filePath, config, dryRun);
 }
 
-function mergeCodexToml(filePath, warnings, dryRun = false) {
+function mergeCodexToml(filePath, warnings, installState, target, dryRun = false) {
   const config = parseTomlConfig(filePath, warnings);
   if (config === null) return false;
+  const existing = config.mcp_servers?.[INTEGRATION_NAME];
+  if (existing && !isDesiredMcpServer(existing)) {
+    throw new Error('Refusing to overwrite existing user-owned context-mode MCP config');
+  }
 
   const before = JSON.stringify(config);
   config.features = config.features && typeof config.features === 'object' && !Array.isArray(config.features)
@@ -148,20 +285,37 @@ function mergeCodexToml(filePath, warnings, dryRun = false) {
   config.mcp_servers = config.mcp_servers && typeof config.mcp_servers === 'object' && !Array.isArray(config.mcp_servers)
     ? config.mcp_servers
     : {};
-  config.mcp_servers[INTEGRATION_NAME] = { command: BINARY_NAME };
+  if (!existing) {
+    config.mcp_servers[INTEGRATION_NAME] = cloneJson(CONTEXT_MODE_MCP_SERVER);
+    markMcpTargetOwned(installState, target);
+  }
 
   if (JSON.stringify(config) === before) return false;
   return writeTomlIfChanged(filePath, config, dryRun);
 }
 
-function removeCodexToml(filePath, warnings, dryRun = false) {
-  if (!existsSync(filePath)) return false;
+function removeCodexToml(filePath, warnings, installState, target, dryRun = false) {
+  if (!ownsMcpTarget(installState, target)) return false;
+  if (!existsSync(filePath)) {
+    unmarkMcpTargetOwned(installState, target);
+    return false;
+  }
   const config = parseTomlConfig(filePath, warnings);
   if (config === null) return false;
-  if (!config.mcp_servers?.[INTEGRATION_NAME]) return false;
+  const existing = config.mcp_servers?.[INTEGRATION_NAME];
+  if (!existing) {
+    unmarkMcpTargetOwned(installState, target);
+    return false;
+  }
+  if (!isDesiredMcpServer(existing)) {
+    warnings.push(`Preserved user-modified context-mode MCP config at ${filePath}`);
+    unmarkMcpTargetOwned(installState, target);
+    return false;
+  }
 
   delete config.mcp_servers[INTEGRATION_NAME];
   if (Object.keys(config.mcp_servers).length === 0) delete config.mcp_servers;
+  unmarkMcpTargetOwned(installState, target);
   return writeTomlIfChanged(filePath, config, dryRun);
 }
 
@@ -170,23 +324,23 @@ function ensureCodexHook(config, phase, command) {
     ? config.hooks
     : {};
   const entries = Array.isArray(config.hooks[phase]) ? config.hooks[phase] : [];
-  if (entries.some(entry => Array.isArray(entry?.hooks) && entry.hooks.some(hook => hook?.command === command))) {
-    config.hooks[phase] = entries;
-    return false;
-  }
+  const before = JSON.stringify(entries);
+  const nextEntries = [];
 
-  const target = entries.find(entry => Array.isArray(entry?.hooks));
-  const hook = { type: 'command', command };
-  if (target) {
-    target.hooks.push(hook);
-  } else {
-    const entry = { hooks: [hook] };
-    if (phase === 'SessionStart') entry.matcher = 'startup|resume';
-    if (phase === 'PreToolUse' || phase === 'PostToolUse') entry.matcher = '*';
-    entries.push(entry);
+  for (const entry of entries) {
+    if (!Array.isArray(entry?.hooks)) {
+      nextEntries.push(entry);
+      continue;
+    }
+
+    const nextHooks = entry.hooks.filter(hook => hook?.command !== command);
+    if (nextHooks.length === 0) continue;
+    nextEntries.push(nextHooks.length === entry.hooks.length ? entry : { ...entry, hooks: nextHooks });
   }
-  config.hooks[phase] = entries;
-  return true;
+
+  nextEntries.push(buildCodexHookEntry(phase, command));
+  config.hooks[phase] = nextEntries;
+  return JSON.stringify(nextEntries) !== before;
 }
 
 function mergeCodexHooks(filePath, dryRun = false) {
@@ -229,18 +383,13 @@ function removeCodexHooks(filePath, dryRun = false) {
   return writeJsonIfChanged(filePath, config, dryRun);
 }
 
-function ensureCursorHook(config, phase, command) {
+function ensureCursorHook(config, event, command) {
   config.hooks = config.hooks && typeof config.hooks === 'object' && !Array.isArray(config.hooks)
     ? config.hooks
     : {};
-  const entries = Array.isArray(config.hooks[phase]) ? config.hooks[phase] : [];
-  if (entries.some(entry => entry?.command === command)) {
-    config.hooks[phase] = entries;
-    return false;
-  }
-  entries.push({ command });
-  config.hooks[phase] = entries;
-  return true;
+  const entries = Array.isArray(config.hooks[event]) ? config.hooks[event] : [];
+  entries.push({ command, event });
+  config.hooks[event] = entries;
 }
 
 function mergeCursorHooks(filePath, dryRun = false) {
@@ -252,12 +401,24 @@ function mergeCursorHooks(filePath, dryRun = false) {
   let changed = false;
   if (config.version === undefined) {
     config.version = 1;
-    changed = true;
   }
-  for (const [phase, command] of Object.entries(CURSOR_HOOK_COMMANDS)) {
-    changed = ensureCursorHook(config, phase, command) || changed;
+  config.hooks = config.hooks && typeof config.hooks === 'object' && !Array.isArray(config.hooks)
+    ? config.hooks
+    : {};
+
+  for (const phase of Object.keys(config.hooks)) {
+    if (!Array.isArray(config.hooks[phase])) continue;
+    const nextEntries = config.hooks[phase].filter(entry => !isContextModeCommand(entry?.command));
+    if (nextEntries.length > 0) config.hooks[phase] = nextEntries;
+    else delete config.hooks[phase];
   }
-  return changed && writeJsonIfChanged(filePath, config, dryRun);
+
+  for (const { event, command } of CURSOR_HOOK_COMMANDS) {
+    ensureCursorHook(config, event, command);
+  }
+
+  changed = writeJsonIfChanged(filePath, config, dryRun);
+  return changed;
 }
 
 function runConfigMutation(label, filePath, mutate, warnings) {
@@ -313,9 +474,7 @@ function hasCodexHookCoverage(filePath) {
     const config = readJson(filePath, {});
     return Object.entries(CODEX_HOOK_COMMANDS).every(([phase, command]) =>
       Array.isArray(config.hooks?.[phase])
-      && config.hooks[phase].some(entry =>
-        Array.isArray(entry?.hooks) && entry.hooks.some(hook => hook?.command === command)
-      )
+      && config.hooks[phase].some(entry => isCanonicalCodexHookEntry(entry, phase, command))
     );
   } catch {
     return false;
@@ -326,9 +485,9 @@ function hasCursorHookCoverage(filePath) {
   if (!existsSync(filePath)) return false;
   try {
     const config = readJson(filePath, {});
-    return Object.entries(CURSOR_HOOK_COMMANDS).every(([phase, command]) =>
-      Array.isArray(config.hooks?.[phase])
-      && config.hooks[phase].some(entry => entry?.command === command)
+    return CURSOR_HOOK_COMMANDS.every(({ event, command }) =>
+      Array.isArray(config.hooks?.[event])
+      && config.hooks[event].some(entry => entry?.command === command && entry?.event === event)
     );
   } catch {
     return false;
@@ -384,6 +543,17 @@ export function detectContextModeBinary(options = {}) {
   });
   const versionOutput = `${versionResult.stdout || ''}${versionResult.stderr || ''}`.trim();
 
+  if (versionResult.error || versionResult.status !== 0 || versionResult.signal) {
+    return {
+      present: false,
+      path: binaryPath,
+      version: null,
+      reason: versionOutput
+        || versionResult.error?.message
+        || (versionResult.signal ? `--version terminated by ${versionResult.signal}` : `--version exited with status ${versionResult.status ?? 'unknown'}`),
+    };
+  }
+
   return {
     present: true,
     path: binaryPath,
@@ -398,6 +568,7 @@ export function ensureContextModeIntegration(home, options = {}) {
   const warnings = [];
   const changedFiles = [];
   const configuredHarnesses = [];
+  const installState = readInstallState(home);
   const binary = detectContextModeBinary({ env });
 
   if (!binary.present) {
@@ -411,11 +582,11 @@ export function ensureContextModeIntegration(home, options = {}) {
   }
 
   const updates = [
-    ['Codex MCP', join(home, '.codex', 'config.toml'), () => mergeCodexToml(join(home, '.codex', 'config.toml'), warnings, dryRun)],
+    ['Codex MCP', join(home, '.codex', 'config.toml'), () => mergeCodexToml(join(home, '.codex', 'config.toml'), warnings, installState, MCP_TARGETS.codex, dryRun)],
     ['Codex hooks', join(home, '.codex', 'hooks.json'), () => mergeCodexHooks(join(home, '.codex', 'hooks.json'), dryRun)],
-    ['Cursor MCP', join(home, '.cursor', 'mcp.json'), () => mergeJsonMcpServer(join(home, '.cursor', 'mcp.json'), dryRun)],
+    ['Cursor MCP', join(home, '.cursor', 'mcp.json'), () => mergeJsonMcpServer(join(home, '.cursor', 'mcp.json'), installState, MCP_TARGETS.cursor, dryRun)],
     ['Cursor hooks', join(home, '.cursor', 'hooks.json'), () => mergeCursorHooks(join(home, '.cursor', 'hooks.json'), dryRun)],
-    ['Claude MCP', join(home, '.claude.json'), () => mergeJsonMcpServer(join(home, '.claude.json'), dryRun)],
+    ['Claude MCP', join(home, '.claude.json'), () => mergeJsonMcpServer(join(home, '.claude.json'), installState, MCP_TARGETS.claude, dryRun)],
   ];
 
   for (const [label, filePath, update] of updates) {
@@ -424,6 +595,10 @@ export function ensureContextModeIntegration(home, options = {}) {
       configuredHarnesses.push(label);
     }
   }
+  const statePath = contextModeInstallStatePath(home);
+  if (writeInstallStateIfChanged(home, installState, dryRun)) {
+    changedFiles.push(statePath);
+  }
 
   return {
     changedFiles: unique(changedFiles),
@@ -438,18 +613,23 @@ export function removeContextModeIntegration(home, options = {}) {
   const dryRun = options.dryRun === true;
   const warnings = [];
   const changedFiles = [];
+  const installState = readInstallState(home);
 
   const removals = [
-    ['Codex MCP', join(home, '.codex', 'config.toml'), () => removeCodexToml(join(home, '.codex', 'config.toml'), warnings, dryRun)],
+    ['Codex MCP', join(home, '.codex', 'config.toml'), () => removeCodexToml(join(home, '.codex', 'config.toml'), warnings, installState, MCP_TARGETS.codex, dryRun)],
     ['Codex hooks', join(home, '.codex', 'hooks.json'), () => removeCodexHooks(join(home, '.codex', 'hooks.json'), dryRun)],
-    ['Cursor MCP', join(home, '.cursor', 'mcp.json'), () => removeJsonMcpServer(join(home, '.cursor', 'mcp.json'), dryRun)],
+    ['Cursor MCP', join(home, '.cursor', 'mcp.json'), () => removeJsonMcpServer(join(home, '.cursor', 'mcp.json'), installState, MCP_TARGETS.cursor, warnings, dryRun)],
     ['Cursor hooks', join(home, '.cursor', 'hooks.json'), () => removeCursorHooks(join(home, '.cursor', 'hooks.json'), dryRun)],
-    ['Claude MCP', join(home, '.claude.json'), () => removeJsonMcpServer(join(home, '.claude.json'), dryRun)],
+    ['Claude MCP', join(home, '.claude.json'), () => removeJsonMcpServer(join(home, '.claude.json'), installState, MCP_TARGETS.claude, warnings, dryRun)],
   ];
 
   for (const [label, filePath, remove] of removals) {
     if (runConfigMutation(label, filePath, remove, warnings)) changedFiles.push(filePath);
   }
+  const statePath = contextModeInstallStatePath(home);
+  if (writeInstallStateIfChanged(home, installState, dryRun)) {
+    changedFiles.push(statePath);
+  }
 
   return {
     changedFiles: unique(changedFiles),