@kelceyp/caw-server 1.0.272 → 1.0.274

package/dist/pty-wrapper.mjs

@@ -24,6 +24,7 @@ import { join } from 'path';
 import { tmpdir, homedir } from 'os';
 import { execSync } from 'child_process';
 import { readSentinelPayload, hasPendingWork } from './pty-deferred-teardown.mjs';
+import { emitResult as emitResultLine } from './pty-emit-result.mjs';
 
 // --- Arg parsing ---
 
@@ -152,11 +153,35 @@ ensureNonInteractiveSetup(process.cwd());
 
 // --- Deferred teardown state ---
 
-const WATCHDOG_TIMEOUT_MS = 90 * 60 * 1000; // 90 minutes — covers full ScheduleWakeup range (up to 3600s) with 30m headroom
+// 90 minutes — covers full ScheduleWakeup range (up to 3600s) with 30m headroom.
+// The env override (`CAW_PTY_WATCHDOG_TIMEOUT_MS`) exists only so integration
+// tests can exercise the watchdog force-kill path without waiting the full 90m.
+const WATCHDOG_TIMEOUT_MS = Number.parseInt(process.env.CAW_PTY_WATCHDOG_TIMEOUT_MS, 10) || (90 * 60 * 1000);
+
+// D11 test-only env overrides (default off). Precedent: CAW_PTY_WATCHDOG_TIMEOUT_MS above.
+// CAW_PTY_DISABLE_TRANSCRIPT_TAIL: skip all tailTranscript() work (both the
+//   1s polling loop's calls and the final onExit call), so wrapper stdout
+//   carries no `transcript` lines. Used to prove downstream (Task 5) fallback
+//   consumes `result` instead of the missing transcript stream.
+// CAW_PTY_SUPPRESS_STOP_FALLBACK: blank the emitted `result` field on the
+//   success branch of pty-emit-result (only when hookData is non-null and
+//   the success branch runs). Used to prove the AC-5 gate downstream.
+const DISABLE_TRANSCRIPT_TAIL = process.env.CAW_PTY_DISABLE_TRANSCRIPT_TAIL === '1';
+const SUPPRESS_STOP_FALLBACK = process.env.CAW_PTY_SUPPRESS_STOP_FALLBACK === '1';
 
 let watchdogTimer = null;
 let teardownInitiated = false;
 
+// Duration capture: wall clock from `pty.spawn` to top of `teardown()`.
+// `endedAt` is set by whichever teardown path fires first (normal SIGUSR1
+// completion or watchdog force-kill — both routed through `teardown()`,
+// per design Decision D1). The prompt-too-long branch in `onExit` does NOT
+// go through `teardown()`, so `endedAt` remains null and no `durationMs`
+// is emitted (per Decision D3 — service appends the pre-existing `'0'`
+// duration sentinel).
+let startedAt = null;
+let endedAt = null;
+
 // Forward declarations (assigned after ptyProcess is created)
 let ptyProcess = null;
 
@@ -172,7 +197,9 @@ const startOrResetWatchdog = () => {
 const teardown = () => {
     if (teardownInitiated) return;
     teardownInitiated = true;
+    endedAt = Date.now();
     log('Teardown: stop received, no pending work, killing claude');
+    log(`Duration: ${startedAt !== null ? (endedAt - startedAt) : 'unknown'} ms (startedAt=${startedAt}, endedAt=${endedAt})`);
     if (watchdogTimer) { clearTimeout(watchdogTimer); watchdogTimer = null; }
     stopPolling();
     if (ptyProcess) ptyProcess.kill('SIGINT');
@@ -233,6 +260,7 @@ log(`Prompt length: ${prompt.length} chars`);
 
 // --- Spawn claude via PTY ---
 
+startedAt = Date.now();
 ptyProcess = pty.spawn(claudePath, claudeArgs, {
     name: 'xterm-256color',
     cols: 120,
@@ -272,10 +300,38 @@ let transcriptPathResolutionAttempts = 0;
 const processedEntryUUIDs = new Set();
 let lastReadEntryUUID = null;
 
+// Snapshot the pre-existing line count on --resume so only new content streams.
+// Shared by the cwd-hash-hit branch and the D14 hook-path adoption branch —
+// keeping the snapshot in one place avoids duplicating the readFileSync/count
+// logic and satisfies the checklist rule ("Do not duplicate the snapshot
+// logic into the D14 branch").
+const snapshotResumeBaseline = (path) => {
+    if (!resumeId) return;
+    try {
+        const content = readFileSync(path, 'utf-8');
+        transcriptLinesRead = content.trim().split('\n').filter(Boolean).length;
+        log(`Resume: skipping ${transcriptLinesRead} existing transcript lines`);
+    } catch { /* ignore */ }
+};
+
 // 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;
+//
+// D14 (guarded hook-path adoption): callers may pass an `overridePath` — the
+// Stop hook's `hookData.transcript_path`. When supplied, the function bypasses
+// the cwd-hash candidate search and adopts the override path directly (after
+// an existsSync guard). The caller must already have gated on `!transcriptPath`
+// so this is only used when the polling loop never memoised a path — which
+// preserves today's behaviour on every turn the hash convention worked for.
+const resolveTranscriptPath = (overridePath = null) => {
+    if (!overridePath && transcriptPath) return transcriptPath;
+
+    if (overridePath) {
+        if (!existsSync(overridePath)) return null;
+        transcriptPath = overridePath;
+        snapshotResumeBaseline(overridePath);
+        return transcriptPath;
+    }
 
     transcriptPathResolutionAttempts++;
     const claudeProjectsDir = join(homedir(), '.claude', 'projects');
@@ -289,14 +345,7 @@ const resolveTranscriptPath = () => {
         if (existsSync(candidate)) {
             transcriptPath = candidate;
             log(`Transcript found (attempt ${transcriptPathResolutionAttempts}): ${transcriptPath}`);
-            // On resume: snapshot existing line count so only new content streams
-            if (resumeId) {
-                try {
-                    const content = readFileSync(candidate, 'utf-8');
-                    transcriptLinesRead = content.trim().split('\n').filter(Boolean).length;
-                    log(`Resume: skipping ${transcriptLinesRead} existing transcript lines`);
-                } catch { /* ignore */ }
-            }
+            snapshotResumeBaseline(candidate);
             return transcriptPath;
         }
     }
@@ -308,6 +357,11 @@ const resolveTranscriptPath = () => {
 
 // Read new transcript entries and forward to stdout. Returns count of new lines emitted.
 const tailTranscript = () => {
+    // D11 test-only override: skip all tail work so wrapper stdout carries no
+    // `transcript` lines. Both the 1s polling loop's calls and the final
+    // onExit call short-circuit here — the fallback-consumption case downstream
+    // (Task 5) needs a wire with no transcript stream at all.
+    if (DISABLE_TRANSCRIPT_TAIL) return 0;
     const path = resolveTranscriptPath();
     if (!path) return 0;
 
@@ -376,40 +430,37 @@ const tailTranscript = () => {
 };
 
 // --- Sentinel / result emission ---
-// Called from onExit after polling stops. Reads sentinel written by Stop hook.
+// Called from onExit after polling stops. The Stop-hook sentinel is read once
+// at the onExit seam (hoisted out of this delegator) so the parsed payload
+// drives both the D14 hook-path adoption guard AND this emission. On the
+// null-hookData path (ENOENT / JSON-parse failure): resultEmitted /
+// failureEmitted stay false and the prompt-too-long branch below fires as
+// today.
 
 let resultEmitted = false;
 let failureEmitted = false;
 
-const emitResult = () => {
+const emitResult = (hookData) => {
     if (resultEmitted || failureEmitted) return;
-    if (!existsSync(sentinelPath)) return;
-
-    try {
-        const hookData = JSON.parse(readFileSync(sentinelPath, 'utf-8'));
-
-        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}`);
-    }
+    if (!hookData) return;
+
+    // durationMs: wall clock from pty.spawn to teardown(). Both the normal
+    // SIGUSR1 path and the watchdog force-kill path route through teardown()
+    // (Decision D1), so both report an honest real elapsed time. Only omitted
+    // when startedAt/endedAt are unset — which never happens on the success
+    // branch because teardown() runs before onExit calls emitResult().
+    const { emitted } = emitResultLine({
+        hookData,
+        transcriptPath,
+        effectiveSessionId,
+        startedAt,
+        endedAt,
+        alreadyEmitted: resultEmitted || failureEmitted,
+        suppressFallback: SUPPRESS_STOP_FALLBACK,
+        log
+    });
+    if (emitted === 'result') resultEmitted = true;
+    else if (emitted === 'error') failureEmitted = true;
 };
 
 // --- Transcript poll interval ---
@@ -449,14 +500,42 @@ ptyProcess.onExit(({ exitCode }) => {
     if (watchdogTimer) { clearTimeout(watchdogTimer); watchdogTimer = null; }
     stopPolling();
 
+    // Hoisted Stop-hook sentinel read at the onExit → pre-emitResult seam.
+    // The parsed payload (or null on ENOENT / JSON-parse failure) drives both
+    // the D14 hook-path adoption guard below and the emitResult() delegator —
+    // the extracted pty-emit-result.mjs no longer re-reads the sentinel from
+    // disk. Null-hookData path: D14 guard is a no-op (`hookData?.transcript_path`
+    // short-circuits); emitResult() no-ops on the null input; prompt-too-long
+    // branch below fires as today (resultEmitted/failureEmitted stay false).
+    const hookData = readSentinelPayload(sentinelPath);
+
+    // D14 (guarded hook-path adoption): when the 1s polling loop never
+    // memoised a `transcriptPath` (cwd-hash convention produced nothing —
+    // e.g., a client that writes elsewhere, an out-of-tree working directory
+    // hashed differently, or a project-scoped transcript root), adopt the
+    // Stop hook's `hookData.transcript_path` for the final tail. Gated on
+    // `!transcriptPath` so every turn the hash convention worked for keeps
+    // its pre-D14 behaviour byte-for-byte.
+    if (hookData?.transcript_path && !transcriptPath) {
+        const adopted = resolveTranscriptPath(hookData.transcript_path);
+        if (adopted) {
+            log(`Final tail using hook-supplied transcript_path (hash resolution produced nothing, hook-supplied=${adopted})`);
+        }
+    }
+
     // Do a final transcript tail to capture any last entries
     tailTranscript();
 
-    // Read sentinel and emit result or error (tempDir still present — delete after)
-    emitResult();
+    // Emit result or error from the pre-parsed sentinel payload (tempDir still
+    // present — deleted below)
+    emitResult(hookData);
 
-    // Prompt-too-long detection: no sentinel written, ttyBuffer has the error text
+    // Prompt-too-long detection: no sentinel written, ttyBuffer has the error text.
+    // teardown() never ran on this path (Stop hook did not fire), so `endedAt` is
+    // unset and `durationMs` is deliberately omitted from the emission — the
+    // service appends the pre-existing `'0'` duration sentinel (Decision D3).
     if (!resultEmitted && !failureEmitted && ttyBuffer.includes('Prompt is too long')) {
+        log('Prompt-too-long: omitting durationMs (teardown() never ran, endedAt unset)');
         process.stdout.write(JSON.stringify({
             type: 'error',
             error: 'prompt_too_long',