claude-code-pilot 3.1.1 → 3.3.0

package/src/hooks/kit-check-update.js

@@ -41,17 +41,69 @@ const child = spawn(process.execPath, ['-e', `
 `], { stdio: 'ignore', windowsHide: true, detached: true });
 child.unref();
 
-// Show cached result if fresh
+// Stale-hook detector: scan installed .claude/hooks/*.{js,sh} for ccp-hook-version
+// headers, compare against the installed pilot VERSION. Advisory only; never blocks.
+//
+// Regex matches both bash ('# ') and JS ('// ') comment styles to avoid the
+// upstream bug where bash hooks landed in the "unknown" branch on every session.
+// The negative case (no comment prefix) is intentional to prevent false positives
+// on bare version strings inside file content.
+function findStaleHooks(hooksDir, installedVersion) {
+  if (!hooksDir || !fs.existsSync(hooksDir)) return [];
+  const VERSION_RE = /(?:\/\/|#) ccp-hook-version:\s*(.+)/;
+  const stale = [];
+  try {
+    for (const file of fs.readdirSync(hooksDir)) {
+      if (!file.endsWith('.js') && !file.endsWith('.sh')) continue;
+      const p = path.join(hooksDir, file);
+      let content;
+      try { content = fs.readFileSync(p, 'utf8'); } catch { continue; }
+      const m = content.match(VERSION_RE);
+      if (!m) continue; // unversioned hooks are not flagged
+      const hookVersion = m[1].trim();
+      if (hookVersion.includes('{{')) continue; // unsubstituted placeholder -- skip
+      if (hookVersion !== installedVersion) {
+        stale.push({ file, hookVersion, installedVersion });
+      }
+    }
+  } catch {
+    // detector failure is silent; never break SessionStart
+  }
+  return stale;
+}
+
+// Show cached result if fresh + stale-hook advisory (combined into one notice)
 try {
+  let installedVersion = '0.0.0';
+  try { installedVersion = fs.readFileSync(versionFile, 'utf8').trim(); } catch {}
+  const hooksDir = path.join(path.dirname(path.dirname(versionFile)), 'hooks');
+  let stale = [];
+  try { stale = findStaleHooks(hooksDir, installedVersion); } catch {}
+
+  let updateMsg = null;
   if (fs.existsSync(cacheFile)) {
     const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
     if ((Math.floor(Date.now() / 1000) - (cached.checked || 0)) < 86400 && cached.update_available) {
-      process.stdout.write(JSON.stringify({
-        hookSpecificOutput: {
-          hookEventName: 'SessionStart',
-          additionalContext: `Pilot update available: ${cached.installed} -> ${cached.latest}. Run /ccp:update to upgrade.`
-        }
-      }));
+      updateMsg = `Pilot update available: ${cached.installed} -> ${cached.latest}. Run /ccp:update to upgrade.`;
     }
   }
+
+  let staleMsg = null;
+  if (stale.length > 0) {
+    staleMsg = `Stale hooks detected (run /ccp:update): ${stale.map(s => s.file).join(', ')}`;
+  }
+
+  if (updateMsg || staleMsg) {
+    const lines = [];
+    if (staleMsg) lines.push(staleMsg);
+    if (updateMsg) lines.push(updateMsg);
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'SessionStart',
+        additionalContext: lines.join('\n')
+      }
+    }));
+  }
 } catch {}
+
+module.exports = { findStaleHooks };

package/src/hooks/run-with-flags-shell.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# ccp-hook-version: {{CCP_VERSION}}
 set -euo pipefail
 
 HOOK_ID="${1:-}"

package/src/hooks/run-with-flags.js

@@ -9,9 +9,10 @@
 'use strict';
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
-const { isHookEnabled } = require('../lib/hook-flags');
+const { isHookEnabled, isProfilingEnabled } = require('../lib/hook-flags');
 
 const MAX_STDIN = 1024 * 1024;
 
@@ -85,6 +86,45 @@ function getPluginRoot() {
   return path.resolve(__dirname, '..', '..');
 }
 
+/**
+ * Append a single JSONL row to the timings sidecar.
+ *
+ * Wrapped in try/catch so timing failures NEVER block the hook itself.
+ * File path: {CCP_HOOK_TIMINGS_DIR || os.tmpdir()}/ccp-hook-timings-{sessionId}.json
+ */
+function recordTiming(hookId, durationMs) {
+  try {
+    const timingsDir = (process.env.CCP_HOOK_TIMINGS_DIR && process.env.CCP_HOOK_TIMINGS_DIR.trim())
+      ? process.env.CCP_HOOK_TIMINGS_DIR
+      : os.tmpdir();
+    const sessionId = (process.env.CLAUDE_SESSION_ID && process.env.CLAUDE_SESSION_ID.trim())
+      ? process.env.CLAUDE_SESSION_ID
+      : 'unknown';
+    const sidecarPath = path.join(timingsDir, `ccp-hook-timings-${sessionId}.json`);
+    const row = JSON.stringify({
+      hookId: String(hookId || ''),
+      durationMs: Number(durationMs) || 0,
+      ts: Date.now()
+    });
+    try {
+      fs.appendFileSync(sidecarPath, row + '\n', { flag: 'a' });
+    } catch {
+      // sidecar write failed -- swallow silently; never block the hook
+    }
+  } catch {
+    // outer guard: even path resolution must not break the dispatcher
+  }
+}
+
+/**
+ * Measure wall-clock duration in milliseconds using the monotonic hrtime
+ * clock (resists wall-clock skew/NTP adjustments).
+ */
+function elapsedMs(startNs) {
+  const deltaNs = process.hrtime.bigint() - startNs;
+  return Number(deltaNs) / 1e6;
+}
+
 async function main() {
   const [, , hookId, relScriptPath, profilesCsv] = process.argv;
   const { raw, truncated } = await readStdinRaw();
@@ -135,11 +175,16 @@ async function main() {
     }
   }
 
+  const profileOn = isProfilingEnabled();
+
   if (hookModule && typeof hookModule.run === 'function') {
+    const startNs = profileOn ? process.hrtime.bigint() : null;
     try {
       const output = hookModule.run(raw, { truncated, maxStdin: MAX_STDIN });
+      if (profileOn) recordTiming(hookId, elapsedMs(startNs));
       process.exit(emitHookResult(raw, output));
     } catch (runErr) {
+      if (profileOn) recordTiming(hookId, elapsedMs(startNs));
       process.stderr.write(`[Hook] run() error for ${hookId}: ${runErr.message}\n`);
       process.stdout.write(raw);
     }
@@ -147,6 +192,7 @@ async function main() {
   }
 
   // Legacy path: spawn a child Node process for hooks without run() export
+  const legacyStartNs = profileOn ? process.hrtime.bigint() : null;
   const result = spawnSync(process.execPath, [scriptPath], {
     input: raw,
     encoding: 'utf8',
@@ -158,6 +204,7 @@ async function main() {
     cwd: process.cwd(),
     timeout: 30000
   });
+  if (profileOn) recordTiming(hookId, elapsedMs(legacyStartNs));
 
   writeLegacySpawnOutput(raw, result);
   if (result.stderr) process.stderr.write(result.stderr);

package/src/hooks/session-end.js

@@ -11,6 +11,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 const {
   getSessionsDir,
   getDateString,
@@ -25,6 +26,52 @@ const {
   log
 } = require('../lib/utils');
 
+// Cap sidecar reads at 1 MB to prevent memory blow-up if the file grew
+// unexpectedly large. Mitigation for T-21-02 in the threat model.
+const MAX_TIMINGS_SIDECAR_BYTES = 1024 * 1024;
+
+/**
+ * Build a "## Hook Timings" markdown section by parsing a JSONL sidecar.
+ * Returns null if the sidecar is missing/empty/unreadable. Wrapped in
+ * try/catch by callers; this helper is best-effort and never throws.
+ */
+function buildHookTimingsSection(sidecarPath) {
+  try {
+    if (!sidecarPath || !fs.existsSync(sidecarPath)) return null;
+    const stat = fs.statSync(sidecarPath);
+    if (stat.size === 0 || stat.size > MAX_TIMINGS_SIDECAR_BYTES) return null;
+    const raw = fs.readFileSync(sidecarPath, 'utf8');
+    const grouped = new Map();
+    for (const line of raw.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let row;
+      try { row = JSON.parse(trimmed); } catch { continue; }
+      if (!row || typeof row.hookId !== 'string') continue;
+      const id = row.hookId;
+      const dur = Number(row.durationMs) || 0;
+      const prev = grouped.get(id) || { calls: 0, totalMs: 0 };
+      prev.calls += 1;
+      prev.totalMs += dur;
+      grouped.set(id, prev);
+    }
+    if (grouped.size === 0) return null;
+    const rows = Array.from(grouped.entries())
+      .sort((a, b) => b[1].totalMs - a[1].totalMs)
+      .map(([id, s]) => `| ${id} | ${s.calls} | ${s.totalMs.toFixed(2)} | ${(s.totalMs / s.calls).toFixed(2)} |`);
+    return [
+      '## Hook Timings',
+      '',
+      '| Hook | Calls | Total (ms) | Avg (ms) |',
+      '|------|-------|------------|----------|',
+      ...rows,
+      ''
+    ].join('\n');
+  } catch {
+    return null;
+  }
+}
+
 const SUMMARY_START_MARKER = '<!-- ECC:SUMMARY:START -->';
 const SUMMARY_END_MARKER = '<!-- ECC:SUMMARY:END -->';
 const SESSION_SEPARATOR = '\n---\n';
@@ -178,11 +225,13 @@ function mergeSessionHeader(content, today, currentTime, metadata) {
 }
 
 async function main() {
-  // Parse stdin JSON to get transcript_path
+  // Parse stdin JSON to get transcript_path + session_id
   let transcriptPath = null;
+  let sessionIdFromStdin = null;
   try {
     const input = JSON.parse(stdinData);
     transcriptPath = input.transcript_path;
+    sessionIdFromStdin = input.session_id;
   } catch {
     // Fallback: try env var for backwards compatibility
     transcriptPath = process.env.CLAUDE_TRANSCRIPT_PATH;
@@ -260,6 +309,44 @@ async function main() {
     log(`[SessionEnd] Created session file: ${sessionFile}`);
   }
 
+  // Hook Timings summary -- best-effort. If a sidecar exists, summarise it
+  // into a "## Hook Timings" markdown section appended to the session file,
+  // then delete the sidecar. Failures are silent; never block session-end.
+  try {
+    const sessionId = (sessionIdFromStdin && String(sessionIdFromStdin).trim())
+      ? String(sessionIdFromStdin).trim()
+      : (process.env.CLAUDE_SESSION_ID && process.env.CLAUDE_SESSION_ID.trim()
+        ? process.env.CLAUDE_SESSION_ID.trim()
+        : null);
+    if (sessionId) {
+      const timingsDir = (process.env.CCP_HOOK_TIMINGS_DIR && process.env.CCP_HOOK_TIMINGS_DIR.trim())
+        ? process.env.CCP_HOOK_TIMINGS_DIR
+        : os.tmpdir();
+      const sidecarPath = path.join(timingsDir, `ccp-hook-timings-${sessionId}.json`);
+      const timingSection = buildHookTimingsSection(sidecarPath);
+      if (timingSection && fs.existsSync(sessionFile)) {
+        try {
+          const existing = readFile(sessionFile) || '';
+          // If a previous Hook Timings section exists, replace it; otherwise append.
+          let updated;
+          if (existing.includes('## Hook Timings')) {
+            updated = existing.replace(/## Hook Timings[\s\S]*?(?=\n## |\n# |$)/, timingSection + '\n');
+          } else {
+            updated = existing.endsWith('\n')
+              ? `${existing}\n${timingSection}\n`
+              : `${existing}\n\n${timingSection}\n`;
+          }
+          writeFile(sessionFile, updated);
+        } catch {
+          // ignore: never block on timing summary write failure
+        }
+        try { fs.unlinkSync(sidecarPath); } catch { /* ignore */ }
+      }
+    }
+  } catch {
+    // outer guard: timing summary must not affect session-end success
+  }
+
   process.exit(0);
 }
 

package/src/lib/hook-flags.js

@@ -24,6 +24,19 @@ function getHookProfile() {
   return VALID_PROFILES.has(raw) ? raw : 'standard';
 }
 
+/**
+ * Boolean toggle for per-hook timing instrumentation.
+ *
+ * Distinct from getHookProfile() (string profile selector). The timing toggle
+ * is read from CCP_HOOK_PROFILE === '1' (or ECC_HOOK_PROFILE === '1' for
+ * back-compat). Other values like 'standard' / 'minimal' / 'strict' do NOT
+ * enable timing — those are profile names handled by getHookProfile().
+ */
+function isProfilingEnabled() {
+  const raw = String(process.env.CCP_HOOK_PROFILE || process.env.ECC_HOOK_PROFILE || '').trim();
+  return raw === '1';
+}
+
 function getDisabledHookIds() {
   const raw = String(process.env.CCP_DISABLED_HOOKS || process.env.ECC_DISABLED_HOOKS || '');
   if (!raw.trim()) return new Set();
@@ -72,6 +85,7 @@ module.exports = {
   VALID_PROFILES,
   normalizeId,
   getHookProfile,
+  isProfilingEnabled,
   getDisabledHookIds,
   parseProfiles,
   isHookEnabled,

package/src/lib/project-detect.js

@@ -3,8 +3,6 @@
  *
  * Cross-platform (Windows, macOS, Linux) project type detection
  * by inspecting files in the working directory.
- *
- * Resolves: https://github.com/affaan-m/everything-claude-code/issues/293
  */
 
 const fs = require('fs');