@ghl-ai/aw 0.1.50 → 0.1.52

package/mcp.mjs

@@ -1,16 +1,72 @@
 // mcp.mjs — MCP config generation for Claude Code, Cursor, and Codex (global ~/ configs)
 // Uses native Streamable HTTP — no bridge process needed.
 
-import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'node:fs';
+import { existsSync, writeFileSync, readFileSync, mkdirSync, renameSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
+import { randomBytes } from 'node:crypto';
 import * as p from '@clack/prompts';
 import * as fmt from './fmt.mjs';
 
 const HOME = homedir();
 const DEFAULT_MCP_URL = 'https://services.leadconnectorhq.com/agentic-workspace/mcp';
+const MCP_PREFS_FILENAME = 'mcp-preferences.json';
+const ENABLED_MODE = 'enabled';
+const DISABLED_MODE = 'disabled';
+const DISABLE_MCP_ENV = 'AW_DISABLE_MCP';
+const MCP_SERVER_NAME = 'ghl-ai';
+
+function mcpPrefsPath(homeDir = HOME) {
+  return join(homeDir, '.aw', MCP_PREFS_FILENAME);
+}
+
+function readJson(filePath, fallback = {}) {
+  if (!existsSync(filePath)) return fallback;
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    // Malformed or unreadable JSON should behave like an absent optional config.
+    return fallback;
+  }
+}
+
+function writeJson(filePath, value) {
+  const dir = dirname(filePath);
+  mkdirSync(dir, { recursive: true });
+  const tmpPath = join(dir, `.${randomBytes(8).toString('hex')}.tmp`);
+  writeFileSync(tmpPath, `${JSON.stringify(value, null, 2)}\n`);
+  renameSync(tmpPath, filePath);
+}
+
+function envDisablesMcp(env = process.env) {
+  const value = String(env[DISABLE_MCP_ENV] || '').trim().toLowerCase();
+  return ['1', 'true', 'yes', 'on'].includes(value);
+}
+
+export function loadMcpPreferences(homeDir = HOME) {
+  const prefs = readJson(mcpPrefsPath(homeDir), {});
+  return {
+    mode: prefs.mode === DISABLED_MODE ? DISABLED_MODE : ENABLED_MODE,
+    updatedAt: typeof prefs.updatedAt === 'string' ? prefs.updatedAt : null,
+  };
+}
+
+export function saveMcpPreferences(mode, homeDir = HOME) {
+  const normalizedMode = mode === DISABLED_MODE ? DISABLED_MODE : ENABLED_MODE;
+  const next = {
+    mode: normalizedMode,
+    updatedAt: new Date().toISOString(),
+  };
+  writeJson(mcpPrefsPath(homeDir), next);
+  return next;
+}
+
+export function isMcpEnabled(homeDir = HOME, env = process.env) {
+  if (envDisablesMcp(env)) return false;
+  return loadMcpPreferences(homeDir).mode !== DISABLED_MODE;
+}
 
 /**
  * Auto-detect MCP server paths.
@@ -250,11 +306,28 @@ async function resolveClickUpToken(silent = false, cwd = process.cwd()) {
 }
 
 /**
- * Setup MCP configs globally for Claude Code and Cursor.
+ * Setup MCP configs globally for Claude Code, Cursor, and Codex.
  * Merges ghl-ai server into existing configs without overwriting other servers.
  * Returns list of file paths that were created or updated.
  */
 export async function setupMcp(cwd, namespace, { silent = false } = {}) {
+  const prefs = loadMcpPreferences(HOME);
+  if (prefs.mode === DISABLED_MODE) {
+    const removed = removeMcpConfig();
+    if (!silent) {
+      const reason = `${fmt.chalk.dim(mcpPrefsPath(HOME).replace(HOME, '~'))} is disabled`;
+      fmt.logInfo(`MCP disabled (${reason}); removed ${removed} AW-managed MCP config file${removed === 1 ? '' : 's'}`);
+    }
+    return [];
+  }
+
+  if (envDisablesMcp()) {
+    if (!silent) {
+      fmt.logInfo(`MCP disabled (${DISABLE_MCP_ENV}=1); skipping MCP config updates`);
+    }
+    return [];
+  }
+
   const paths = detectPaths();
   const updatedFiles = [];
 
@@ -286,13 +359,13 @@ export async function setupMcp(cwd, namespace, { silent = false } = {}) {
 
   // ── Claude Code: ~/.claude.json (global) ──
   const claudeJsonPath = join(HOME, '.claude.json');
-  if (mergeJsonMcpServer(claudeJsonPath, 'ghl-ai', ghlAiServerLocal)) {
+  if (mergeJsonMcpServer(claudeJsonPath, MCP_SERVER_NAME, ghlAiServerLocal)) {
     updatedFiles.push(claudeJsonPath);
   }
 
   // ── Cursor: ~/.cursor/mcp.json (global) ──
   const cursorMcpPath = join(HOME, '.cursor', 'mcp.json');
-  if (mergeJsonMcpServer(cursorMcpPath, 'ghl-ai', ghlAiServerLocal)) {
+  if (mergeJsonMcpServer(cursorMcpPath, MCP_SERVER_NAME, ghlAiServerLocal)) {
     updatedFiles.push(cursorMcpPath);
   }
 
@@ -302,11 +375,11 @@ export async function setupMcp(cwd, namespace, { silent = false } = {}) {
   // survives — without this, each re-init overwrites ~/.codex/config.toml
   // from the ECC source which doesn't have the ghl-ai block.
   const codexTomlPath = join(HOME, '.codex', 'config.toml');
-  if (mergeTomlMcpServer(codexTomlPath, 'ghl-ai', ghlAiServerLocal)) {
+  if (mergeTomlMcpServer(codexTomlPath, MCP_SERVER_NAME, ghlAiServerLocal)) {
     updatedFiles.push(codexTomlPath);
   }
   const eccCodexTomlPath = join(HOME, '.aw-ecc', '.codex', 'config.toml');
-  mergeTomlMcpServer(eccCodexTomlPath, 'ghl-ai', ghlAiServerLocal);
+  mergeTomlMcpServer(eccCodexTomlPath, MCP_SERVER_NAME, ghlAiServerLocal);
 
   // Deduplicate
   const unique = [...new Set(updatedFiles)];
@@ -326,12 +399,6 @@ export async function setupMcp(cwd, namespace, { silent = false } = {}) {
  * Called by `aw nuke`. Returns number of files modified.
  */
 export function removeMcpConfig() {
-  const targets = [
-    join(HOME, '.claude.json'),
-    join(HOME, '.cursor', 'mcp.json'),
-  ];
-
-  // Also clean legacy locations that older versions wrote to
   const jsonTargets = [
     join(HOME, '.claude.json'),
     join(HOME, '.cursor', 'mcp.json'),
@@ -345,8 +412,8 @@ export function removeMcpConfig() {
     if (!existsSync(filePath)) continue;
     try {
       const config = JSON.parse(readFileSync(filePath, 'utf8'));
-      if (!config.mcpServers?.['ghl-ai']) continue;
-      delete config.mcpServers['ghl-ai'];
+      if (!config.mcpServers?.[MCP_SERVER_NAME]) continue;
+      delete config.mcpServers[MCP_SERVER_NAME];
       if (Object.keys(config.mcpServers).length === 0) delete config.mcpServers;
       writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n');
       removed++;
@@ -354,13 +421,62 @@ export function removeMcpConfig() {
   }
 
   // Codex: ~/.codex/config.toml (TOML format)
-  if (removeTomlMcpServer(join(HOME, '.codex', 'config.toml'), 'ghl-ai')) {
+  if (removeTomlMcpServer(join(HOME, '.codex', 'config.toml'), MCP_SERVER_NAME)) {
+    removed++;
+  }
+  if (removeTomlMcpServer(join(HOME, '.aw-ecc', '.codex', 'config.toml'), MCP_SERVER_NAME)) {
     removed++;
   }
 
   return removed;
 }
 
+function jsonMcpHealth(filePath) {
+  const server = readJson(filePath, {})?.mcpServers?.[MCP_SERVER_NAME];
+  const authorization = typeof server?.headers?.Authorization === 'string'
+    && server.headers.Authorization.trim().length > 0;
+  return {
+    path: filePath,
+    present: !!server,
+    url: typeof server?.url === 'string' && /^https?:\/\//.test(server.url),
+    authorization,
+  };
+}
+
+function tomlMcpHealth(filePath) {
+  if (!existsSync(filePath)) {
+    return { path: filePath, present: false, url: false, authorization: false };
+  }
+
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    return {
+      path: filePath,
+      present: new RegExp(`\\[mcp_servers\\.${MCP_SERVER_NAME}\\]`).test(content),
+      url: new RegExp(`\\[mcp_servers\\.${MCP_SERVER_NAME}\\][\\s\\S]*?url\\s*=\\s*"https?:\\/\\/[^"]+"`).test(content),
+      authorization: new RegExp(`\\[mcp_servers\\.${MCP_SERVER_NAME}\\.headers\\][\\s\\S]*?Authorization\\s*=\\s*".+"`).test(content),
+    };
+  } catch {
+    // Unreadable TOML should behave like an absent optional MCP config.
+    return { path: filePath, present: false, url: false, authorization: false };
+  }
+}
+
+export function getMcpStatus(homeDir = HOME, env = process.env) {
+  const prefs = loadMcpPreferences(homeDir);
+  return {
+    ...prefs,
+    effectiveMode: isMcpEnabled(homeDir, env) ? ENABLED_MODE : DISABLED_MODE,
+    envDisableMcp: envDisablesMcp(env),
+    envDisableMcpName: DISABLE_MCP_ENV,
+    preferencesPath: mcpPrefsPath(homeDir),
+    claude: jsonMcpHealth(join(homeDir, '.claude.json')),
+    cursor: jsonMcpHealth(join(homeDir, '.cursor', 'mcp.json')),
+    codex: tomlMcpHealth(join(homeDir, '.codex', 'config.toml')),
+    eccCodex: tomlMcpHealth(join(homeDir, '.aw-ecc', '.codex', 'config.toml')),
+  };
+}
+
 // ── TOML helpers for Codex ~/.codex/config.toml ───────────────────────────
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {
@@ -35,6 +35,7 @@
     "hooks/",
     "startup.mjs",
     "ecc.mjs",
+    "integrations.mjs",
     "render-rules.mjs",
     "telemetry.mjs"
   ],
@@ -52,9 +53,9 @@
   "license": "MIT",
   "scripts": {
     "test": "yarn test:vitest && yarn test:node",
-    "test:vitest": "vitest run --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4",
+    "test:vitest": "vitest run --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4 tests/integrations-graphify.test.mjs",
     "test:node": "node tests/run-node-tests.mjs",
-    "test:watch": "vitest --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4",
+    "test:watch": "vitest --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4 tests/integrations-graphify.test.mjs",
     "preuninstall": "node bin.js nuke 2>/dev/null || true"
   },
   "publishConfig": {

package/render-rules.mjs

@@ -5,6 +5,7 @@ import { dirname, join, relative } from 'node:path';
 import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
 import { RULES_RUNTIME_DIR } from './constants.mjs';
+import { isDefaultRoutingEnabled } from './startup.mjs';
 
 // The marker is placed AFTER the YAML frontmatter so Cursor/Markdown parsers
 // see the frontmatter at byte 0. Putting an HTML comment before --- breaks
@@ -212,6 +213,24 @@ function pruneStaleGeneratedRules(outputDir, expectedFilenames) {
   }
 }
 
+function defaultRoutingEnabled(options = {}) {
+  if (typeof options.defaultRoutingEnabled === 'boolean') {
+    return options.defaultRoutingEnabled;
+  }
+  return isDefaultRoutingEnabled(options.homeDir || homedir());
+}
+
+function cleanupRenderedRules(cwd, options = {}) {
+  pruneStaleGeneratedRules(join(cwd, '.cursor', 'rules'), new Set());
+  pruneStaleGeneratedRules(join(cwd, '.claude', 'rules', 'platform'), new Set());
+
+  const HOME = options.homeDir || homedir();
+  if (cwd !== HOME) {
+    pruneStaleGeneratedRules(join(HOME, '.cursor', 'rules'), new Set());
+    pruneStaleGeneratedRules(join(HOME, '.claude', 'rules', 'platform'), new Set());
+  }
+}
+
 function stackOverlaysEnabled(options = {}) {
   if (typeof options.enableStackOverlays === 'boolean') {
     return options.enableStackOverlays;
@@ -701,8 +720,13 @@ export function generateAgentsMdRulesSection(rulesDir, options = {}) {
  *   2. Returns sections for CLAUDE.md and AGENTS.md injection
  */
 export function renderRules(cwd, options = {}) {
+  if (!defaultRoutingEnabled(options)) {
+    cleanupRenderedRules(cwd, options);
+    return { cursorCount: 0, claudeCount: 0, claudeSection: '', agentsSection: '' };
+  }
+
   const rulesDir = resolveRulesSourceDir(cwd, options);
-  if (!rulesDir) return { cursorCount: 0, claudeSection: '', agentsSection: '' };
+  if (!rulesDir) return { cursorCount: 0, claudeCount: 0, claudeSection: '', agentsSection: '' };
 
   // Resolve applicable scopes for AGENTS.md / CLAUDE.md MUST-rule list.
   // Order: explicit option → .aw/config.json awRuleScopes → auto-detect.

package/startup.mjs

@@ -13,6 +13,7 @@ import {
 const STARTUP_PREFS_FILENAME = 'startup-preferences.json';
 const ENABLED_MODE = 'enabled';
 const DISABLED_MODE = 'disabled';
+const DISABLE_DEFAULT_ROUTING_ENV = 'AW_DISABLE_DEFAULT_ROUTING';
 
 const CLAUDE_DISABLE_DESCRIPTION = 'AW-managed override: disable automatic AW session routing';
 const CLAUDE_TELEMETRY_DESCRIPTION = 'AW usage telemetry';
@@ -542,9 +543,35 @@ function disableCodexStartup(homeDir = homedir()) {
   return updatedFiles;
 }
 
-function isManagedCursorSessionStartEntry(entry) {
+function cursorSessionStartShellScriptUsesAwRouting(homeDir = homedir()) {
+  const scriptPath = join(homeDir, '.cursor', 'hooks', 'session-start.sh');
+  if (!existsSync(scriptPath)) return false;
+
+  try {
+    const content = readFileSync(scriptPath, 'utf8');
+    return content.includes('using-aw-skills/hooks/session-start.sh')
+      || content.includes('skills/using-aw-skills/hooks/session-start.sh');
+  } catch {
+    // Unreadable Cursor shell hook is safest to treat as non-AW managed.
+    return false;
+  }
+}
+
+function isManagedCursorSessionStartEntry(entry, homeDir = homedir()) {
   const command = String(entry?.command || '');
-  return command === CURSOR_SESSION_START_COMMAND || command.endsWith('.cursor/hooks/session-start.js');
+  if (command === CURSOR_SESSION_START_COMMAND || command.endsWith('.cursor/hooks/session-start.js')) {
+    return true;
+  }
+
+  if (command.includes('using-aw-skills/hooks/session-start.sh')) {
+    return true;
+  }
+
+  if (command.includes('.cursor/hooks/session-start.sh')) {
+    return cursorSessionStartShellScriptUsesAwRouting(homeDir);
+  }
+
+  return false;
 }
 
 function hasCursorSessionStartScript(homeDir = homedir()) {
@@ -560,7 +587,7 @@ function disableCursorStartup(homeDir = homedir()) {
     return [];
   }
 
-  const filtered = config.hooks.sessionStart.filter(entry => !isManagedCursorSessionStartEntry(entry));
+  const filtered = config.hooks.sessionStart.filter(entry => !isManagedCursorSessionStartEntry(entry, homeDir));
   if (filtered.length === config.hooks.sessionStart.length) {
     return [];
   }
@@ -622,6 +649,16 @@ export function loadStartupPreferences(homeDir = homedir()) {
   };
 }
 
+function envDisablesDefaultRouting(env = process.env) {
+  const value = String(env[DISABLE_DEFAULT_ROUTING_ENV] || '').trim().toLowerCase();
+  return ['1', 'true', 'yes', 'on'].includes(value);
+}
+
+export function isDefaultRoutingEnabled(homeDir = homedir(), env = process.env) {
+  if (envDisablesDefaultRouting(env)) return false;
+  return loadStartupPreferences(homeDir).mode !== DISABLED_MODE;
+}
+
 export function saveStartupPreferences(mode, homeDir = homedir()) {
   const normalizedMode = mode === DISABLED_MODE ? DISABLED_MODE : ENABLED_MODE;
   const next = {
@@ -658,11 +695,11 @@ export function applyGlobalStartupMode(mode, homeDir = homedir()) {
   return [...new Set(updatedFiles)];
 }
 
-export function applyStoredStartupPreferences(homeDir = homedir()) {
-  return applyGlobalStartupMode(loadStartupPreferences(homeDir).mode, homeDir);
+export function applyStoredStartupPreferences(homeDir = homedir(), env = process.env) {
+  return applyGlobalStartupMode(isDefaultRoutingEnabled(homeDir, env) ? ENABLED_MODE : DISABLED_MODE, homeDir);
 }
 
-export function getStartupStatus(homeDir = homedir()) {
+export function getStartupStatus(homeDir = homedir(), env = process.env) {
   const prefs = loadStartupPreferences(homeDir);
   const claudeSettingsPath = join(homeDir, '.claude', 'settings.json');
   const codexHooksPath = join(homeDir, '.codex', 'hooks.json');
@@ -670,9 +707,15 @@ export function getStartupStatus(homeDir = homedir()) {
   const claudeSettings = readJson(claudeSettingsPath, {});
   const codexHooks = readJson(codexHooksPath, {});
   const cursorHooks = readJson(cursorHooksPath, {});
+  const cursorSessionStartEntries = Array.isArray(cursorHooks?.hooks?.sessionStart)
+    ? cursorHooks.hooks.sessionStart
+    : [];
 
   return {
     ...prefs,
+    effectiveMode: isDefaultRoutingEnabled(homeDir, env) ? ENABLED_MODE : DISABLED_MODE,
+    envDisableDefaultRouting: envDisablesDefaultRouting(env),
+    envDisableDefaultRoutingName: DISABLE_DEFAULT_ROUTING_ENV,
     preferencesPath: startupPrefsPath(homeDir),
     claudePluginEnabled: claudeSettings?.enabledPlugins?.['aw@aw-marketplace'] === true,
     claudePluginInstalled: hasClaudePluginCache(homeDir),
@@ -684,8 +727,9 @@ export function getStartupStatus(homeDir = homedir()) {
     codexSessionStartPresent: Array.isArray(codexHooks?.hooks?.SessionStart) &&
       codexHooks.hooks.SessionStart.some(isManagedCodexSessionStartEntry),
     codexSessionStartScriptInstalled: hasCodexSessionStartScript(homeDir),
-    cursorSessionStartPresent: Array.isArray(cursorHooks?.hooks?.sessionStart) &&
-      cursorHooks.hooks.sessionStart.length > 0,
+    cursorSessionStartPresent: cursorSessionStartEntries.some(entry =>
+      isManagedCursorSessionStartEntry(entry, homeDir)),
+    cursorAnySessionStartPresent: cursorSessionStartEntries.length > 0,
     cursorSessionStartScriptInstalled: hasCursorSessionStartScript(homeDir),
   };
 }