@getpaseo/server 0.1.3 → 0.1.4

package/dist/server/server/session.js

@@ -6,6 +6,7 @@ import { promisify } from "util";
 import { join, resolve, sep } from "path";
 import { z } from "zod";
 import { serializeAgentStreamEvent, } from "./messages.js";
+import { BinaryMuxChannel, TerminalBinaryFlags, TerminalBinaryMessageType, } from "../shared/binary-mux.js";
 import { TTSManager } from "./agent/tts-manager.js";
 import { STTManager } from "./agent/stt-manager.js";
 import { maybePersistTtsDebugAudio } from "./agent/tts-debug.js";
@@ -16,13 +17,14 @@ import { experimental_createMCPClient } from "ai";
 import { buildProviderRegistry } from "./agent/provider-registry.js";
 import { scheduleAgentMetadataGeneration } from "./agent/agent-metadata-generator.js";
 import { toAgentPayload } from "./agent/agent-projections.js";
+import { projectTimelineRows } from "./agent/timeline-projection.js";
 import { StructuredAgentResponseError, generateStructuredAgentResponse, } from "./agent/agent-response-loop.js";
 import { isValidAgentProvider, AGENT_PROVIDER_IDS } from "./agent/provider-manifest.js";
 import { buildVoiceAgentMcpServerConfig, buildVoiceModeSystemPrompt, stripVoiceModeSystemPrompt, } from "./voice-config.js";
 import { isVoicePermissionAllowed } from "./voice-permission-policy.js";
 import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, } from "./file-explorer/service.js";
 import { createWorktree, runWorktreeSetupCommands, WorktreeSetupError, slugify, validateBranchSlug, listPaseoWorktrees, deletePaseoWorktree, isPaseoOwnedWorktreeCwd, resolvePaseoWorktreeRootForCwd, } from "../utils/worktree.js";
-import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, } from "../utils/checkout-git.js";
+import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, } from "../utils/checkout-git.js";
 import { getProjectIcon } from "../utils/project-icon.js";
 import { expandTilde } from "../utils/path.js";
 import { ensureLocalSpeechModels, getLocalSpeechModelDir, listLocalSpeechModels, } from "./speech/providers/local/models.js";
@@ -39,6 +41,9 @@ const PROJECT_PLACEMENT_CACHE_TTL_MS = 10000;
 const MAX_AGENTS_PER_PROJECT = 5;
 const CHECKOUT_DIFF_WATCH_DEBOUNCE_MS = 150;
 const CHECKOUT_DIFF_FALLBACK_REFRESH_MS = 5000;
+const TERMINAL_STREAM_WINDOW_BYTES = 256 * 1024;
+const TERMINAL_STREAM_MAX_PENDING_BYTES = 2 * 1024 * 1024;
+const TERMINAL_STREAM_MAX_PENDING_CHUNKS = 2048;
 /**
  * Default model used for auto-generating commit messages and PR descriptions.
  * Uses Claude Haiku for speed and cost efficiency.
@@ -116,6 +121,15 @@ const VOICE_INTERNAL_DICTATION_ID_PREFIX = "__voice_turn__:";
 const SAFE_GIT_REF_PATTERN = /^[A-Za-z0-9._\/-]+$/;
 const AgentIdSchema = z.string().uuid();
 const VOICE_MCP_SERVER_NAME = "paseo_voice";
+class VoiceFeatureUnavailableError extends Error {
+    constructor(context) {
+        super(context.message);
+        this.name = "VoiceFeatureUnavailableError";
+        this.reasonCode = context.reasonCode;
+        this.retryable = context.retryable;
+        this.missingModelIds = [...context.missingModelIds];
+    }
+}
 function convertPCMToWavBuffer(pcmBuffer, sampleRate, channels, bitsPerSample) {
     const headerSize = 44;
     const wavBuffer = Buffer.alloc(headerSize + pcmBuffer.length);
@@ -199,14 +213,18 @@ export class Session {
         this.clientActivity = null;
         this.MOBILE_BACKGROUND_STREAM_GRACE_MS = 60000;
         this.terminalSubscriptions = new Map();
+        this.terminalStreams = new Map();
+        this.terminalStreamByTerminalId = new Map();
+        this.nextTerminalStreamId = 1;
         this.checkoutDiffSubscriptions = new Map();
         this.checkoutDiffTargets = new Map();
         this.voiceModeAgentId = null;
         this.voiceModeBaseConfig = null;
-        const { clientId, onMessage, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, createAgentMcpTransport, stt, tts, terminalManager, voice, voiceBridge, dictation, agentProviderRuntimeSettings, } = options;
+        const { clientId, onMessage, onBinaryMessage, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, createAgentMcpTransport, stt, tts, terminalManager, voice, voiceBridge, dictation, agentProviderRuntimeSettings, } = options;
         this.clientId = clientId;
         this.sessionId = uuidv4();
         this.onMessage = onMessage;
+        this.onBinaryMessage = onBinaryMessage ?? null;
         this.downloadTokenStore = downloadTokenStore;
         this.pushTokenStore = pushTokenStore;
         this.paseoHome = paseoHome;
@@ -230,6 +248,7 @@ export class Session {
         this.unregisterVoiceCallerContext = voiceBridge?.unregisterVoiceCallerContext;
         this.ensureVoiceMcpSocketForAgent = voiceBridge?.ensureVoiceMcpSocketForAgent;
         this.removeVoiceMcpSocketForAgent = voiceBridge?.removeVoiceMcpSocketForAgent;
+        this.getSpeechReadiness = dictation?.getSpeechReadiness;
         this.agentProviderRuntimeSettings = agentProviderRuntimeSettings;
         this.abortController = new AbortController();
         this.sessionLogger = logger.child({
@@ -415,9 +434,7 @@ export class Session {
             }
             // Reduce bandwidth/CPU on mobile: only forward high-frequency agent stream events
             // for the focused agent, with a short grace window while backgrounded.
-            //
-            // History catch-up is handled via explicit `initialize_agent_request` which emits a
-            // batched `agent_stream_snapshot`.
+            // History catch-up is handled via pull-based `fetch_agent_timeline_request`.
             const activity = this.clientActivity;
             if (activity?.deviceType === "mobile") {
                 if (!activity.focusedAgentId) {
@@ -441,6 +458,8 @@ export class Session {
                 agentId: event.agentId,
                 event: serializedEvent,
                 timestamp: new Date().toISOString(),
+                ...(typeof event.seq === "number" ? { seq: event.seq } : {}),
+                ...(typeof event.epoch === "string" ? { epoch: event.epoch } : {}),
             };
             this.emit({
                 type: "agent_stream",
@@ -699,6 +718,22 @@ export class Session {
                     await this.handleWaitForFinish(msg.agentId, msg.requestId, msg.timeoutMs);
                     break;
                 case "dictation_stream_start":
+                    {
+                        const unavailable = this.resolveVoiceFeatureUnavailableContext("dictation");
+                        if (unavailable) {
+                            this.emit({
+                                type: "dictation_stream_error",
+                                payload: {
+                                    dictationId: msg.dictationId,
+                                    error: unavailable.message,
+                                    retryable: unavailable.retryable,
+                                    reasonCode: unavailable.reasonCode,
+                                    missingModelIds: unavailable.missingModelIds,
+                                },
+                            });
+                            break;
+                        }
+                    }
                     await this.dictationStreamManager.handleStart(msg.dictationId, msg.format);
                     break;
                 case "dictation_stream_chunk":
@@ -730,8 +765,8 @@ export class Session {
                 case "restart_server_request":
                     await this.handleRestartServerRequest(msg.requestId, msg.reason);
                     break;
-                case "initialize_agent_request":
-                    await this.handleInitializeAgentRequest(msg.agentId, msg.requestId);
+                case "fetch_agent_timeline_request":
+                    await this.handleFetchAgentTimelineRequest(msg);
                     break;
                 case "set_agent_mode_request":
                     await this.handleSetAgentModeRequest(msg.agentId, msg.modeId, msg.requestId);
@@ -751,6 +786,9 @@ export class Session {
                 case "validate_branch_request":
                     await this.handleValidateBranchRequest(msg);
                     break;
+                case "branch_suggestions_request":
+                    await this.handleBranchSuggestionsRequest(msg);
+                    break;
                 case "subscribe_checkout_diff_request":
                     await this.handleSubscribeCheckoutDiffRequest(msg);
                     break;
@@ -848,6 +886,12 @@ export class Session {
                 case "kill_terminal_request":
                     await this.handleKillTerminalRequest(msg);
                     break;
+                case "attach_terminal_stream_request":
+                    await this.handleAttachTerminalStreamRequest(msg);
+                    break;
+                case "detach_terminal_stream_request":
+                    this.handleDetachTerminalStreamRequest(msg);
+                    break;
             }
         }
         catch (error) {
@@ -881,6 +925,58 @@ export class Session {
             });
         }
     }
+    handleBinaryFrame(frame) {
+        switch (frame.channel) {
+            case BinaryMuxChannel.Terminal:
+                this.handleTerminalBinaryFrame(frame);
+                break;
+            default:
+                this.sessionLogger.warn({ channel: frame.channel, messageType: frame.messageType }, "Unhandled binary mux channel");
+                break;
+        }
+    }
+    handleTerminalBinaryFrame(frame) {
+        if (frame.messageType === TerminalBinaryMessageType.InputUtf8) {
+            const binding = this.terminalStreams.get(frame.streamId);
+            if (!binding) {
+                this.sessionLogger.warn({ streamId: frame.streamId }, "Terminal stream not found for input");
+                return;
+            }
+            if (!this.terminalManager) {
+                return;
+            }
+            const session = this.terminalManager.getTerminal(binding.terminalId);
+            if (!session) {
+                this.detachTerminalStream(frame.streamId, { emitExit: true });
+                return;
+            }
+            const payload = frame.payload ?? new Uint8Array(0);
+            if (payload.byteLength === 0) {
+                return;
+            }
+            const text = Buffer.from(payload).toString("utf8");
+            if (!text) {
+                return;
+            }
+            session.send({ type: "input", data: text });
+            return;
+        }
+        if (frame.messageType === TerminalBinaryMessageType.Ack) {
+            const binding = this.terminalStreams.get(frame.streamId);
+            if (binding) {
+                if (!Number.isFinite(frame.offset) || frame.offset < 0) {
+                    return;
+                }
+                const nextAckOffset = Math.max(binding.lastAckOffset, Math.min(Math.floor(frame.offset), binding.lastOutputOffset));
+                if (nextAckOffset > binding.lastAckOffset) {
+                    binding.lastAckOffset = nextAckOffset;
+                    this.flushPendingTerminalStreamChunks(frame.streamId, binding);
+                }
+            }
+            return;
+        }
+        this.sessionLogger.warn({ streamId: frame.streamId, messageType: frame.messageType }, "Unhandled terminal binary frame");
+    }
     async handleRestartServerRequest(requestId, reason) {
         if (restartRequested) {
             this.sessionLogger.debug("Restart already requested, ignoring duplicate");
@@ -1032,12 +1128,57 @@ export class Session {
             });
         }
     }
+    toVoiceFeatureUnavailableContext(state) {
+        return {
+            reasonCode: state.reasonCode,
+            message: state.message,
+            retryable: state.retryable,
+            missingModelIds: [...state.missingModelIds],
+        };
+    }
+    resolveModeReadinessState(readiness, mode) {
+        if (mode === "voice_mode") {
+            return readiness.realtimeVoice;
+        }
+        return readiness.dictation;
+    }
+    getVoiceFeatureUnavailableResponseMetadata(error) {
+        if (!(error instanceof VoiceFeatureUnavailableError)) {
+            return {};
+        }
+        return {
+            reasonCode: error.reasonCode,
+            retryable: error.retryable,
+            missingModelIds: error.missingModelIds,
+        };
+    }
+    resolveVoiceFeatureUnavailableContext(mode) {
+        const readiness = this.getSpeechReadiness?.();
+        if (!readiness) {
+            return null;
+        }
+        const modeReadiness = this.resolveModeReadinessState(readiness, mode);
+        if (!modeReadiness.enabled) {
+            return this.toVoiceFeatureUnavailableContext(modeReadiness);
+        }
+        if (!readiness.voiceFeature.available) {
+            return this.toVoiceFeatureUnavailableContext(readiness.voiceFeature);
+        }
+        if (!modeReadiness.available) {
+            return this.toVoiceFeatureUnavailableContext(modeReadiness);
+        }
+        return null;
+    }
     /**
      * Handle voice mode toggle
      */
     async handleSetVoiceMode(enabled, agentId, requestId) {
         try {
             if (enabled) {
+                const unavailable = this.resolveVoiceFeatureUnavailableContext("voice_mode");
+                if (unavailable) {
+                    throw new VoiceFeatureUnavailableError(unavailable);
+                }
                 const normalizedAgentId = this.parseVoiceTargetAgentId(agentId ?? "", "set_voice_mode");
                 if (this.isVoiceMode &&
                     this.voiceModeAgentId &&
@@ -1084,6 +1225,7 @@ export class Session {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "Failed to set voice mode";
+            const unavailable = this.getVoiceFeatureUnavailableResponseMetadata(error);
             this.sessionLogger.error({
                 err: error,
                 enabled,
@@ -1098,6 +1240,7 @@ export class Session {
                         agentId: this.voiceModeAgentId,
                         accepted: false,
                         error: errorMessage,
+                        ...unavailable,
                     },
                 });
                 return;
@@ -1410,37 +1553,6 @@ export class Session {
         }
         this.startAgentStream(agentId, prompt, runOptions);
     }
-    /**
-     * Handle on-demand agent initialization request from client
-     */
-    async handleInitializeAgentRequest(agentId, requestId) {
-        try {
-            const snapshot = await this.ensureAgentLoaded(agentId);
-            await this.forwardAgentUpdate(snapshot);
-            // Send timeline snapshot after hydration (if any)
-            const timelineSize = this.emitAgentTimelineSnapshot(snapshot);
-            this.emit({
-                type: "initialize_agent_request",
-                payload: {
-                    agentId,
-                    agentStatus: snapshot.lifecycle,
-                    timelineSize,
-                    requestId,
-                },
-            });
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, agentId }, `Failed to initialize agent ${agentId}`);
-            this.emit({
-                type: "initialize_agent_request",
-                payload: {
-                    agentId,
-                    requestId,
-                    error: error?.message ?? "Failed to initialize agent",
-                },
-            });
-        }
-    }
     /**
      * Handle create agent request
      */
@@ -1541,7 +1653,7 @@ export class Session {
             const snapshot = await this.agentManager.resumeAgentFromPersistence(handle, overrides);
             await this.agentManager.hydrateTimelineFromProvider(snapshot.id);
             await this.forwardAgentUpdate(snapshot);
-            const timelineSize = this.emitAgentTimelineSnapshot(snapshot);
+            const timelineSize = this.agentManager.getTimeline(snapshot.id).length;
             if (requestId) {
                 const agentPayload = await this.getAgentPayloadById(snapshot.id);
                 if (!agentPayload) {
@@ -1600,7 +1712,7 @@ export class Session {
             }
             await this.agentManager.hydrateTimelineFromProvider(agentId);
             await this.forwardAgentUpdate(snapshot);
-            const timelineSize = this.emitAgentTimelineSnapshot(snapshot);
+            const timelineSize = this.agentManager.getTimeline(agentId).length;
             if (requestId) {
                 this.emit({
                     type: "status",
@@ -2627,6 +2739,31 @@ export class Session {
             });
         }
     }
+    async handleBranchSuggestionsRequest(msg) {
+        const { cwd, query, limit, requestId } = msg;
+        try {
+            const resolvedCwd = expandTilde(cwd);
+            const branches = await listBranchSuggestions(resolvedCwd, { query, limit });
+            this.emit({
+                type: "branch_suggestions_response",
+                payload: {
+                    branches,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.emit({
+                type: "branch_suggestions_response",
+                payload: {
+                    branches: [],
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId,
+                },
+            });
+        }
+    }
     normalizeCheckoutDiffCompare(compare) {
         if (compare.mode === "uncommitted") {
             return { mode: "uncommitted" };
@@ -2798,30 +2935,42 @@ export class Session {
             latestPayload: null,
             latestFingerprint: null,
         };
-        const watchPaths = new Set([cwd]);
-        if (watchRoot) {
-            watchPaths.add(watchRoot);
-        }
+        const repoWatchPath = watchRoot ?? cwd;
+        const watchPaths = new Set([repoWatchPath]);
         const gitDir = await this.resolveCheckoutGitDir(cwd);
         if (gitDir) {
             watchPaths.add(gitDir);
         }
-        let hasWatchRootCoverage = false;
+        let hasRecursiveRepoCoverage = false;
+        const allowRecursiveRepoWatch = process.platform !== "linux";
         for (const watchPath of watchPaths) {
+            const shouldTryRecursive = watchPath === repoWatchPath && allowRecursiveRepoWatch;
             const createWatcher = (recursive) => watch(watchPath, { recursive }, () => {
                 this.scheduleCheckoutDiffTargetRefresh(target);
             });
             let watcher = null;
+            let watcherIsRecursive = false;
             try {
-                watcher = createWatcher(true);
+                if (shouldTryRecursive) {
+                    watcher = createWatcher(true);
+                    watcherIsRecursive = true;
+                }
+                else {
+                    watcher = createWatcher(false);
+                }
             }
             catch (error) {
-                try {
-                    watcher = createWatcher(false);
-                    this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Checkout diff recursive watch unavailable; using non-recursive fallback");
+                if (shouldTryRecursive) {
+                    try {
+                        watcher = createWatcher(false);
+                        this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Checkout diff recursive watch unavailable; using non-recursive fallback");
+                    }
+                    catch (fallbackError) {
+                        this.sessionLogger.warn({ err: fallbackError, watchPath, cwd, compare }, "Failed to start checkout diff watcher");
+                    }
                 }
-                catch (fallbackError) {
-                    this.sessionLogger.warn({ err: fallbackError, watchPath, cwd, compare }, "Failed to start checkout diff watcher");
+                else {
+                    this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Failed to start checkout diff watcher");
                 }
             }
             if (!watcher) {
@@ -2831,11 +2980,11 @@ export class Session {
                 this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Checkout diff watcher error");
             });
             target.watchers.push(watcher);
-            if (watchRoot && watchPath === watchRoot) {
-                hasWatchRootCoverage = true;
+            if (watchPath === repoWatchPath && watcherIsRecursive) {
+                hasRecursiveRepoCoverage = true;
             }
         }
-        const missingRepoCoverage = Boolean(watchRoot) && !hasWatchRootCoverage;
+        const missingRepoCoverage = !hasRecursiveRepoCoverage;
         if (target.watchers.length === 0 || missingRepoCoverage) {
             target.fallbackRefreshInterval = setInterval(() => {
                 this.scheduleCheckoutDiffTargetRefresh(target);
@@ -2846,7 +2995,7 @@ export class Session {
                 intervalMs: CHECKOUT_DIFF_FALLBACK_REFRESH_MS,
                 reason: target.watchers.length === 0
                     ? "no_watchers"
-                    : "missing_repo_root_coverage",
+                    : "missing_recursive_repo_root_coverage",
             }, "Checkout diff watchers unavailable; using timed refresh fallback");
         }
         this.checkoutDiffTargets.set(targetKey, target);
@@ -3606,6 +3755,77 @@ export class Session {
             payload: { requestId, agent, error: null },
         });
     }
+    async handleFetchAgentTimelineRequest(msg) {
+        const direction = msg.direction ?? (msg.cursor ? "after" : "tail");
+        const projection = msg.projection ?? "projected";
+        const limit = msg.limit ?? (direction === "after" ? 0 : undefined);
+        const cursor = msg.cursor
+            ? {
+                epoch: msg.cursor.epoch,
+                seq: msg.cursor.seq,
+            }
+            : undefined;
+        try {
+            const snapshot = await this.ensureAgentLoaded(msg.agentId);
+            const timeline = this.agentManager.fetchTimeline(msg.agentId, {
+                direction,
+                cursor,
+                limit,
+            });
+            const projected = projectTimelineRows(timeline.rows, snapshot.provider, projection);
+            const firstRow = timeline.rows[0];
+            const lastRow = timeline.rows[timeline.rows.length - 1];
+            const startCursor = firstRow
+                ? { epoch: timeline.epoch, seq: firstRow.seq }
+                : null;
+            const endCursor = lastRow
+                ? { epoch: timeline.epoch, seq: lastRow.seq }
+                : null;
+            this.emit({
+                type: "fetch_agent_timeline_response",
+                payload: {
+                    requestId: msg.requestId,
+                    agentId: msg.agentId,
+                    direction,
+                    projection,
+                    epoch: timeline.epoch,
+                    reset: timeline.reset,
+                    staleCursor: timeline.staleCursor,
+                    gap: timeline.gap,
+                    window: timeline.window,
+                    startCursor,
+                    endCursor,
+                    hasOlder: timeline.hasOlder,
+                    hasNewer: timeline.hasNewer,
+                    entries: projected,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, agentId: msg.agentId }, "Failed to handle fetch_agent_timeline_request");
+            this.emit({
+                type: "fetch_agent_timeline_response",
+                payload: {
+                    requestId: msg.requestId,
+                    agentId: msg.agentId,
+                    direction,
+                    projection,
+                    epoch: "",
+                    reset: false,
+                    staleCursor: false,
+                    gap: false,
+                    window: { minSeq: 0, maxSeq: 0, nextSeq: 0 },
+                    startCursor: null,
+                    endCursor: null,
+                    hasOlder: false,
+                    hasNewer: false,
+                    entries: [],
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
     async handleSendAgentMessageRequest(msg) {
         const resolved = await this.resolveAgentIdentifier(msg.agentId);
         if (!resolved.ok) {
@@ -3782,30 +4002,6 @@ export class Session {
             clearTimeout(timeoutHandle);
         }
     }
-    emitAgentTimelineSnapshot(agent) {
-        const timeline = this.agentManager.getTimeline(agent.id);
-        const events = timeline.flatMap((item) => {
-            const serializedEvent = serializeAgentStreamEvent({
-                type: "timeline",
-                provider: agent.provider,
-                item,
-            });
-            if (!serializedEvent) {
-                return [];
-            }
-            return [
-                {
-                    event: serializedEvent,
-                    timestamp: new Date().toISOString(),
-                },
-            ];
-        });
-        this.emit({
-            type: "agent_stream_snapshot",
-            payload: { agentId: agent.id, events },
-        });
-        return timeline.length;
-    }
     /**
      * Handle audio chunk for buffering and transcription
      */
@@ -4257,6 +4453,17 @@ export class Session {
         }
         this.onMessage(msg);
     }
+    emitBinary(frame) {
+        if (!this.onBinaryMessage) {
+            return;
+        }
+        try {
+            this.onBinaryMessage(frame);
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error }, "Failed to emit binary frame");
+        }
+    }
     /**
      * Clean up session resources
      */
@@ -4299,6 +4506,7 @@ export class Session {
             unsubscribe();
         }
         this.terminalSubscriptions.clear();
+        this.detachAllTerminalStreams({ emitExit: false });
         for (const target of this.checkoutDiffTargets.values()) {
             this.closeCheckoutDiffWatchTarget(target);
         }
@@ -4472,6 +4680,10 @@ export class Session {
             unsubscribe();
             this.terminalSubscriptions.delete(msg.terminalId);
         }
+        const streamId = this.terminalStreamByTerminalId.get(msg.terminalId);
+        if (typeof streamId === "number") {
+            this.detachTerminalStream(streamId, { emitExit: true });
+        }
         this.terminalManager.killTerminal(msg.terminalId);
         this.emit({
             type: "kill_terminal_response",
@@ -4482,5 +4694,213 @@ export class Session {
             },
         });
     }
+    async handleAttachTerminalStreamRequest(msg) {
+        if (!this.terminalManager || !this.onBinaryMessage) {
+            this.emit({
+                type: "attach_terminal_stream_response",
+                payload: {
+                    terminalId: msg.terminalId,
+                    streamId: null,
+                    replayedFrom: 0,
+                    currentOffset: 0,
+                    earliestAvailableOffset: 0,
+                    reset: true,
+                    error: "Terminal streaming not available",
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        const session = this.terminalManager.getTerminal(msg.terminalId);
+        if (!session) {
+            this.emit({
+                type: "attach_terminal_stream_response",
+                payload: {
+                    terminalId: msg.terminalId,
+                    streamId: null,
+                    replayedFrom: 0,
+                    currentOffset: 0,
+                    earliestAvailableOffset: 0,
+                    reset: true,
+                    error: "Terminal not found",
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        if (msg.rows || msg.cols) {
+            const state = session.getState();
+            session.send({
+                type: "resize",
+                rows: msg.rows ?? state.rows,
+                cols: msg.cols ?? state.cols,
+            });
+        }
+        const existingStreamId = this.terminalStreamByTerminalId.get(msg.terminalId);
+        if (typeof existingStreamId === "number") {
+            this.detachTerminalStream(existingStreamId, { emitExit: false });
+        }
+        const streamId = this.allocateTerminalStreamId();
+        const initialOffset = Math.max(0, Math.floor(msg.resumeOffset ?? 0));
+        const binding = {
+            terminalId: msg.terminalId,
+            unsubscribe: () => { },
+            lastOutputOffset: initialOffset,
+            lastAckOffset: initialOffset,
+            pendingChunks: [],
+            pendingBytes: 0,
+        };
+        this.terminalStreams.set(streamId, binding);
+        this.terminalStreamByTerminalId.set(msg.terminalId, streamId);
+        let rawSub;
+        try {
+            rawSub = session.subscribeRaw((chunk) => {
+                const currentBinding = this.terminalStreams.get(streamId);
+                if (!currentBinding) {
+                    return;
+                }
+                this.enqueueOrEmitTerminalStreamChunk(streamId, currentBinding, {
+                    data: chunk.data,
+                    startOffset: chunk.startOffset,
+                    endOffset: chunk.endOffset,
+                    replay: chunk.replay,
+                });
+            }, { fromOffset: msg.resumeOffset ?? 0 });
+        }
+        catch (error) {
+            this.terminalStreams.delete(streamId);
+            this.terminalStreamByTerminalId.delete(msg.terminalId);
+            throw error;
+        }
+        binding.unsubscribe = rawSub.unsubscribe;
+        binding.lastAckOffset = rawSub.replayedFrom;
+        if (binding.lastOutputOffset < rawSub.replayedFrom) {
+            binding.lastOutputOffset = rawSub.replayedFrom;
+        }
+        this.flushPendingTerminalStreamChunks(streamId, binding);
+        this.emit({
+            type: "attach_terminal_stream_response",
+            payload: {
+                terminalId: msg.terminalId,
+                streamId,
+                replayedFrom: rawSub.replayedFrom,
+                currentOffset: rawSub.currentOffset,
+                earliestAvailableOffset: rawSub.earliestAvailableOffset,
+                reset: rawSub.reset,
+                error: null,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    getTerminalStreamChunkByteLength(chunk) {
+        return Math.max(0, chunk.endOffset - chunk.startOffset);
+    }
+    canEmitTerminalStreamChunk(binding, chunk) {
+        return chunk.startOffset < binding.lastAckOffset + TERMINAL_STREAM_WINDOW_BYTES;
+    }
+    emitTerminalStreamChunk(streamId, binding, chunk) {
+        const payload = new Uint8Array(Buffer.from(chunk.data, "utf8"));
+        this.emitBinary({
+            channel: BinaryMuxChannel.Terminal,
+            messageType: TerminalBinaryMessageType.OutputUtf8,
+            streamId,
+            offset: chunk.startOffset,
+            flags: chunk.replay ? TerminalBinaryFlags.Replay : 0,
+            payload,
+        });
+        binding.lastOutputOffset = chunk.endOffset;
+    }
+    enqueueOrEmitTerminalStreamChunk(streamId, binding, chunk) {
+        const chunkBytes = this.getTerminalStreamChunkByteLength(chunk);
+        if (binding.pendingChunks.length > 0 || !this.canEmitTerminalStreamChunk(binding, chunk)) {
+            if (binding.pendingChunks.length >= TERMINAL_STREAM_MAX_PENDING_CHUNKS ||
+                binding.pendingBytes + chunkBytes > TERMINAL_STREAM_MAX_PENDING_BYTES) {
+                this.sessionLogger.warn({
+                    streamId,
+                    pendingChunks: binding.pendingChunks.length,
+                    pendingBytes: binding.pendingBytes,
+                    chunkBytes,
+                }, "Terminal stream pending buffer overflow; closing stream");
+                this.detachTerminalStream(streamId, { emitExit: true });
+                return;
+            }
+            binding.pendingChunks.push(chunk);
+            binding.pendingBytes += chunkBytes;
+            return;
+        }
+        this.emitTerminalStreamChunk(streamId, binding, chunk);
+    }
+    flushPendingTerminalStreamChunks(streamId, binding) {
+        while (binding.pendingChunks.length > 0) {
+            const next = binding.pendingChunks[0];
+            if (!next || !this.canEmitTerminalStreamChunk(binding, next)) {
+                break;
+            }
+            binding.pendingChunks.shift();
+            binding.pendingBytes -= this.getTerminalStreamChunkByteLength(next);
+            if (binding.pendingBytes < 0) {
+                binding.pendingBytes = 0;
+            }
+            this.emitTerminalStreamChunk(streamId, binding, next);
+        }
+    }
+    handleDetachTerminalStreamRequest(msg) {
+        const success = this.detachTerminalStream(msg.streamId, { emitExit: false });
+        this.emit({
+            type: "detach_terminal_stream_response",
+            payload: {
+                streamId: msg.streamId,
+                success,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    detachAllTerminalStreams(options) {
+        for (const streamId of Array.from(this.terminalStreams.keys())) {
+            this.detachTerminalStream(streamId, options);
+        }
+    }
+    detachTerminalStream(streamId, options) {
+        const binding = this.terminalStreams.get(streamId);
+        if (!binding) {
+            return false;
+        }
+        try {
+            binding.unsubscribe();
+        }
+        catch (error) {
+            this.sessionLogger.warn({ err: error, streamId }, "Failed to unsubscribe terminal stream");
+        }
+        this.terminalStreams.delete(streamId);
+        if (this.terminalStreamByTerminalId.get(binding.terminalId) === streamId) {
+            this.terminalStreamByTerminalId.delete(binding.terminalId);
+        }
+        if (options?.emitExit) {
+            this.emit({
+                type: "terminal_stream_exit",
+                payload: {
+                    streamId,
+                    terminalId: binding.terminalId,
+                },
+            });
+        }
+        return true;
+    }
+    allocateTerminalStreamId() {
+        let attempts = 0;
+        while (attempts < 0xffffffff) {
+            const candidate = this.nextTerminalStreamId >>> 0;
+            this.nextTerminalStreamId = ((this.nextTerminalStreamId + 1) & 0xffffffff) >>> 0;
+            if (candidate === 0) {
+                attempts += 1;
+                continue;
+            }
+            if (!this.terminalStreams.has(candidate)) {
+                return candidate;
+            }
+            attempts += 1;
+        }
+        throw new Error("Unable to allocate terminal stream id");
+    }
 }
 //# sourceMappingURL=session.js.map