@ghl-ai/aw 0.1.39-beta.8 → 0.1.39

package/startup.mjs

@@ -0,0 +1,562 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+import {
+  CODEX_HOME_HOOK_MATCHER,
+  codexHomeHookScriptPath,
+  getCodexHomePhaseDefinitions,
+  isManagedCodexHomeEntry,
+} from './hooks/codex-home.mjs';
+
+const STARTUP_PREFS_FILENAME = 'startup-preferences.json';
+const ENABLED_MODE = 'enabled';
+const DISABLED_MODE = 'disabled';
+
+const CLAUDE_DISABLE_DESCRIPTION = 'AW-managed override: disable automatic AW session routing';
+const CURSOR_SESSION_START_COMMAND = 'node .cursor/hooks/session-start.js';
+const CURSOR_SESSION_START_DESCRIPTION = 'Load previous context and detect environment';
+const REPO_CURSOR_SESSION_START_COMMAND = 'bash "$(git rev-parse --show-toplevel)/hooks/aw-session-start"';
+const REPO_CLAUDE_SESSION_START_COMMAND = '"$CLAUDE_PROJECT_DIR"/hooks/aw-session-start';
+const CODEX_HOME_PHASE_DEFINITIONS = getCodexHomePhaseDefinitions();
+const CODEX_HOME_PHASE_BY_NAME = new Map(
+  CODEX_HOME_PHASE_DEFINITIONS.map(definition => [definition.phase, definition]),
+);
+const CODEX_SESSION_START_DEFINITION = CODEX_HOME_PHASE_BY_NAME.get('SessionStart');
+const CODEX_PROMPT_DEFINITION = CODEX_HOME_PHASE_BY_NAME.get('UserPromptSubmit');
+const CODEX_PRE_TOOL_USE_DEFINITION = CODEX_HOME_PHASE_BY_NAME.get('PreToolUse');
+const CODEX_POST_TOOL_USE_DEFINITION = CODEX_HOME_PHASE_BY_NAME.get('PostToolUse');
+const CODEX_STOP_DEFINITION = CODEX_HOME_PHASE_BY_NAME.get('Stop');
+const CODEX_HOOK_COMMAND = CODEX_SESSION_START_DEFINITION.command;
+const CODEX_HOOK_STATUS = CODEX_SESSION_START_DEFINITION.entry.hooks[0].statusMessage;
+const CODEX_PROMPT_HOOK_COMMAND = CODEX_PROMPT_DEFINITION.command;
+const CODEX_PRE_TOOL_HOOK_COMMAND = CODEX_PRE_TOOL_USE_DEFINITION.command;
+const CODEX_POST_TOOL_HOOK_COMMAND = CODEX_POST_TOOL_USE_DEFINITION.command;
+const CODEX_STOP_HOOK_COMMAND = CODEX_STOP_DEFINITION.command;
+
+function startupPrefsPath(homeDir = homedir()) {
+  return join(homeDir, '.aw', STARTUP_PREFS_FILENAME);
+}
+
+function codexConfigPath(homeDir = homedir()) {
+  return join(homeDir, '.codex', 'config.toml');
+}
+
+function codexHookScriptPath(homeDir = homedir()) {
+  return codexHomeHookScriptPath(homeDir, CODEX_SESSION_START_DEFINITION);
+}
+
+function resolveRegistryRoot(homeDir = homedir()) {
+  return [
+    join(homeDir, '.aw_registry'),
+    join(homeDir, '.aw', '.aw_registry'),
+  ].find(existsSync) || null;
+}
+
+function awRuntimeHookSourcePath(homeDir = homedir()) {
+  return join(homeDir, '.aw-ecc', 'skills', 'using-aw-skills', 'hooks', 'session-start.sh');
+}
+
+function readJson(filePath, fallback = {}) {
+  if (!existsSync(filePath)) return fallback;
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(filePath, value) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function ensureManagedFile(filePath, content, updatedFiles) {
+  const current = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+  if (!existsSync(filePath) || current !== content) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content);
+    updatedFiles.push(filePath);
+  }
+}
+
+function removeManagedFile(filePath, marker, updatedFiles) {
+  if (!existsSync(filePath)) return;
+  try {
+    const current = readFileSync(filePath, 'utf8');
+    if (!current.includes(marker)) return;
+    rmSync(filePath, { force: true });
+    updatedFiles.push(filePath);
+  } catch {
+    /* best effort */
+  }
+}
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isEmptyObject(value) {
+  return isObject(value) && Object.keys(value).length === 0;
+}
+
+function pruneEmptySettingsFile(filePath, config) {
+  if (!existsSync(filePath)) return false;
+  if (!isEmptyObject(config)) return false;
+  rmSync(filePath, { force: true });
+  return true;
+}
+
+function ensureHooksObject(config) {
+  if (!isObject(config.hooks)) {
+    config.hooks = {};
+  }
+}
+
+function isManagedClaudeSessionStartOverride(entry) {
+  return entry?.description === CLAUDE_DISABLE_DESCRIPTION;
+}
+
+function hasClaudePluginCache(homeDir = homedir()) {
+  const cacheRoot = join(homeDir, '.claude', 'plugins', 'cache', 'aw-marketplace', 'aw');
+  if (!existsSync(cacheRoot)) return false;
+  try {
+    return readdirSync(cacheRoot, { withFileTypes: true }).some(entry => entry.isDirectory());
+  } catch {
+    return false;
+  }
+}
+
+function isLegacyClaudeSessionStartEntry(entry) {
+  return Array.isArray(entry?.hooks)
+    && entry.hooks.some(hook =>
+      hook?.type === 'command'
+      && typeof hook?.command === 'string'
+      && hook.command.includes('.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh')
+    );
+}
+
+function hasCommandHook(entry, command) {
+  return Array.isArray(entry?.hooks)
+    && entry.hooks.some(hook =>
+      hook?.type === 'command'
+      && hook?.command === command
+    );
+}
+
+function isManagedCodexSessionStartEntry(entry) {
+  return isManagedCodexHomeEntry(entry, CODEX_SESSION_START_DEFINITION);
+}
+
+function isLegacyCodexSessionStartEntry(entry) {
+  return Array.isArray(entry?.hooks)
+    && entry.hooks.some(hook => {
+      const command = String(hook?.command || '');
+      return (
+        command.includes('.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh')
+        || (command.includes('.codex/hooks/aw-session-start.sh') && entry?.matcher !== CODEX_HOME_HOOK_MATCHER)
+      );
+    });
+}
+
+function isManagedCodexPromptSubmitEntry(entry) {
+  return isManagedCodexHomeEntry(entry, CODEX_PROMPT_DEFINITION);
+}
+
+function isManagedCodexPreToolUseEntry(entry) {
+  return isManagedCodexHomeEntry(entry, CODEX_PRE_TOOL_USE_DEFINITION);
+}
+
+function isManagedCodexPostToolUseEntry(entry) {
+  return isManagedCodexHomeEntry(entry, CODEX_POST_TOOL_USE_DEFINITION);
+}
+
+function isManagedCodexStopEntry(entry) {
+  return isManagedCodexHomeEntry(entry, CODEX_STOP_DEFINITION);
+}
+
+function disableClaudeStartup(homeDir = homedir()) {
+  const settingsPath = join(homeDir, '.claude', 'settings.json');
+  const config = readJson(settingsPath, {});
+  ensureHooksObject(config);
+
+  const current = Array.isArray(config.hooks.SessionStart) ? config.hooks.SessionStart : [];
+  const next = [
+    {
+      matcher: '*',
+      hooks: [],
+      description: CLAUDE_DISABLE_DESCRIPTION,
+    },
+    ...current.filter(entry => !isManagedClaudeSessionStartOverride(entry) && !isLegacyClaudeSessionStartEntry(entry)),
+  ];
+
+  if (JSON.stringify(current) === JSON.stringify(next)) {
+    return [];
+  }
+
+  config.hooks.SessionStart = next;
+  writeJson(settingsPath, config);
+  return [settingsPath];
+}
+
+function enableClaudeStartup(homeDir = homedir()) {
+  const settingsPath = join(homeDir, '.claude', 'settings.json');
+  if (!existsSync(settingsPath)) return [];
+
+  const config = readJson(settingsPath, {});
+  if (!isObject(config.hooks) || !Array.isArray(config.hooks.SessionStart)) {
+    return [];
+  }
+
+  const filtered = config.hooks.SessionStart.filter(
+    entry => !isManagedClaudeSessionStartOverride(entry) && !isLegacyClaudeSessionStartEntry(entry),
+  );
+  if (filtered.length === config.hooks.SessionStart.length) {
+    return [];
+  }
+
+  if (filtered.length > 0) {
+    config.hooks.SessionStart = filtered;
+  } else {
+    delete config.hooks.SessionStart;
+  }
+
+  if (isEmptyObject(config.hooks)) {
+    delete config.hooks;
+  }
+
+  if (!pruneEmptySettingsFile(settingsPath, config)) {
+    writeJson(settingsPath, config);
+  }
+
+  return [settingsPath];
+}
+
+function hasCodexSessionStartScript(homeDir = homedir()) {
+  return existsSync(codexHookScriptPath(homeDir));
+}
+
+export function ensureAwRuntimeHook(homeDir = homedir()) {
+  const sourcePath = awRuntimeHookSourcePath(homeDir);
+  const registryRoot = resolveRegistryRoot(homeDir);
+  if (!existsSync(sourcePath) || !registryRoot) return [];
+
+  const destinationPath = join(
+    registryRoot,
+    'platform',
+    'core',
+    'skills',
+    'using-aw-skills',
+    'hooks',
+    'session-start.sh',
+  );
+  const sourceContent = readFileSync(sourcePath, 'utf8');
+  const existingContent = existsSync(destinationPath) ? readFileSync(destinationPath, 'utf8') : null;
+  if (existingContent === sourceContent) return [];
+
+  mkdirSync(dirname(destinationPath), { recursive: true });
+  writeFileSync(destinationPath, sourceContent);
+  try { chmodSync(destinationPath, 0o755); } catch { /* best effort */ }
+  return [destinationPath];
+}
+
+function hasCodexHooksEnabled(homeDir = homedir()) {
+  const configPath = codexConfigPath(homeDir);
+  if (!existsSync(configPath)) return false;
+
+  try {
+    return /^\s*codex_hooks\s*=\s*true\b/m.test(readFileSync(configPath, 'utf8'));
+  } catch {
+    return false;
+  }
+}
+
+function ensureCodexHookEnabled(content) {
+  if (/^\s*codex_hooks\s*=\s*true\b/m.test(content)) {
+    return content;
+  }
+
+  if (/^\s*codex_hooks\s*=\s*false\b/m.test(content)) {
+    return content.replace(/^\s*codex_hooks\s*=\s*false\b.*$/m, 'codex_hooks = true');
+  }
+
+  const featuresHeaderMatch = content.match(/^\[features\]\s*$/m);
+  if (featuresHeaderMatch && featuresHeaderMatch.index !== undefined) {
+    const insertAt = featuresHeaderMatch.index + featuresHeaderMatch[0].length;
+    return `${content.slice(0, insertAt)}\ncodex_hooks = true${content.slice(insertAt)}`;
+  }
+
+  const trimmed = content.trimEnd();
+  if (trimmed.length === 0) {
+    return '[features]\ncodex_hooks = true\n';
+  }
+
+  return `${trimmed}\n\n[features]\ncodex_hooks = true\n`;
+}
+
+function enableCodexStartup(homeDir = homedir()) {
+  const updatedFiles = [];
+  const configPath = codexConfigPath(homeDir);
+  const currentConfig = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
+  const nextConfig = ensureCodexHookEnabled(currentConfig);
+
+  if (!existsSync(configPath) || nextConfig !== currentConfig) {
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, nextConfig);
+    updatedFiles.push(configPath);
+  }
+
+  for (const definition of CODEX_HOME_PHASE_DEFINITIONS) {
+    ensureManagedFile(codexHomeHookScriptPath(homeDir, definition), definition.scriptContent, updatedFiles);
+  }
+
+  const hooksPath = join(homeDir, '.codex', 'hooks.json');
+  const config = readJson(hooksPath, {});
+
+  if (!isObject(config.hooks)) {
+    config.hooks = {};
+  }
+
+  let hooksChanged = false;
+
+  for (const definition of CODEX_HOME_PHASE_DEFINITIONS) {
+    const currentEntries = Array.isArray(config.hooks[definition.hookConfigKey]) ? config.hooks[definition.hookConfigKey] : [];
+    const nextEntries = [
+      ...currentEntries.filter(entry => !isManagedCodexHomeEntry(entry, definition)
+        && !(definition.phase === 'SessionStart' && isLegacyCodexSessionStartEntry(entry))),
+      definition.entry,
+    ];
+
+    if (JSON.stringify(nextEntries) !== JSON.stringify(currentEntries)) {
+      config.hooks[definition.hookConfigKey] = nextEntries;
+      hooksChanged = true;
+    }
+  }
+
+  if (hooksChanged) {
+    writeJson(hooksPath, config);
+    updatedFiles.push(hooksPath);
+  }
+
+  return updatedFiles;
+}
+
+function disableCodexStartup(homeDir = homedir()) {
+  const updatedFiles = [];
+  for (const definition of CODEX_HOME_PHASE_DEFINITIONS) {
+    removeManagedFile(codexHomeHookScriptPath(homeDir, definition), definition.scriptMarker, updatedFiles);
+  }
+
+  const hooksPath = join(homeDir, '.codex', 'hooks.json');
+  if (!existsSync(hooksPath)) return updatedFiles;
+
+  const config = readJson(hooksPath, {});
+  if (!isObject(config.hooks)) {
+    return updatedFiles;
+  }
+
+  let hooksChanged = false;
+
+  for (const definition of CODEX_HOME_PHASE_DEFINITIONS) {
+    const currentEntries = Array.isArray(config.hooks[definition.hookConfigKey]) ? config.hooks[definition.hookConfigKey] : null;
+    if (!currentEntries) continue;
+
+    const filtered = currentEntries.filter(entry => !isManagedCodexHomeEntry(entry, definition)
+      && !(definition.phase === 'SessionStart' && isLegacyCodexSessionStartEntry(entry)));
+    if (filtered.length !== currentEntries.length) {
+      hooksChanged = true;
+      if (filtered.length > 0) {
+        config.hooks[definition.hookConfigKey] = filtered;
+      } else {
+        delete config.hooks[definition.hookConfigKey];
+      }
+    }
+  }
+
+  if (!hooksChanged) return updatedFiles;
+
+  if (isEmptyObject(config.hooks)) {
+    delete config.hooks;
+  }
+
+  if (!pruneEmptySettingsFile(hooksPath, config)) {
+    writeJson(hooksPath, config);
+  }
+
+  updatedFiles.push(hooksPath);
+  return updatedFiles;
+}
+
+function isManagedCursorSessionStartEntry(entry) {
+  const command = String(entry?.command || '');
+  return command === CURSOR_SESSION_START_COMMAND || command.endsWith('.cursor/hooks/session-start.js');
+}
+
+function hasCursorSessionStartScript(homeDir = homedir()) {
+  return existsSync(join(homeDir, '.cursor', 'hooks', 'session-start.js'));
+}
+
+function disableCursorStartup(homeDir = homedir()) {
+  const hooksPath = join(homeDir, '.cursor', 'hooks.json');
+  if (!existsSync(hooksPath)) return [];
+
+  const config = readJson(hooksPath, {});
+  if (!isObject(config.hooks) || !Array.isArray(config.hooks.sessionStart)) {
+    return [];
+  }
+
+  const filtered = config.hooks.sessionStart.filter(entry => !isManagedCursorSessionStartEntry(entry));
+  if (filtered.length === config.hooks.sessionStart.length) {
+    return [];
+  }
+
+  if (filtered.length > 0) {
+    config.hooks.sessionStart = filtered;
+  } else {
+    delete config.hooks.sessionStart;
+  }
+
+  if (isEmptyObject(config.hooks)) {
+    delete config.hooks;
+  }
+
+  if (config.version === undefined) {
+    config.version = 1;
+  }
+
+  if (!pruneEmptySettingsFile(hooksPath, config)) {
+    writeJson(hooksPath, config);
+  }
+
+  return [hooksPath];
+}
+
+function enableCursorStartup(homeDir = homedir()) {
+  if (!hasCursorSessionStartScript(homeDir)) return [];
+
+  const hooksPath = join(homeDir, '.cursor', 'hooks.json');
+  const config = readJson(hooksPath, {});
+
+  if (!isObject(config.hooks)) {
+    config.hooks = {};
+  }
+
+  const current = Array.isArray(config.hooks.sessionStart) ? config.hooks.sessionStart : [];
+  if (current.length > 0) {
+    return [];
+  }
+
+  config.version = Number.isInteger(config.version) ? config.version : 1;
+  config.hooks.sessionStart = [
+    {
+      command: CURSOR_SESSION_START_COMMAND,
+      event: 'sessionStart',
+      description: CURSOR_SESSION_START_DESCRIPTION,
+    },
+  ];
+
+  writeJson(hooksPath, config);
+  return [hooksPath];
+}
+
+export function loadStartupPreferences(homeDir = homedir()) {
+  const prefs = readJson(startupPrefsPath(homeDir), {});
+  return {
+    mode: prefs.mode === DISABLED_MODE ? DISABLED_MODE : ENABLED_MODE,
+    updatedAt: typeof prefs.updatedAt === 'string' ? prefs.updatedAt : null,
+  };
+}
+
+export function saveStartupPreferences(mode, homeDir = homedir()) {
+  const normalizedMode = mode === DISABLED_MODE ? DISABLED_MODE : ENABLED_MODE;
+  const next = {
+    mode: normalizedMode,
+    updatedAt: new Date().toISOString(),
+  };
+  writeJson(startupPrefsPath(homeDir), next);
+  return next;
+}
+
+export function clearStartupPreferences(homeDir = homedir()) {
+  const prefsPath = startupPrefsPath(homeDir);
+  if (!existsSync(prefsPath)) return false;
+  rmSync(prefsPath, { force: true });
+  return true;
+}
+
+export function applyGlobalStartupMode(mode, homeDir = homedir()) {
+  const normalizedMode = mode === DISABLED_MODE ? DISABLED_MODE : ENABLED_MODE;
+  const updatedFiles = [];
+
+  if (normalizedMode === DISABLED_MODE) {
+    updatedFiles.push(...disableClaudeStartup(homeDir));
+    updatedFiles.push(...disableCodexStartup(homeDir));
+    updatedFiles.push(...disableCursorStartup(homeDir));
+  } else {
+    updatedFiles.push(...enableClaudeStartup(homeDir));
+    updatedFiles.push(...enableCodexStartup(homeDir));
+    updatedFiles.push(...enableCursorStartup(homeDir));
+  }
+
+  return [...new Set(updatedFiles)];
+}
+
+export function applyStoredStartupPreferences(homeDir = homedir()) {
+  return applyGlobalStartupMode(loadStartupPreferences(homeDir).mode, homeDir);
+}
+
+export function getStartupStatus(homeDir = homedir()) {
+  const prefs = loadStartupPreferences(homeDir);
+  const claudeSettingsPath = join(homeDir, '.claude', 'settings.json');
+  const codexHooksPath = join(homeDir, '.codex', 'hooks.json');
+  const cursorHooksPath = join(homeDir, '.cursor', 'hooks.json');
+  const claudeSettings = readJson(claudeSettingsPath, {});
+  const codexHooks = readJson(codexHooksPath, {});
+  const cursorHooks = readJson(cursorHooksPath, {});
+
+  return {
+    ...prefs,
+    preferencesPath: startupPrefsPath(homeDir),
+    claudePluginEnabled: claudeSettings?.enabledPlugins?.['aw@aw-marketplace'] === true,
+    claudePluginInstalled: hasClaudePluginCache(homeDir),
+    claudeDisabled: Array.isArray(claudeSettings?.hooks?.SessionStart) &&
+      claudeSettings.hooks.SessionStart.some(isManagedClaudeSessionStartOverride),
+    claudeLegacySessionStartPresent: Array.isArray(claudeSettings?.hooks?.SessionStart) &&
+      claudeSettings.hooks.SessionStart.some(isLegacyClaudeSessionStartEntry),
+    codexHooksEnabled: hasCodexHooksEnabled(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,
+    cursorSessionStartScriptInstalled: hasCursorSessionStartScript(homeDir),
+  };
+}
+
+export function hasLegacyRepoStartupDefaults(cwd) {
+  const codexHooksPath = join(cwd, '.codex', 'hooks.json');
+  const cursorHooksPath = join(cwd, '.cursor', 'hooks.json');
+  const claudeSettingsPath = join(cwd, '.claude', 'settings.json');
+  const wrapperPath = join(cwd, 'hooks', 'aw-session-start');
+
+  const codexHooks = readJson(codexHooksPath, {});
+  const cursorHooks = readJson(cursorHooksPath, {});
+  const claudeSettings = readJson(claudeSettingsPath, {});
+
+  const codexSessionStart = Array.isArray(codexHooks?.hooks?.SessionStart)
+    && codexHooks.hooks.SessionStart.some(entry =>
+      Array.isArray(entry?.hooks)
+      && entry.hooks.some(hook => String(hook?.command || '').includes('hooks/aw-session-start'))
+    );
+
+  const cursorSessionStart = Array.isArray(cursorHooks?.hooks?.sessionStart)
+    && cursorHooks.hooks.sessionStart.some(entry => String(entry?.command || '') === REPO_CURSOR_SESSION_START_COMMAND);
+
+  const claudeSessionStart = Array.isArray(claudeSettings?.hooks?.SessionStart)
+    && claudeSettings.hooks.SessionStart.some(entry =>
+      Array.isArray(entry?.hooks)
+      && entry.hooks.some(hook => String(hook?.command || '') === REPO_CLAUDE_SESSION_START_COMMAND)
+    );
+
+  return existsSync(wrapperPath) || codexSessionStart || cursorSessionStart || claudeSessionStart;
+}