fix: session hook cleanup and timeout

Author: Scoteezy

scripts/session_hook_forwarder.cjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+/**
+ * Session Hook Forwarder
+ * 
+ * This script is executed by Claude's SessionStart hook.
+ * It reads JSON data from stdin and forwards it to Happy's hook server.
+ * 
+ * Usage: echo '{"session_id":"..."}' | node session_hook_forwarder.cjs <port>
+ */
+
+const http = require('http');
+
+const port = parseInt(process.argv[2], 10);
+
+if (!port || isNaN(port)) {
+    process.exit(1);
+}
+
+const chunks = [];
+
+process.stdin.on('data', (chunk) => {
+    chunks.push(chunk);
+});
+
+process.stdin.on('end', () => {
+    const body = Buffer.concat(chunks);
+    
+    const req = http.request({
+        host: '127.0.0.1',
+        port: port,
+        method: 'POST',
+        path: '/hook/session-start',
+        headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': body.length
+        }
+    }, (res) => {
+        res.resume(); // Drain response
+    });
+    
+    req.on('error', () => {
+        // Silently ignore errors - don't break Claude
+    });
+    
+    req.end(body);
+});
+
+process.stdin.resume();
+

src/claude/claudeLocal.ts

@@ -227,5 +227,3 @@ export async function claudeLocal(opts: {
 
     return effectiveSessionId;
 }
-
-export type ClaudeLocalResult = string | null;

src/claude/session.ts

@@ -23,6 +23,9 @@ export class Session {
 
     /** Callbacks to be notified when session ID is found/changed */
     private sessionFoundCallbacks: ((sessionId: string) => void)[] = [];
+    
+    /** Keep alive interval reference for cleanup */
+    private keepAliveInterval: NodeJS.Timeout;
 
     constructor(opts: {
         api: ApiClient,
@@ -54,10 +57,19 @@ export class Session {
 
         // Start keep alive
         this.client.keepAlive(this.thinking, this.mode);
-        setInterval(() => {
+        this.keepAliveInterval = setInterval(() => {
             this.client.keepAlive(this.thinking, this.mode);
         }, 2000);
     }
+    
+    /**
+     * Cleanup resources (call when session is no longer needed)
+     */
+    cleanup = (): void => {
+        clearInterval(this.keepAliveInterval);
+        this.sessionFoundCallbacks = [];
+        logger.debug('[Session] Cleaned up resources');
+    }
 
     onThinkingChange = (thinking: boolean) => {
         this.thinking = thinking;
@@ -113,14 +125,21 @@ export class Session {
 
     /**
      * Consume one-time Claude flags from claudeArgs after Claude spawn
-     * Currently handles: --resume (with or without session ID)
+     * Handles: --resume (with or without session ID), --continue
      */
     consumeOneTimeFlags = (): void => {
         if (!this.claudeArgs) return;
 
         const filteredArgs: string[] = [];
         for (let i = 0; i < this.claudeArgs.length; i++) {
-            if (this.claudeArgs[i] === '--resume') {
+            const arg = this.claudeArgs[i];
+            
+            if (arg === '--continue') {
+                logger.debug('[Session] Consumed --continue flag');
+                continue;
+            }
+            
+            if (arg === '--resume') {
                 // Check if next arg looks like a UUID (contains dashes and alphanumeric)
                 if (i + 1 < this.claudeArgs.length) {
                     const nextArg = this.claudeArgs[i + 1];
@@ -137,9 +156,10 @@ export class Session {
                     // --resume at the end of args
                     logger.debug('[Session] Consumed --resume flag (no session ID)');
                 }
-            } else {
-                filteredArgs.push(this.claudeArgs[i]);
+                continue;
             }
+            
+            filteredArgs.push(arg);
         }
 
         this.claudeArgs = filteredArgs.length > 0 ? filteredArgs : undefined;

src/claude/utils/generateHookSettings.ts

@@ -5,10 +5,11 @@
  * to notify our HTTP server when sessions change (new session, resume, compact, etc.)
  */
 
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { writeFileSync, mkdirSync, unlinkSync, existsSync } from 'node:fs';
 import { configuration } from '@/configuration';
 import { logger } from '@/ui/logger';
+import { projectPath } from '@/projectPath';
 
 /**
  * Generate a temporary settings file with SessionStart hook configuration
@@ -24,9 +25,9 @@ export function generateHookSettingsFile(port: number): string {
     const filename = `session-hook-${process.pid}.json`;
     const filepath = join(hooksDir, filename);
 
-    // Node one-liner that reads stdin and POSTs it to our server
-    // This command is executed by Claude when SessionStart hook fires
-    const hookCommand = `node -e 'const http=require("http");const chunks=[];process.stdin.on("data",c=>chunks.push(c));process.stdin.on("end",()=>{const body=Buffer.concat(chunks);const req=http.request({host:"127.0.0.1",port:${port},method:"POST",path:"/hook/session-start",headers:{"Content-Type":"application/json","Content-Length":body.length}},res=>{res.resume()});req.on("error",()=>{});req.end(body)});process.stdin.resume()'`;
+    // Path to the hook forwarder script
+    const forwarderScript = resolve(projectPath(), 'scripts', 'session_hook_forwarder.cjs');
+    const hookCommand = `node "${forwarderScript}" ${port}`;
 
     const settings = {
         hooks: {

src/claude/utils/startHookServer.ts

@@ -48,11 +48,21 @@ export async function startHookServer(options: HookServerOptions): Promise<HookS
         const server: Server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
             // Only handle POST to /hook/session-start
             if (req.method === 'POST' && req.url === '/hook/session-start') {
+                // Set timeout to prevent hanging if Claude doesn't close stdin
+                const timeout = setTimeout(() => {
+                    if (!res.headersSent) {
+                        logger.debug('[hookServer] Request timeout');
+                        res.writeHead(408).end('timeout');
+                    }
+                }, 5000);
+
                 try {
                     const chunks: Buffer[] = [];
                     for await (const chunk of req) {
                         chunks.push(chunk as Buffer);
                     }
+                    clearTimeout(timeout);
+                    
                     const body = Buffer.concat(chunks).toString('utf-8');
                     logger.debug('[hookServer] Received session hook:', body);
 
@@ -74,6 +84,7 @@ export async function startHookServer(options: HookServerOptions): Promise<HookS
 
                     res.writeHead(200, { 'Content-Type': 'text/plain' }).end('ok');
                 } catch (error) {
+                    clearTimeout(timeout);
                     logger.debug('[hookServer] Error handling session hook:', error);
                     if (!res.headersSent) {
                         res.writeHead(500).end('error');