@jmylchreest/aide-plugin 0.0.56 → 0.0.58

package/src/hooks/session-end.ts

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * Session End Hook (SessionEnd)
+ *
+ * Delegates cleanup to `aide session end` — single binary invocation.
+ *
+ * When invoked from Codex CLI's Stop hook (which has no separate SessionEnd),
+ * checks whether autopilot mode is active and skips cleanup if so — the
+ * session is continuing, not ending.
+ *
+ * CONSTRAINTS:
+ * - No ES module imports (hoisted resolution adds ~3s)
+ * - Output {"continue": true} before require() resolves
+ * - Cleanup via detached spawn to avoid blocking exit
+ * - MUST complete well within Claude Code's ~1.5s hook timeout
+ *
+ * STDIN:
+ * Claude Code pipes JSON via stdin and closes the pipe. The documented
+ * payload includes session_id, but in practice Claude Code often sends
+ * just `{}`. Bun's `for await` async iterator on stdin hangs even when
+ * the pipe is closed — use synchronous readFileSync(0) instead.
+ */
+
+const T0 = performance.now();
+
+// Output continue IMMEDIATELY — before require(), before anything.
+console.log(JSON.stringify({ continue: true }));
+
+const { spawn, execFileSync } = require("child_process") as typeof import("child_process");
+const { existsSync, realpathSync, appendFileSync, mkdirSync, readFileSync } = require("fs") as typeof import("fs");
+const { join } = require("path") as typeof import("path");
+const whichSync = (require("which") as typeof import("which")).sync;
+
+const SESSION_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+
+/** Elapsed ms since T0. */
+function ms(): string {
+  return `+${(performance.now() - T0).toFixed(0)}ms`;
+}
+
+/**
+ * Always log to .aide/_logs/session-end.log (NOT gated on AIDE_DEBUG).
+ * This hook has historically been invisible when it fails — always log.
+ */
+function log(cwd: string, msg: string): void {
+  try {
+    const logDir = join(cwd, ".aide", "_logs");
+    if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+    const line = `[${new Date().toISOString()}] [session-end] ${ms()} ${msg}\n`;
+    appendFileSync(join(logDir, "session-end.log"), line);
+  } catch { /* best effort */ }
+}
+
+/** Find aide binary — inline, no external module imports. */
+function findBinary(cwd?: string): string | null {
+  const pluginRoot = process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT;
+  let resolvedRoot = pluginRoot;
+  if (resolvedRoot) {
+    try { resolvedRoot = realpathSync(resolvedRoot); } catch { /* symlink may not resolve */ }
+    const p = join(resolvedRoot, "bin", "aide");
+    if (existsSync(p)) return p;
+  }
+  if (cwd) {
+    const p = join(cwd, ".aide", "bin", "aide");
+    if (existsSync(p)) return p;
+  }
+  try {
+    return whichSync("aide", { nothrow: true });
+  } catch { return null; }
+}
+
+function main(): void {
+  const cwd = process.cwd();
+  log(cwd, "started");
+
+  try {
+    // Read stdin synchronously — avoids bun's broken async iterator.
+    // Claude Code closes the pipe so this returns immediately.
+    let input = "";
+    try {
+      input = readFileSync(0, "utf-8");
+    } catch {
+      log(cwd, "stdin not readable (not a pipe?)");
+    }
+    log(cwd, `stdin (${input.length} bytes): ${input.trim().slice(0, 200)}`);
+
+    // Parse session_id from stdin JSON
+    let sessionId = "";
+    if (input.trim()) {
+      try {
+        const data = JSON.parse(input);
+        sessionId = data.session_id || "";
+      } catch {
+        log(cwd, "stdin is not valid JSON");
+      }
+    }
+
+    if (!sessionId) {
+      log(cwd, "no session_id in payload, skipping cleanup");
+      return;
+    }
+
+    if (!SESSION_ID_RE.test(sessionId)) {
+      log(cwd, `invalid session_id: ${sessionId}`);
+      return;
+    }
+
+    const binary = findBinary(cwd);
+    log(cwd, `binary: ${binary}`);
+    if (!binary) {
+      log(cwd, "no binary found, skipping cleanup");
+      return;
+    }
+
+    // Mode guard: skip cleanup if autopilot is active (session is continuing,
+    // not ending). This matters when Codex CLI invokes session-end from Stop
+    // hook since there's no separate SessionEnd event.
+    try {
+      const mode = execFileSync(binary, ["state", "get", "mode"], {
+        cwd, timeout: 500, encoding: "utf-8",
+      }).trim();
+      if (mode === "autopilot") {
+        log(cwd, "autopilot mode active, skipping cleanup (session continuing)");
+        return;
+      }
+    } catch {
+      // Binary may not support 'state get' or state may not exist — proceed
+    }
+
+    log(cwd, `spawning cleanup: session end --session=${sessionId}`);
+    const child = spawn(binary, ["session", "end", `--session=${sessionId}`], {
+      cwd, detached: true, stdio: "ignore",
+    });
+    child.unref();
+    log(cwd, "cleanup spawned (detached)");
+  } catch (error) {
+    log(cwd, `error: ${error}`);
+  }
+
+  log(cwd, `done ${ms()}`);
+}
+
+// On SIGINT/SIGTERM, exit cleanly (continue already output).
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
+
+main();
+process.exit(0);

package/src/hooks/session-start.ts

@@ -0,0 +1,488 @@
+#!/usr/bin/env node
+/**
+ * Session Start Hook (SessionStart)
+ *
+ * Initializes aide state and configuration on session start.
+ * - Creates .aide directories if needed
+ * - Loads config files
+ * - Initializes HUD state
+ * - Runs `aide session init` (single binary call for state reset, cleanup, memory fetch)
+ *
+ * Debug logging: Set AIDE_DEBUG=1 to enable startup tracing
+ * Logs written to: .aide/_logs/startup.log
+ */
+
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  copyFileSync,
+  chmodSync,
+} from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+import { Logger, debug, setDebugCwd } from "../lib/logger.js";
+import { readStdin, detectPlatform } from "../lib/hook-utils.js";
+import { findAideBinary, ensureAideBinary } from "../lib/aide-downloader.js";
+import {
+  ensureDirectories as coreEnsureDirectories,
+  loadConfig as coreLoadConfig,
+  initializeSession as coreInitializeSession,
+  cleanupStaleStateFiles as coreCleanupStaleStateFiles,
+  resetHudState as coreResetHudState,
+  getProjectName,
+  runSessionInit as coreRunSessionInit,
+  buildWelcomeContext as coreBuildWelcomeContext,
+  formatTimeAgo,
+} from "../core/session-init.js";
+import { syncMcpServers } from "../core/mcp-sync.js";
+import type {
+  AideConfig,
+  SessionState,
+  SessionInitResult,
+  MemoryInjection,
+  StartupNotices,
+} from "../core/types.js";
+
+const SOURCE = "session-start";
+debug(SOURCE, `Hook started (AIDE_DEBUG=${process.env.AIDE_DEBUG || "unset"})`);
+
+interface HookInput {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+  transcript_path?: string;
+  permission_mode?: string;
+}
+
+interface HookOutput {
+  continue: boolean;
+  hookSpecificOutput?: {
+    hookEventName: string;
+    additionalContext?: string;
+  };
+}
+
+interface BinaryCheckResult {
+  binary: string | null;
+  error: string | null;
+  warning: string | null;
+  downloaded: boolean;
+}
+
+/**
+ * Check for aide binary with logging, version checking, and auto-download
+ */
+async function checkAideBinary(
+  cwd: string,
+  log: Logger,
+): Promise<BinaryCheckResult> {
+  log.start("checkAideBinary");
+
+  const result = await ensureAideBinary(cwd);
+
+  if (result.binary) {
+    if (result.downloaded) {
+      log.info(`aide binary downloaded successfully to ${result.binary}`);
+    }
+    if (result.warning) {
+      log.info("aide update available");
+    }
+    log.end("checkAideBinary", {
+      found: true,
+      path: result.binary,
+      downloaded: result.downloaded,
+      hasWarning: !!result.warning,
+    });
+    return result;
+  }
+
+  log.warn("aide binary not found and download failed");
+  log.end("checkAideBinary", { found: false });
+
+  return result;
+}
+
+/**
+ * Reset HUD state file for clean session start — delegates to core
+ */
+function resetHudState(cwd: string, log: Logger): void {
+  log.start("resetHudState");
+  try {
+    coreResetHudState(cwd);
+    log.end("resetHudState", { success: true });
+  } catch (err) {
+    log.warn("Failed to reset HUD state", err);
+    log.end("resetHudState", { success: false, error: String(err) });
+  }
+}
+
+/**
+ * Get the plugin root directory
+ */
+function getPluginRoot(): string | null {
+  // Check AIDE_PLUGIN_ROOT or CLAUDE_PLUGIN_ROOT env var
+  const envRoot =
+    process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT;
+  if (envRoot && existsSync(join(envRoot, "package.json"))) {
+    return envRoot;
+  }
+
+  // Calculate from this script's location: dist/hooks/session-start.js -> ../../
+  try {
+    const scriptPath = fileURLToPath(import.meta.url);
+    const pluginRoot = join(dirname(scriptPath), "..", "..");
+    if (existsSync(join(pluginRoot, "package.json"))) {
+      return pluginRoot;
+    }
+  } catch {
+    // import.meta.url not available
+  }
+
+  return null;
+}
+
+/**
+ * Install the HUD wrapper script to ~/.claude/bin/
+ *
+ * This installs a thin wrapper that delegates to the real HUD script in the plugin.
+ * The wrapper allows plugin updates to take effect without reinstalling.
+ */
+function installHudWrapper(log: Logger): void {
+  log.start("installHudWrapper");
+
+  const claudeBinDir = join(homedir(), ".claude", "bin");
+  const wrapperDest = join(claudeBinDir, "aide-hud.ts");
+
+  // Check if wrapper already exists
+  if (existsSync(wrapperDest)) {
+    log.debug("HUD wrapper already installed");
+    log.end("installHudWrapper", { skipped: true, reason: "exists" });
+    return;
+  }
+
+  // Find our wrapper source
+  const pluginRoot = getPluginRoot();
+  if (!pluginRoot) {
+    log.warn("Could not determine plugin root, skipping HUD wrapper install");
+    log.end("installHudWrapper", { skipped: true, reason: "no-plugin-root" });
+    return;
+  }
+
+  const wrapperSrc = join(pluginRoot, "scripts", "aide-hud-wrapper.ts");
+  if (!existsSync(wrapperSrc)) {
+    log.warn(`HUD wrapper source not found: ${wrapperSrc}`);
+    log.end("installHudWrapper", { skipped: true, reason: "no-source" });
+    return;
+  }
+
+  try {
+    // Create ~/.claude/bin if needed
+    if (!existsSync(claudeBinDir)) {
+      mkdirSync(claudeBinDir, { recursive: true });
+    }
+
+    // Copy wrapper script
+    copyFileSync(wrapperSrc, wrapperDest);
+    try { chmodSync(wrapperDest, 0o755); } catch { /* no-op on Windows */ }
+
+    log.info(`Installed HUD wrapper to ${wrapperDest}`);
+    log.end("installHudWrapper", { success: true, path: wrapperDest });
+  } catch (err) {
+    log.warn("Failed to install HUD wrapper", err);
+    log.end("installHudWrapper", { success: false, error: String(err) });
+  }
+}
+
+/**
+ * Ensure all .aide directories exist — delegates to core
+ */
+function ensureDirectories(cwd: string, log: Logger): void {
+  log.start("ensureDirectories");
+  const { created, existed } = coreEnsureDirectories(cwd);
+  log.end("ensureDirectories", { created, existed });
+}
+
+/**
+ * Load or create config file — delegates to core
+ */
+function loadConfig(cwd: string, log: Logger): AideConfig {
+  log.start("loadConfig");
+  const config = coreLoadConfig(cwd);
+  log.end("loadConfig");
+  return config;
+}
+
+/**
+ * Clean up stale state files — delegates to core
+ */
+function cleanupStaleStateFiles(cwd: string, log: Logger): void {
+  log.start("cleanupStaleStateFiles");
+  const { scanned, deleted } = coreCleanupStaleStateFiles(cwd);
+  log.end("cleanupStaleStateFiles", { scanned, deleted });
+}
+
+/**
+ * Initialize session state — delegates to core
+ */
+function initializeSession(
+  sessionId: string,
+  cwd: string,
+  log: Logger,
+): SessionState {
+  log.start("initializeSession");
+  const state = coreInitializeSession(sessionId, cwd);
+  log.end("initializeSession", { sessionId: sessionId.slice(0, 8) });
+  return state;
+}
+
+// getProjectName, runSessionInit, formatTimeAgo, buildWelcomeContext
+// are now imported from ../core/session-init.js above.
+// The runSessionInit wrapper below adds logging around the core function.
+
+/**
+ * Run session init with logging — wraps core function
+ */
+function runSessionInit(
+  cwd: string,
+  projectName: string,
+  sessionLimit: number,
+  log: Logger,
+  config?: AideConfig,
+): MemoryInjection {
+  log.start("sessionInit");
+
+  const binary = findAideBinary(cwd);
+  if (!binary) {
+    log.debug("aide binary not found, skipping session init");
+    log.end("sessionInit", { skipped: true, reason: "no-binary" });
+    return {
+      static: { global: [], project: [], decisions: [] },
+      dynamic: { sessions: [] },
+    };
+  }
+
+  const result = coreRunSessionInit(
+    binary,
+    cwd,
+    projectName,
+    sessionLimit,
+    config,
+  );
+
+  log.end("sessionInit", {
+    globalCount: result.static.global.length,
+    projectCount: result.static.project.length,
+    decisionCount: result.static.decisions.length,
+    sessionCount: result.dynamic.sessions.length,
+  });
+
+  return result;
+}
+
+/**
+ * Build welcome context — wraps core function
+ */
+function buildWelcomeContext(
+  state: SessionState,
+  memories: MemoryInjection,
+  notices: StartupNotices = {},
+): string {
+  return coreBuildWelcomeContext(state, memories, notices);
+}
+
+// Debug helper - writes to debug.log (not stderr)
+function debugLog(msg: string): void {
+  debug(SOURCE, msg);
+}
+
+// Ensure we always output valid JSON, even on catastrophic errors
+function outputContinue(): void {
+  try {
+    console.log(JSON.stringify({ continue: true }));
+  } catch {
+    // Last resort - raw JSON string
+    console.log('{"continue":true}');
+  }
+}
+
+// Global error handlers to prevent hook crashes without JSON output
+process.on("uncaughtException", (err) => {
+  debugLog(`UNCAUGHT EXCEPTION: ${err}`);
+  outputContinue();
+  process.exit(0);
+});
+
+process.on("unhandledRejection", (reason) => {
+  debugLog(`UNHANDLED REJECTION: ${reason}`);
+  outputContinue();
+  process.exit(0);
+});
+
+async function main(): Promise<void> {
+  let log: Logger | null = null;
+  const hookStart = Date.now();
+
+  debugLog(`Hook started at ${new Date().toISOString()}`);
+
+  try {
+    debugLog("Reading stdin...");
+    const input = await readStdin();
+    debugLog(`Stdin read complete (${Date.now() - hookStart}ms)`);
+
+    if (!input.trim()) {
+      debugLog("Empty input, exiting");
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const data: HookInput = JSON.parse(input);
+    const cwd = data.cwd || process.cwd();
+    const sessionId = data.session_id || "unknown";
+
+    // Switch debug logging to project-local logs
+    setDebugCwd(cwd);
+
+    debugLog(`Parsed input: cwd=${cwd}, sessionId=${sessionId.slice(0, 8)}`);
+
+    // Initialize logger
+    log = new Logger("session-start", cwd);
+    log.info(`Session starting: ${sessionId.slice(0, 8)}`);
+    log.start("total");
+
+    debugLog(`Logger initialized, enabled=${log.isEnabled()}`);
+
+    // Initialize directories (FS only, fast)
+    debugLog("ensureDirectories starting...");
+    ensureDirectories(cwd, log);
+    debugLog(`ensureDirectories complete (${Date.now() - hookStart}ms)`);
+
+    // Install HUD wrapper script if not present (FS only, fast)
+    debugLog("installHudWrapper starting...");
+    installHudWrapper(log);
+    debugLog(`installHudWrapper complete (${Date.now() - hookStart}ms)`);
+
+    // Sync MCP server configs across assistants (FS only, fast)
+    debugLog("mcpSync starting...");
+    log.start("mcpSync");
+    try {
+      const mcpResult = syncMcpServers(detectPlatform(), cwd);
+      const totalImported =
+        mcpResult.user.imported + mcpResult.project.imported;
+      const totalWritten =
+        mcpResult.user.serversWritten + mcpResult.project.serversWritten;
+      const totalSkipped = mcpResult.user.skipped + mcpResult.project.skipped;
+      log.end("mcpSync", {
+        userServers: mcpResult.user.serversWritten,
+        projectServers: mcpResult.project.serversWritten,
+        imported: totalImported,
+        skipped: totalSkipped,
+      });
+      if (totalImported > 0) {
+        debugLog(
+          `mcp-sync: imported ${totalImported} server(s), ${totalWritten} total`,
+        );
+      }
+    } catch (err) {
+      log.warn("MCP sync failed (non-fatal)", err);
+      log.end("mcpSync", { success: false, error: String(err) });
+    }
+    debugLog(`mcpSync complete (${Date.now() - hookStart}ms)`);
+
+    // Check that aide binary is available (auto-downloads if missing/outdated)
+    debugLog("checkAideBinary starting...");
+    const {
+      error: binaryError,
+      warning: binaryWarning,
+      downloaded: binaryDownloaded,
+    } = await checkAideBinary(cwd, log);
+    if (binaryDownloaded) {
+      debugLog(`aide binary was downloaded`);
+    }
+    debugLog(`checkAideBinary complete (${Date.now() - hookStart}ms)`);
+
+    // Reset HUD state for clean session start (FS only, fast)
+    debugLog("resetHudState starting...");
+    resetHudState(cwd, log);
+    debugLog(`resetHudState complete (${Date.now() - hookStart}ms)`);
+
+    // Load config (FS only, fast)
+    debugLog("loadConfig starting...");
+    const config = loadConfig(cwd, log);
+    debugLog(`loadConfig complete (${Date.now() - hookStart}ms)`);
+
+    // Cleanup stale state files on disk (FS only, fast)
+    debugLog("cleanupStaleStateFiles starting...");
+    cleanupStaleStateFiles(cwd, log);
+    debugLog(`cleanupStaleStateFiles complete (${Date.now() - hookStart}ms)`);
+
+    // Initialize session state file (FS only, fast)
+    debugLog("initializeSession starting...");
+    const state = initializeSession(sessionId, cwd, log);
+    debugLog(`initializeSession complete (${Date.now() - hookStart}ms)`);
+
+    // Single aide binary call: reset state + cleanup agents + fetch all memories
+    // Replaces 7 separate binary spawns (~35-50s) with 1 (~5s)
+    const projectName = getProjectName(cwd);
+    debugLog("sessionInit starting...");
+    const memories = runSessionInit(cwd, projectName, 2, log, config);
+    debugLog(`sessionInit complete (${Date.now() - hookStart}ms)`);
+
+    // Build startup notices
+    const notices: StartupNotices = {
+      error: binaryError,
+      warning: binaryWarning,
+      info: [],
+    };
+    if (binaryDownloaded) {
+      notices.info!.push("aide binary downloaded");
+    }
+
+    // Log notices via debug (avoids stderr which Claude Code interprets as error)
+    if (notices.error) {
+      debugLog(`NOTICE ERROR: ${notices.error}`);
+    }
+    if (notices.warning) {
+      debugLog(`NOTICE WARNING: ${notices.warning}`);
+    }
+    for (const info of notices.info || []) {
+      debugLog(`NOTICE INFO: ${info}`);
+    }
+
+    // Build welcome context with injected memories
+    debugLog("buildWelcomeContext starting...");
+    log.start("buildWelcomeContext");
+    const context = buildWelcomeContext(state, memories, notices);
+    log.end("buildWelcomeContext");
+    debugLog(`buildWelcomeContext complete (${Date.now() - hookStart}ms)`);
+
+    log.end("total");
+    log.info("Session start complete");
+    debugLog(`Flushing logs to ${log.getLogFile()}...`);
+    log.flush();
+    debugLog(`Hook complete (${Date.now() - hookStart}ms total)`);
+
+    const output: HookOutput = {
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext: context,
+      },
+    };
+
+    console.log(JSON.stringify(output));
+  } catch (error) {
+    debugLog(`ERROR: ${error}`);
+    // Log error if logger is available
+    if (log) {
+      log.error("Session start failed", error);
+      log.flush();
+    }
+    // On error, allow continuation without context
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();