@ghl-ai/aw 0.1.37-beta.52 → 0.1.37-beta.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.52",
+  "version": "0.1.37-beta.53",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",
@@ -25,6 +25,7 @@
     "apply.mjs",
     "update.mjs",
     "hooks.mjs",
+    "startup.mjs",
     "ecc.mjs",
     "render-rules.mjs"
   ],

package/startup.mjs

@@ -0,0 +1,470 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+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 CODEX_HOOK_MATCHER = 'startup|resume';
+const CODEX_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-session-start.sh"';
+const CODEX_HOOK_STATUS = 'Loading AW router';
+const CODEX_HOOK_MARKER = '# aw-managed: codex-global-session-start';
+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_HOOK_SCRIPT = `#!/usr/bin/env bash
+${CODEX_HOOK_MARKER}
+set -euo pipefail
+
+TARGETS=(
+  "\$HOME/.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh"
+  "\$HOME/.aw/.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh"
+)
+
+for target in "\${TARGETS[@]}"; do
+  if [[ -f "\$target" ]]; then
+    exec bash "\$target"
+  fi
+done
+
+CONTEXT="# AW Session Context
+
+WARNING: AW using-aw-skills hook not found in ~/.aw_registry. Run aw init or aw pull platform."
+
+JSON_CONTEXT=$(printf '%s' "\$CONTEXT" | python3 -c 'import json, sys; print(json.dumps(sys.stdin.read()))')
+
+echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"SessionStart\\",\\"additionalContext\\":\${JSON_CONTEXT}}}"
+`;
+
+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 join(homeDir, '.codex', 'hooks', 'aw-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 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 isManagedCodexSessionStartEntry(entry) {
+  return entry?.matcher === CODEX_HOOK_MATCHER
+    && Array.isArray(entry?.hooks)
+    && entry.hooks.some(hook =>
+      hook?.type === 'command'
+      && hook?.command === CODEX_HOOK_COMMAND
+    );
+}
+
+function isLegacyCodexSessionStartEntry(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 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 : [];
+  if (current.some(isManagedClaudeSessionStartOverride)) {
+    return [];
+  }
+
+  config.hooks.SessionStart = [
+    {
+      matcher: '*',
+      hooks: [],
+      description: CLAUDE_DISABLE_DESCRIPTION,
+    },
+    ...current,
+  ];
+
+  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));
+  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));
+}
+
+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);
+  }
+
+  const hookScriptPath = codexHookScriptPath(homeDir);
+  const currentHookScript = existsSync(hookScriptPath) ? readFileSync(hookScriptPath, 'utf8') : '';
+  if (!existsSync(hookScriptPath) || currentHookScript !== CODEX_HOOK_SCRIPT) {
+    mkdirSync(dirname(hookScriptPath), { recursive: true });
+    writeFileSync(hookScriptPath, CODEX_HOOK_SCRIPT);
+    updatedFiles.push(hookScriptPath);
+  }
+
+  const hooksPath = join(homeDir, '.codex', 'hooks.json');
+  const config = readJson(hooksPath, {});
+
+  if (!isObject(config.hooks)) {
+    config.hooks = {};
+  }
+
+  const current = Array.isArray(config.hooks.SessionStart) ? config.hooks.SessionStart : [];
+  const cleaned = current.filter(entry => !isLegacyCodexSessionStartEntry(entry) && !isManagedCodexSessionStartEntry(entry));
+  const hasManagedEntry = current.some(isManagedCodexSessionStartEntry);
+
+  if (!hasManagedEntry || cleaned.length !== current.length) {
+    config.hooks.SessionStart = [
+      ...cleaned,
+      {
+        matcher: CODEX_HOOK_MATCHER,
+        hooks: [
+          {
+            type: 'command',
+            command: CODEX_HOOK_COMMAND,
+            statusMessage: CODEX_HOOK_STATUS,
+          },
+        ],
+      },
+    ];
+    writeJson(hooksPath, config);
+    updatedFiles.push(hooksPath);
+  }
+
+  return updatedFiles;
+}
+
+function disableCodexStartup(homeDir = homedir()) {
+  const updatedFiles = [];
+  const hookScriptPath = codexHookScriptPath(homeDir);
+  if (existsSync(hookScriptPath)) {
+    try {
+      const currentHookScript = readFileSync(hookScriptPath, 'utf8');
+      if (currentHookScript.includes(CODEX_HOOK_MARKER)) {
+        rmSync(hookScriptPath, { force: true });
+        updatedFiles.push(hookScriptPath);
+      }
+    } catch {
+      /* best effort */
+    }
+  }
+
+  const hooksPath = join(homeDir, '.codex', 'hooks.json');
+  if (!existsSync(hooksPath)) return updatedFiles;
+
+  const config = readJson(hooksPath, {});
+  if (!isObject(config.hooks) || !Array.isArray(config.hooks.SessionStart)) {
+    return updatedFiles;
+  }
+
+  const filtered = config.hooks.SessionStart.filter(entry => !isManagedCodexSessionStartEntry(entry) && !isLegacyCodexSessionStartEntry(entry));
+  if (filtered.length === config.hooks.SessionStart.length) {
+    return updatedFiles;
+  }
+
+  if (filtered.length > 0) {
+    config.hooks.SessionStart = filtered;
+  } else {
+    delete config.hooks.SessionStart;
+  }
+
+  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),
+    claudeDisabled: Array.isArray(claudeSettings?.hooks?.SessionStart) &&
+      claudeSettings.hooks.SessionStart.some(isManagedClaudeSessionStartOverride),
+    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;
+}