@goodfoot/claude-code-hooks 1.0.17 → 1.0.19

package/dist/cli.js

@@ -16,7 +16,6 @@
  */
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import * as esbuild from "esbuild";
 import { glob } from "glob";
@@ -374,46 +373,53 @@ async function discoverHookFiles(pattern, cwd) {
 /**
  * Compiles a TypeScript hook file to a self-contained ESM executable.
  *
- * Creates a wrapper that imports the hook and calls execute(), then bundles
- * everything together including the runtime.
+ * Uses esbuild's stdin option to avoid writing temporary wrapper files to disk.
+ * This produces stable, reproducible builds by:
+ * - Using a distinct sourcefile name to avoid import resolution conflicts
+ * - Eliminating environment-specific temp paths from source comments
+ *
+ * Uses a two-step process to generate stable content hashes:
+ * 1. Compile WITHOUT sourcemaps → generate stable content hash
+ * 2. Compile WITH sourcemaps → final output content
+ *
  * @param options - Compilation options
- * @returns Compiled output content as a string
+ * @returns Compiled content and stable content hash
  */
 async function compileHook(options) {
     const { sourcePath, logFilePath } = options;
-    // Create a temporary wrapper file that imports the hook and executes it
-    // Use system temp directory with deterministic name based on hook basename (not full path)
-    // This ensures builds are reproducible across different environments/machines
-    const hashInputs = [path.basename(sourcePath), logFilePath ? "log" : ""].join(":");
-    const buildHash = crypto.createHash("sha256").update(hashInputs).digest("hex").substring(0, 16);
-    const tempDir = path.join(os.tmpdir(), "claude-code-hooks-build", buildHash);
-    const wrapperPath = path.join(tempDir, "wrapper.ts");
-    const tempOutput = path.join(tempDir, "output.mjs");
     // Get the path to the runtime module (relative to this CLI)
     const runtimePath = path.resolve(path.dirname(new URL(import.meta.url).pathname), "./runtime.js");
-    // Ensure temp directory exists (don't delete - concurrent builds may be using it)
-    fs.mkdirSync(tempDir, { recursive: true });
     // Build log file injection code if specified
     const logFileInjection = logFilePath !== undefined
         ? `process.env['CLAUDE_CODE_HOOKS_CLI_LOG_FILE'] = ${JSON.stringify(logFilePath)};\n`
         : "";
-    // Create wrapper that imports the hook and calls execute
+    // Create wrapper content that imports the hook and calls execute
+    // Uses absolute paths to avoid resolution issues
     const wrapperContent = `${logFileInjection}
 import hook from '${sourcePath.replace(/\\/g, "/")}';
 import { execute } from '${runtimePath.replace(/\\/g, "/")}';
 
 execute(hook);
 `;
-    fs.writeFileSync(wrapperPath, wrapperContent, "utf-8");
-    await esbuild.build({
-        entryPoints: [wrapperPath],
-        outfile: tempOutput,
+    // Use stdin instead of a temp file - sourcefile becomes the stable reference
+    // The sourcefile name must be distinct from the actual source file to avoid
+    // esbuild resolving the import to the stdin content instead of the real file
+    const baseName = path.basename(sourcePath, path.extname(sourcePath));
+    const stdinOptions = {
+        contents: wrapperContent,
+        resolveDir: path.dirname(sourcePath),
+        sourcefile: `${baseName}-entry.ts`,
+        loader: "ts",
+    };
+    // Common esbuild options
+    const commonOptions = {
+        stdin: stdinOptions,
         format: "esm",
         platform: "node",
         target: "node20",
         bundle: true,
-        sourcemap: "inline",
         minify: false,
+        write: false, // Return content directly via outputFiles
         // Keep node built-ins external
         external: [
             "node:*",
@@ -437,11 +443,27 @@ execute(hook);
         // Ensure we get clean ESM output
         mainFields: ["module", "main"],
         conditions: ["import", "node"],
+    };
+    // Step 1: Compile WITHOUT sourcemaps to generate stable content hash
+    const resultNoSourcemap = await esbuild.build({
+        ...commonOptions,
+        sourcemap: false,
+    });
+    const contentForHash = resultNoSourcemap.outputFiles?.[0]?.text;
+    if (contentForHash === undefined) {
+        throw new Error(`esbuild produced no output for ${sourcePath}`);
+    }
+    const contentHash = generateContentHash(contentForHash);
+    // Step 2: Compile WITH sourcemaps for final output
+    const resultWithSourcemap = await esbuild.build({
+        ...commonOptions,
+        sourcemap: "inline",
     });
-    // Read and return the compiled content
-    // Don't delete temp directory - allows concurrent builds of same source
-    // and the OS will clean up /tmp periodically
-    return fs.readFileSync(tempOutput, "utf-8");
+    const content = resultWithSourcemap.outputFiles?.[0]?.text;
+    if (content === undefined) {
+        throw new Error(`esbuild produced no output for ${sourcePath}`);
+    }
+    return { content, contentHash };
 }
 /**
  * Generates a content hash (SHA-256, 8-char prefix) for a compiled hook.
@@ -476,19 +498,17 @@ async function compileAllHooks(options) {
             matcher: metadata.matcher,
             timeout: metadata.timeout,
         });
-        // Compile the hook
+        // Compile the hook (two-step process for stable content hash)
         log("info", `Compiling: ${sourcePath}`);
-        const compiledContent = await compileHook({ sourcePath, outputDir, logFilePath });
-        // Generate content hash
-        const hash = generateContentHash(compiledContent);
-        // Determine output filename
+        const { content, contentHash } = await compileHook({ sourcePath, outputDir, logFilePath });
+        // Determine output filename using the stable content hash
         const baseName = path.basename(sourcePath, path.extname(sourcePath));
-        const outputFilename = `${baseName}.${hash}.mjs`;
+        const outputFilename = `${baseName}.${contentHash}.mjs`;
         const outputPath = path.join(outputDir, outputFilename);
         // Write compiled output with shebang for direct execution
         // --enable-source-maps enables stack traces with original source locations
         const shebang = "#!/usr/bin/env -S node --enable-source-maps\n";
-        fs.writeFileSync(outputPath, shebang + compiledContent, { encoding: "utf-8", mode: 0o755 });
+        fs.writeFileSync(outputPath, shebang + content, { encoding: "utf-8", mode: 0o755 });
         log("info", `Wrote: ${outputPath}`);
         compiledHooks.push({
             sourcePath,

package/dist/scaffold.js

@@ -117,7 +117,7 @@ function generatePackageJson(projectName, outputPath) {
             "@goodfoot/claude-code-hooks": "^1.0.9",
         },
         devDependencies: {
-            "@biomejs/biome": "2.3.13",
+            "@biomejs/biome": "2.3.14",
             "@types/node": "^22.0.0",
             typescript: "^5.9.3",
             vitest: "^4.0.16",
@@ -160,7 +160,7 @@ function generateTsConfig() {
  */
 function generateBiomeConfig() {
     return `{
-  "$schema": "https://biomejs.dev/schemas/2.3.13/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.3.14/schema.json",
   "formatter": {
     "enabled": true,
     "indentStyle": "space",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodfoot/claude-code-hooks",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Type-safe Claude Code hooks library with camelCase types and output builders",
   "homepage": "https://github.com/goodfoot-io/marketplace/tree/main/packages/claude-code-hooks",
   "repository": {
@@ -53,8 +53,8 @@
     "typescript": "^5.9.3"
   },
   "devDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.22",
-    "@biomejs/biome": "2.3.13",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.31",
+    "@biomejs/biome": "2.3.14",
     "@types/node": "^24",
     "ts-morph": "^25.0.0",
     "tsx": "^4.20.3",

package/types/cli.d.ts

@@ -151,15 +151,31 @@ interface CompileHookOptions {
     /** Optional log file path to inject into compiled hook. */
     logFilePath?: string;
 }
+/**
+ * Result of compiling a hook.
+ */
+interface CompileHookResult {
+    /** Compiled content WITH sourcemaps (for final output). */
+    content: string;
+    /** Stable content hash generated from sourcemap-free output. */
+    contentHash: string;
+}
 /**
  * Compiles a TypeScript hook file to a self-contained ESM executable.
  *
- * Creates a wrapper that imports the hook and calls execute(), then bundles
- * everything together including the runtime.
+ * Uses esbuild's stdin option to avoid writing temporary wrapper files to disk.
+ * This produces stable, reproducible builds by:
+ * - Using a distinct sourcefile name to avoid import resolution conflicts
+ * - Eliminating environment-specific temp paths from source comments
+ *
+ * Uses a two-step process to generate stable content hashes:
+ * 1. Compile WITHOUT sourcemaps → generate stable content hash
+ * 2. Compile WITH sourcemaps → final output content
+ *
  * @param options - Compilation options
- * @returns Compiled output content as a string
+ * @returns Compiled content and stable content hash
  */
-declare function compileHook(options: CompileHookOptions): Promise<string>;
+declare function compileHook(options: CompileHookOptions): Promise<CompileHookResult>;
 /**
  * Generates a content hash (SHA-256, 8-char prefix) for a compiled hook.
  * @param content - Compiled hook content

package/types/types.d.ts

@@ -307,13 +307,7 @@ export type SubagentStartInput = SDKSubagentStartHookInput;
  * ```
  * @see https://code.claude.com/docs/en/hooks#subagentstop
  */
-export interface SubagentStopInput extends SDKSubagentStopHookInput {
-    /**
-     * Type of subagent that is stopping.
-     * Examples: 'explore', 'codebase-analysis', custom agent types
-     */
-    agent_type: string;
-}
+export type SubagentStopInput = SDKSubagentStopHookInput;
 /**
  * Input for PreCompact hooks.
  *