@kelceyp/caw-server 1.0.230 → 1.0.233

package/dist/pty-wrapper.mjs

@@ -98,19 +98,15 @@ writeFileSync(hookScriptPath, hookScript, { mode: 0o755 });
 
 // --- Write settings file with Stop hook config ---
 
+const hookEntry = {
+    matcher: '',
+    hooks: [{ type: 'command', command: hookScriptPath }]
+};
+
 const settings = {
     hooks: {
-        Stop: [
-            {
-                matcher: '',
-                hooks: [
-                    {
-                        type: 'command',
-                        command: hookScriptPath
-                    }
-                ]
-            }
-        ]
+        Stop: [hookEntry],
+        StopFailure: [hookEntry]
     }
 };
 writeFileSync(settingsPath, JSON.stringify(settings));
@@ -156,7 +152,7 @@ ensureNonInteractiveSetup(process.cwd());
 
 // --- Deferred teardown state ---
 
-const WATCHDOG_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+const WATCHDOG_TIMEOUT_MS = 90 * 60 * 1000; // 90 minutes — covers full ScheduleWakeup range (up to 3600s) with 30m headroom
 
 let watchdogTimer = null;
 let teardownInitiated = false;
@@ -194,6 +190,11 @@ process.on('SIGUSR1', () => {
         teardown();
         return;
     }
+    if (payload.error) {
+        log(`StopFailure received: error=${payload.error}`);
+        teardown();
+        return;
+    }
     const bgCount = Array.isArray(payload.background_tasks) ? payload.background_tasks.length : 0;
     const cronCount = Array.isArray(payload.session_crons) ? payload.session_crons.length : 0;
     log(`Sentinel: background_tasks=${bgCount}, session_crons=${cronCount}`);
@@ -267,23 +268,27 @@ ptyProcess.onData((data) => {
 
 let transcriptPath = null;
 let transcriptLinesRead = 0;
+let transcriptPathResolutionAttempts = 0;
+const processedEntryUUIDs = new Set();
+let lastReadEntryUUID = null;
 
 // Resolve transcript path, handling macOS /tmp → /private/tmp symlinks.
 // Returns null if not yet found (retried on next poll).
 const resolveTranscriptPath = () => {
     if (transcriptPath) return transcriptPath;
 
+    transcriptPathResolutionAttempts++;
     const claudeProjectsDir = join(homedir(), '.claude', 'projects');
     const cwd = process.cwd();
     const paths = new Set([cwd]);
     try { paths.add(realpathSync(cwd)); } catch { /* ignore */ }
 
     for (const dir of paths) {
-        const hash = dir.replace(/\//g, '-');
+        const hash = dir.replace(/[/.]/g, '-');
         const candidate = join(claudeProjectsDir, hash, `${effectiveSessionId}.jsonl`);
         if (existsSync(candidate)) {
             transcriptPath = candidate;
-            log(`Transcript found: ${transcriptPath}`);
+            log(`Transcript found (attempt ${transcriptPathResolutionAttempts}): ${transcriptPath}`);
             // On resume: snapshot existing line count so only new content streams
             if (resumeId) {
                 try {
@@ -295,6 +300,9 @@ const resolveTranscriptPath = () => {
             return transcriptPath;
         }
     }
+    if (transcriptPathResolutionAttempts === 1 || transcriptPathResolutionAttempts % 10 === 0) {
+        log(`Transcript not found (attempt ${transcriptPathResolutionAttempts}), cwd=${cwd}, session=${effectiveSessionId}`);
+    }
     return null;
 };
 
@@ -307,19 +315,62 @@ const tailTranscript = () => {
     try {
         const content = readFileSync(path, 'utf-8');
         const lines = content.trim().split('\n').filter(Boolean);
+        const fileLineCount = lines.length;
+
+        if (fileLineCount < transcriptLinesRead) {
+            log(`tailTranscript: FILE SHRINK — transcriptLinesRead=${transcriptLinesRead}, fileLines=${fileLineCount} (file replaced or truncated), resetting to 0`);
+            transcriptLinesRead = 0;
+        } else if (transcriptLinesRead > 0 && lastReadEntryUUID) {
+            try {
+                const checkEntry = JSON.parse(lines[transcriptLinesRead - 1]);
+                if (checkEntry.uuid && checkEntry.uuid !== lastReadEntryUUID) {
+                    log(`tailTranscript: FILE REPLACED — UUID mismatch at position ${transcriptLinesRead - 1} (expected ${lastReadEntryUUID}, got ${checkEntry.uuid}), resetting to 0`);
+                    transcriptLinesRead = 0;
+                }
+            } catch { /* parse error during write — skip validation this poll */ }
+        }
+
+        const pending = fileLineCount - transcriptLinesRead;
+        if (pending > 0) {
+            log(`tailTranscript: ${pending} new lines (fileLines=${fileLineCount}, read=${transcriptLinesRead})`);
+        }
+
+        const typeCounts = {};
+        let skipped = 0;
         for (let i = transcriptLinesRead; i < lines.length; i++) {
             try {
                 const entry = JSON.parse(lines[i]);
-                if (entry.type === 'progress' && entry.data?.type === 'hook_progress') continue;
+                if (entry.type === 'progress' && entry.data?.type === 'hook_progress') {
+                    skipped++;
+                    continue;
+                }
+                if (entry.uuid && processedEntryUUIDs.has(entry.uuid)) {
+                    skipped++;
+                    continue;
+                }
                 process.stdout.write(JSON.stringify({ type: 'transcript', entry }) + '\n');
+                if (entry.uuid) processedEntryUUIDs.add(entry.uuid);
                 newLines++;
+                const key = entry.type || 'unknown';
+                typeCounts[key] = (typeCounts[key] || 0) + 1;
             } catch {
-                // Skip unparseable lines
+                skipped++;
             }
         }
         transcriptLinesRead = lines.length;
-    } catch {
-        // File may not exist yet or be mid-write — retry on next poll
+        if (lines.length > 0) {
+            try {
+                const lastEntry = JSON.parse(lines[lines.length - 1]);
+                if (lastEntry.uuid) lastReadEntryUUID = lastEntry.uuid;
+            } catch { /* ignore */ }
+        }
+
+        if (newLines > 0 || skipped > 0) {
+            const types = Object.entries(typeCounts).map(([k, v]) => `${k}=${v}`).join(', ');
+            log(`tailTranscript: forwarded=${newLines}, skipped=${skipped}${types ? `, types: ${types}` : ''}`);
+        }
+    } catch (err) {
+        log(`tailTranscript: read error: ${err.message}`);
     }
     return newLines;
 };
@@ -328,24 +379,34 @@ const tailTranscript = () => {
 // Called from onExit after polling stops. Reads sentinel written by Stop hook.
 
 let resultEmitted = false;
+let failureEmitted = false;
 
 const emitResult = () => {
-    if (resultEmitted) return;
+    if (resultEmitted || failureEmitted) return;
     if (!existsSync(sentinelPath)) return;
 
     try {
         const hookData = JSON.parse(readFileSync(sentinelPath, 'utf-8'));
-        const result = {
-            type: 'result',
-            result: hookData.last_assistant_message || '',
-            metadata: {
-                sessionId: hookData.session_id || effectiveSessionId,
-                transcriptPath: hookData.transcript_path || transcriptPath || null,
-                permissionMode: hookData.permission_mode || null
-            }
-        };
-        process.stdout.write(JSON.stringify(result) + '\n');
-        resultEmitted = true;
+
+        if (hookData.error) {
+            process.stdout.write(JSON.stringify({
+                type: 'error',
+                error: hookData.error,
+                message: hookData.last_assistant_message || ''
+            }) + '\n');
+            failureEmitted = true;
+        } else {
+            process.stdout.write(JSON.stringify({
+                type: 'result',
+                result: hookData.last_assistant_message || '',
+                metadata: {
+                    sessionId: hookData.session_id || effectiveSessionId,
+                    transcriptPath: hookData.transcript_path || transcriptPath || null,
+                    permissionMode: hookData.permission_mode || null
+                }
+            }) + '\n');
+            resultEmitted = true;
+        }
     } catch (err) {
         log(`Error reading sentinel: ${err.message}`);
     }
@@ -391,16 +452,27 @@ ptyProcess.onExit(({ exitCode }) => {
     // Do a final transcript tail to capture any last entries
     tailTranscript();
 
-    // Read sentinel and emit result (tempDir still present — delete after)
+    // Read sentinel and emit result or error (tempDir still present — delete after)
     emitResult();
 
+    // Prompt-too-long detection: no sentinel written, ttyBuffer has the error text
+    if (!resultEmitted && !failureEmitted && ttyBuffer.includes('Prompt is too long')) {
+        process.stdout.write(JSON.stringify({
+            type: 'error',
+            error: 'prompt_too_long',
+            message: 'Prompt is too long'
+        }) + '\n');
+        failureEmitted = true;
+    }
+
     // Clean up temp directory
     try { rmSync(tempDir, { recursive: true, force: true }); } catch {}
 
     log(`Claude exited (code: ${exitCode})`);
 
-    // Exit 0 if result was successfully emitted (includes SIGINT 130 remap),
-    // or if claude itself exited cleanly. Otherwise propagate exit code.
+    if (failureEmitted) {
+        process.exit(1);
+    }
     if (resultEmitted || exitCode === 0) {
         process.exit(0);
     }