lark-remote 0.1.0

package/dist/runner/common/exec-translator.js

@@ -0,0 +1,105 @@
+/**
+ * Abstract base class for exec-stream translators (codex, opencode, pi, kimi).
+ *
+ * Encapsulates the shared state machine and guard logic that was duplicated
+ * across every concrete translator:
+ *   - Terminal-state tracking (idempotent `finish()`)
+ *   - `translate()` guard (terminal → []; non-record / non-string-type → anomaly)
+ *   - `recordUnknownEvent()` helper (warn-logs unknown event types)
+ *   - Session / usage / error getters
+ *
+ * Subclasses provide:
+ *   - `logTag` — prefix for warn logs
+ *   - `streamEndedMessage()` — agent-specific "stream ended early" message
+ *   - `translateEvent(raw)` — agent-specific event dispatch
+ *
+ * @see SpawningRunner for the runner that consumes translators
+ */
+import { getLogger } from '../../logger/index.js';
+import { isRecord } from '../../common/guards.js';
+// ---------------------------------------------------------------------------
+// Abstract base class
+// ---------------------------------------------------------------------------
+export class ExecTranslator {
+    // --- Shared state ---
+    terminal = false;
+    lastError;
+    lastUsage;
+    terminalErrorMessage;
+    terminalErrorFromAgent = false;
+    sessionId;
+    startedTools = new Set();
+    // --- translate() guard (shared) ---
+    /** Translate a single parsed ndjson line into zero or more `AgentEvent`s.
+     *  P3-3: filter paths (terminal / non-record / non-string-type) return `null`
+     *  instead of `[]` to avoid a throwaway array allocation per non-emitting
+     *  event on codex/opencode hot paths. The consumer (SpawningRunner) already
+     *  handles `null` via `Array.isArray` + null guards. */
+    translate(raw) {
+        if (this.terminal)
+            return null;
+        if (!isRecord(raw) || typeof raw.type !== 'string') {
+            return null;
+        }
+        return this.translateEvent(raw);
+    }
+    // --- recordUnknownEvent helper ---
+    /** Warn-log an unknown event type and return `null` (P3-3: no throwaway []). */
+    recordUnknownEvent(type) {
+        getLogger().warn(`${this.logTag} unknown event type: ${type}`);
+        return null;
+    }
+    // --- finish() (shared, idempotent) ---
+    /**
+     * Called when the stream ends without a natural terminal event.
+     *
+     * - Marks the translator terminal (idempotent — second call returns `[]`).
+     * - For `reason='failed'`, stores `terminalErrorMessage` so the runner can
+     *   surface it via `buildResultEvent({translatorError})`.
+     * - Returns `[]` — the runner is responsible for emitting the result event.
+     */
+    finish(reason = 'failed') {
+        if (this.terminal)
+            return [];
+        this.terminal = true;
+        if (reason === 'failed') {
+            const detail = this.lastError ? `: ${this.lastError}` : '';
+            this.terminalErrorMessage = `${this.streamEndedMessage()}${detail}`;
+        }
+        // interrupted / timeout: no terminalErrorMessage — the runner's
+        // stoppedByUser flag (set by base class stop()) drives the result subtype.
+        return [];
+    }
+    // --- Getters (shared) ---
+    /** Whether a terminal event has already been seen. */
+    isTerminal() {
+        return this.terminal;
+    }
+    /** Session ID captured from the agent stream (for the result event). */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /** Token usage captured from the terminal event (for the success result event). */
+    getLastUsage() {
+        return this.lastUsage;
+    }
+    /**
+     * Terminal error message captured from an agent-reported error or
+     * `finish('failed')`. Returns `undefined` if no terminal error occurred.
+     */
+    getTerminalError() {
+        return this.terminalErrorMessage;
+    }
+    /**
+     * True iff `getTerminalError()` was populated by an agent-reported terminal
+     * error (e.g. codex `turn.failed`). The runner uses this to pick the correct
+     * root cause for `buildResultEvent`: agent errors override signal/non-zero-code
+     * (the agent error is the root cause), but stream-ended-early errors
+     * (`finish('failed')`) yield to signal/non-zero-code (the signal is the root
+     * cause and the early stream-end is a symptom).
+     */
+    hasAgentTerminalError() {
+        return this.terminalErrorFromAgent;
+    }
+}
+//# sourceMappingURL=exec-translator.js.map

package/dist/runner/common/jsonl-stream.d.ts

@@ -0,0 +1,39 @@
+import type { AgentEvent } from '../types.js';
+import type { Readable } from 'node:stream';
+/** Options for {@link createJSONLStream}. */
+interface JSONLStreamOptions {
+    onParseError?: (line: string) => void;
+    /**
+     * Pause stdout once `lineQueue` exceeds this depth (P1-4 backpressure).
+     * Default 100 (matches production; tests may pass a smaller value).
+     */
+    pauseThreshold?: number;
+    /**
+     * Resume stdout once `lineQueue` drains to or below this depth. Must be
+     * <= `pauseThreshold`. Only meaningful when `pauseThreshold > 0`.
+     */
+    resumeThreshold?: number;
+}
+/**
+ * Parse JSONL (newline-delimited JSON) from a readable stream.
+ *
+ * Handles:
+ * - Partial lines at buffer boundaries
+ * - Trailing incomplete lines (flush on stream end/close)
+ * - JSON parse errors: when `options.onParseError` is provided, bad lines are
+ *   forwarded to the callback; otherwise a warning is logged via getLogger().warn
+ *   and the line is skipped.
+ * - Optional backpressure (P1-4): when `pauseThreshold` is set, stdout is
+ *   paused once the parsed-line queue exceeds the threshold and resumed once
+ *   the consumer drains it back below `resumeThreshold`, bounding memory in
+ *   long runs where the producer (agent stdout) outpaces the consumer (card
+ *   rendering + SDK patch).
+ *
+ * This is the core stream parsing logic shared by Claude, Pi, and other
+ * agents that emit JSONL output.
+ *
+ * Note: timestamp generation is delegated to each runner's translate method
+ * (统一方案：所有 runner 自己生成 timestamp).
+ */
+export declare function createJSONLStream(stdout: Readable, options?: JSONLStreamOptions): AsyncGenerator<AgentEvent>;
+export {};

package/dist/runner/common/jsonl-stream.js

@@ -0,0 +1,203 @@
+import { getLogger } from '../../logger/index.js';
+/**
+ * Parse JSONL (newline-delimited JSON) from a readable stream.
+ *
+ * Handles:
+ * - Partial lines at buffer boundaries
+ * - Trailing incomplete lines (flush on stream end/close)
+ * - JSON parse errors: when `options.onParseError` is provided, bad lines are
+ *   forwarded to the callback; otherwise a warning is logged via getLogger().warn
+ *   and the line is skipped.
+ * - Optional backpressure (P1-4): when `pauseThreshold` is set, stdout is
+ *   paused once the parsed-line queue exceeds the threshold and resumed once
+ *   the consumer drains it back below `resumeThreshold`, bounding memory in
+ *   long runs where the producer (agent stdout) outpaces the consumer (card
+ *   rendering + SDK patch).
+ *
+ * This is the core stream parsing logic shared by Claude, Pi, and other
+ * agents that emit JSONL output.
+ *
+ * Note: timestamp generation is delegated to each runner's translate method
+ * (统一方案：所有 runner 自己生成 timestamp).
+ */
+export function createJSONLStream(stdout, options) {
+    const lineQueue = [];
+    // P3-1: accumulate partial-line fragments in an array instead of repeatedly
+    // string-concatenating a growing `partialLine`. A huge single JSON line
+    // (large tool_result / text_end) spanning many chunks caused O(n²) copies:
+    // each chunk rebuilt `partialLine + text` over the whole accumulated prefix.
+    // With a fragment array, we join only once per chunk (at the line boundary)
+    // and push complete lines; the residual tail stays as array fragments until
+    // the next newline or stream end. Net allocation: O(n) instead of O(n²).
+    const partialFragments = [];
+    // P2-14: accumulated byte length of partialFragments. Backpressure (above)
+    // only counts COMPLETE lines in lineQueue; a never-newline stream (malformed
+    // output, binary garbage) accumulates fragments without ever completing a
+    // line, so pause never fires and memory grows unbounded. Cap the partial
+    // line at 10MB: once exceeded, flush it as a bad line via onParseError and
+    // reset the buffer, bounding peak memory for a single pathological line.
+    const PARTIAL_BYTE_LIMIT = 10 * 1024 * 1024;
+    let partialBytes = 0;
+    const completeLines = [];
+    let done = false;
+    let resolveNext = null;
+    // P1-4 backpressure thresholds. Default matches production (100).
+    const pauseThreshold = options?.pauseThreshold ?? 100;
+    // Default low-water mark is half the high-water mark for meaningful hysteresis
+    // (avoids per-line pause/resume thrashing when callers don't set it explicitly).
+    let resumeThreshold = options?.resumeThreshold ?? Math.max(0, Math.floor(pauseThreshold / 2));
+    // Clamp misconfiguration: resumeThreshold > pauseThreshold would resume at queue
+    // high water then immediately re-pause on the next line → thrash (P1-4 review nit).
+    if (resumeThreshold > pauseThreshold)
+        resumeThreshold = pauseThreshold;
+    let paused = false;
+    function notify() {
+        if (resolveNext) {
+            resolveNext();
+            resolveNext = null;
+        }
+    }
+    // Flush any trailing partial line and mark the stream finished. Shared by the
+    // 'end'/'close'/'error' handlers so flush logic lives in one place (P1-4 review nit).
+    function flushAndFinish() {
+        if (partialFragments.length > 0) {
+            const trimmed = partialFragments.join('').trim();
+            if (trimmed)
+                lineQueue.push(trimmed);
+            partialFragments.length = 0;
+            partialBytes = 0;
+        }
+        done = true;
+        notify();
+    }
+    // P2-14: flush an oversize partial line as a bad line. When partialFragments
+    // exceeds the byte cap, the partial line is treated as malformed (a single
+    // JSON line should never reach 10MB) and reported via onParseError rather
+    // than accumulated indefinitely. Resets the buffer so a pathological stream
+    // cannot leak memory line after line.
+    function flushOversizePartial() {
+        if (partialFragments.length === 0)
+            return;
+        const line = partialFragments.join('');
+        partialFragments.length = 0;
+        partialBytes = 0;
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        if (options?.onParseError) {
+            options.onParseError(trimmed);
+        }
+        else {
+            getLogger().warn(`[jsonl-stream] dropped oversize partial line (${line.length} bytes)`);
+        }
+    }
+    // Apply backpressure after pushing new lines: pause stdout when the queue
+    // exceeds the high-water mark so the producer stops feeding until the
+    // consumer drains it. P1-4 bounds memory in long runs.
+    function maybePause() {
+        if (pauseThreshold > 0 && !paused && lineQueue.length > pauseThreshold) {
+            paused = true;
+            stdout.pause();
+        }
+    }
+    // Release backpressure after consuming a line: resume stdout once the queue
+    // drains to the low-water mark so the producer can feed again.
+    function maybeResume() {
+        if (paused && lineQueue.length <= resumeThreshold) {
+            paused = false;
+            stdout.resume();
+        }
+    }
+    stdout.on('data', (chunk) => {
+        const text = chunk.toString('utf-8');
+        // P3-1: split on newlines. The first segment continues the pending partial
+        // line (joined with accumulated fragments — one join per chunk, not per
+        // byte); subsequent segments are complete lines. The last segment is the
+        // new partial tail (kept as a single fragment).
+        const segments = text.split('\n');
+        if (segments.length === 1) {
+            // No newline in this chunk: the whole chunk is a partial fragment.
+            partialFragments.push(segments[0]);
+            partialBytes += segments[0].length;
+            // P2-14: cap the partial line. A never-newline stream would otherwise
+            // accumulate fragments without bound (backpressure only counts complete
+            // lines). Flush as a bad line once the byte cap is exceeded.
+            if (partialBytes > PARTIAL_BYTE_LIMIT) {
+                flushOversizePartial();
+            }
+        }
+        else {
+            // First segment completes the pending line.
+            partialFragments.push(segments[0]);
+            partialBytes += segments[0].length;
+            completeLines.push(partialFragments.join(''));
+            partialFragments.length = 0;
+            partialBytes = 0;
+            // Middle segments are each complete lines.
+            for (let i = 1; i < segments.length - 1; i++) {
+                completeLines.push(segments[i]);
+            }
+            // Last segment is the new partial tail.
+            partialFragments.push(segments[segments.length - 1]);
+            partialBytes = segments[segments.length - 1].length;
+            // P2-14: the trailing partial tail can itself exceed the cap if a single
+            // chunk is larger than 10MB with no internal newline.
+            if (partialBytes > PARTIAL_BYTE_LIMIT) {
+                flushOversizePartial();
+            }
+        }
+        // Push complete lines into the queue (skipping blank/whitespace-only).
+        for (const line of completeLines) {
+            const trimmed = line.trim();
+            if (trimmed)
+                lineQueue.push(trimmed);
+        }
+        completeLines.length = 0;
+        notify();
+        maybePause();
+    });
+    stdout.on('end', () => {
+        flushAndFinish();
+    });
+    stdout.on('close', () => {
+        flushAndFinish();
+    });
+    // P1-4: handle stdout 'error' so the generator terminates instead of
+    // hanging forever on the `await new Promise` below. Without this, a stdout
+    // error (e.g. broken pipe, runner crash) leaves the consumer awaiting a
+    // notify that never comes → bridge serial queue blocks permanently. We do
+    // not re-throw the error through the generator (the runner's `try/catch`
+    // around `for await` and the proc 'close' path already surface failures via
+    // the unified result event); we only guarantee the generator ends. The error
+    // is logged for diagnosis.
+    stdout.on('error', (err) => {
+        getLogger().warn(`[jsonl-stream] stdout error: ${err.message}`);
+        flushAndFinish();
+    });
+    async function* generator() {
+        while (true) {
+            while (lineQueue.length > 0) {
+                const line = lineQueue.shift();
+                try {
+                    yield JSON.parse(line);
+                }
+                catch {
+                    if (options?.onParseError) {
+                        options.onParseError(line);
+                    }
+                    else {
+                        getLogger().warn(`[jsonl-stream] failed to parse JSONL: ${line.slice(0, 100)}`);
+                    }
+                }
+                maybeResume();
+            }
+            if (done)
+                return;
+            await new Promise((r) => {
+                resolveNext = r;
+            });
+        }
+    }
+    return generator();
+}
+//# sourceMappingURL=jsonl-stream.js.map

package/dist/runner/common/process-stopper.d.ts

@@ -0,0 +1,28 @@
+import type { ChildProcess } from 'node:child_process';
+interface ProcessStopperOptions {
+    graceMs: number;
+}
+interface StopOptions {
+    immediate?: boolean;
+}
+/**
+ * Unified process stop logic: SIGTERM → grace period → SIGKILL.
+ *
+ * Extracts the common pattern shared by ClaudeRunner and BashProcessRunner
+ * so both use identical stop semantics.
+ */
+export declare class ProcessStopper {
+    private graceMs;
+    constructor(opts: ProcessStopperOptions);
+    /**
+     * Stop a child process: SIGTERM → wait grace → SIGKILL.
+     *
+     * Uses negative PID to kill the entire process group, ensuring child
+     * processes (shell wrappers, sub-processes) are also terminated.
+     *
+     * Pass `immediate: true` to skip the grace window — SIGTERM and SIGKILL
+     * are sent back-to-back. Safe to call on an already-exited process.
+     */
+    stop(proc: ChildProcess, opts?: StopOptions): Promise<void>;
+}
+export {};

package/dist/runner/common/process-stopper.js

@@ -0,0 +1,79 @@
+import { getLogger } from '../../logger/index.js';
+/**
+ * Unified process stop logic: SIGTERM → grace period → SIGKILL.
+ *
+ * Extracts the common pattern shared by ClaudeRunner and BashProcessRunner
+ * so both use identical stop semantics.
+ */
+export class ProcessStopper {
+    graceMs;
+    constructor(opts) {
+        this.graceMs = opts.graceMs;
+    }
+    /**
+     * Stop a child process: SIGTERM → wait grace → SIGKILL.
+     *
+     * Uses negative PID to kill the entire process group, ensuring child
+     * processes (shell wrappers, sub-processes) are also terminated.
+     *
+     * Pass `immediate: true` to skip the grace window — SIGTERM and SIGKILL
+     * are sent back-to-back. Safe to call on an already-exited process.
+     */
+    async stop(proc, opts) {
+        if (!proc || proc.exitCode !== null || proc.signalCode !== null) {
+            return;
+        }
+        const pid = proc.pid;
+        if (pid === undefined) {
+            return;
+        }
+        // Use negative PID to kill the entire process group.
+        // This ensures child processes (shell wrappers, sub-processes) are also killed.
+        // If the process is not a group leader, kill(-pid) behaves same as kill(pid).
+        const pgid = -pid;
+        const immediate = opts?.immediate === true;
+        getLogger().debug(`[process-stopper] sending SIGTERM to pgid=${pgid} immediate=${immediate}`);
+        try {
+            process.kill(pgid, 'SIGTERM');
+        }
+        catch {
+            /* process may have exited */
+        }
+        if (immediate) {
+            // Don't wait — send SIGKILL back-to-back. Even if proc just exited
+            // from SIGTERM, kill(SIGKILL) on a dead pid throws ESRCH which we ignore.
+            try {
+                process.kill(pgid, 'SIGKILL');
+            }
+            catch { }
+        }
+        else {
+            // Wait for exit with grace period. Use `once` so repeated stop() calls
+            // don't accumulate listeners on the proc. P2-15: save the grace timer id
+            // and clear it once the race settles — otherwise the timer lingers after
+            // an early exit, keeping the event loop alive and accumulating across
+            // frequent stop() calls.
+            let graceTimer;
+            const exited = await Promise.race([
+                new Promise((resolve) => {
+                    if (proc.exitCode !== null || proc.signalCode !== null)
+                        return resolve(true);
+                    proc.once('exit', () => resolve(true));
+                }),
+                new Promise((resolve) => {
+                    graceTimer = setTimeout(() => resolve(false), this.graceMs);
+                }),
+            ]);
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            if (!exited) {
+                getLogger().info(`[process-stopper] process group ${pgid} did not exit within grace period, sending SIGKILL`);
+                try {
+                    process.kill(pgid, 'SIGKILL');
+                }
+                catch { }
+            }
+        }
+    }
+}
+//# sourceMappingURL=process-stopper.js.map

package/dist/runner/common/runner-utils.d.ts

@@ -0,0 +1,21 @@
+import type { ChildProcess } from 'node:child_process';
+import type { AgentEvent } from '../types.js';
+/**
+ * Return the stdio config ['pipe','pipe','pipe'] used by runners that need
+ * to write the prompt to the child's stdin (codex/opencode).
+ */
+export declare function pipeAllStdio(): ('ignore' | 'pipe')[];
+/**
+ * Write the prompt message to the child's stdin and close it.
+ * Used by codex/opencode runners which pass the prompt via stdin
+ * rather than argv.
+ */
+export declare function endStdinWithPrompt(proc: ChildProcess, message: string): void;
+/**
+ * Build a standardized auth/error result event for yield.
+ *
+ * Used by CodexExecRunner and OpencodeExecRunner when initialization or request
+ * sending fails (e.g. not logged in, session creation failed). Produces a
+ * `result`/`error` event so the bridge can render a card instead of crashing.
+ */
+export declare function authErrorEvent(errorMessage: string, sessionId?: string): AgentEvent;

package/dist/runner/common/runner-utils.js

@@ -0,0 +1,65 @@
+/**
+ * Return the stdio config ['pipe','pipe','pipe'] used by runners that need
+ * to write the prompt to the child's stdin (codex/opencode).
+ */
+export function pipeAllStdio() {
+    return ['pipe', 'pipe', 'pipe'];
+}
+/**
+ * Write the prompt message to the child's stdin and close it.
+ * Used by codex/opencode runners which pass the prompt via stdin
+ * rather than argv.
+ */
+export function endStdinWithPrompt(proc, message) {
+    const stdin = proc.stdin;
+    if (!stdin)
+        return;
+    // Guard against async EPIPE: proc.stdin.end() may emit an 'error' event
+    // asynchronously after the call returns (the child may have already exited),
+    // which the synchronous try/catch below cannot catch.
+    // Check for .once availability — in test environments stdin may be a mock
+    // object that lacks EventEmitter methods.
+    if (typeof stdin.once === 'function') {
+        stdin.once('error', (err) => {
+            if (err.code === 'EPIPE') {
+                // Child exited before we could write — not an error, just a race.
+            }
+            else {
+                // Re-throw unexpected errors so they surface as unhandled-exception
+                // rather than being silently swallowed by the EventEmitter default handler.
+                throw err;
+            }
+        });
+    }
+    try {
+        stdin.end(message, 'utf-8');
+    }
+    catch (err) {
+        if (err &&
+            typeof err === 'object' &&
+            'code' in err &&
+            err.code === 'EPIPE') {
+            // Child exited before we could write — not an error, just a race.
+        }
+        else {
+            throw err;
+        }
+    }
+}
+/**
+ * Build a standardized auth/error result event for yield.
+ *
+ * Used by CodexExecRunner and OpencodeExecRunner when initialization or request
+ * sending fails (e.g. not logged in, session creation failed). Produces a
+ * `result`/`error` event so the bridge can render a card instead of crashing.
+ */
+export function authErrorEvent(errorMessage, sessionId = '') {
+    return {
+        type: 'result',
+        subtype: 'error',
+        session_id: sessionId,
+        errorMessage,
+        timestamp: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=runner-utils.js.map

package/dist/runner/common/spawn-heartbeat.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Spawn-stage heartbeat: warns when a spawned process emits no stdout within
+ * a configured window. Covers the gap between spawn and the first stdout
+ * chunk (OAuth prompt, stdio fd misroute, cwd not reachable) where the
+ * idle watchdog has not started yet.
+ *
+ * Extracted from ClaudeRunner and CodexRunner which had identical patterns
+ * (field trio + setTimeout + three clearTimeout call sites).
+ *
+ * Only logs a WARN — never auto-stops. Spawn-stage issues usually need user
+ * intervention (re-login OAuth), so killing automatically would confuse users.
+ */
+export declare class SpawnHeartbeat {
+    private readonly ms;
+    private readonly logTag;
+    private timer;
+    private firstStdoutSeen;
+    constructor(ms: number, logTag: string);
+    /**
+     * Start the heartbeat timer. If no stdout is observed within `ms`,
+     * log a WARN with the spawn context. Safe to call again after `clear()`
+     * (e.g. across multiple runs).
+     */
+    start(ctx: {
+        pid: number;
+        binary: string;
+        cwd: string;
+    }): void;
+    /** Mark that stdout has been observed; clears the timer. */
+    notifyStdout(): void;
+    /** Clear the timer (safe to call multiple times). */
+    clear(): void;
+}

package/dist/runner/common/spawn-heartbeat.js

@@ -0,0 +1,51 @@
+import { getLogger } from '../../logger/index.js';
+/**
+ * Spawn-stage heartbeat: warns when a spawned process emits no stdout within
+ * a configured window. Covers the gap between spawn and the first stdout
+ * chunk (OAuth prompt, stdio fd misroute, cwd not reachable) where the
+ * idle watchdog has not started yet.
+ *
+ * Extracted from ClaudeRunner and CodexRunner which had identical patterns
+ * (field trio + setTimeout + three clearTimeout call sites).
+ *
+ * Only logs a WARN — never auto-stops. Spawn-stage issues usually need user
+ * intervention (re-login OAuth), so killing automatically would confuse users.
+ */
+export class SpawnHeartbeat {
+    ms;
+    logTag;
+    timer = null;
+    firstStdoutSeen = false;
+    constructor(ms, logTag) {
+        this.ms = ms;
+        this.logTag = logTag;
+    }
+    /**
+     * Start the heartbeat timer. If no stdout is observed within `ms`,
+     * log a WARN with the spawn context. Safe to call again after `clear()`
+     * (e.g. across multiple runs).
+     */
+    start(ctx) {
+        this.firstStdoutSeen = false;
+        this.clear();
+        this.timer = setTimeout(() => {
+            if (!this.firstStdoutSeen) {
+                getLogger().warn(`[${this.logTag}] spawn stage stalled: pid=${ctx.pid} binary=${ctx.binary} ` +
+                    `cwd=${ctx.cwd} — process spawned ${this.ms / 1000}s ago with no stdout output.`);
+            }
+        }, this.ms);
+    }
+    /** Mark that stdout has been observed; clears the timer. */
+    notifyStdout() {
+        this.firstStdoutSeen = true;
+        this.clear();
+    }
+    /** Clear the timer (safe to call multiple times). */
+    clear() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}
+//# sourceMappingURL=spawn-heartbeat.js.map