@getpaseo/server 0.1.96 → 0.1.97-beta.2

package/dist/server/terminal/terminal-session-controller.js

@@ -1,7 +1,8 @@
-import { killTerminalsUnderPath as killWorktreeTerminalsUnderPath } from "../server/paseo-worktree-archive-service.js";
+import { killTerminalsForWorkspace as killWorkspaceTerminals } from "../server/workspace-archive-service.js";
 import { TerminalStreamOpcode, decodeTerminalResizePayload, encodeTerminalStreamFrame, } from "@getpaseo/protocol/binary-frames/index";
 import { TerminalOutputCoalescer } from "./terminal-output-coalescer.js";
-import { MAX_TERMINAL_OUTPUT_FRAME_BYTES, encodeLegacyTerminalSnapshotFrame, encodeTerminalRestoreFrame, resolveRestoreAfterOutputOverflow, resolveTerminalRestoreSnapshotOptions, resolveTerminalSubscriptionSnapshotMode, } from "./terminal-restore.js";
+import { MAX_CLIENT_BUFFERED_BYTES, MAX_TERMINAL_OUTPUT_FRAME_BYTES, encodeLegacyTerminalSnapshotFrame, encodeTerminalRestoreFrame, resolveRestoreAfterOutputOverflow, resolveTerminalRestoreSnapshotOptions, resolveTerminalSubscriptionSnapshotMode, } from "./terminal-restore.js";
+import { terminalSubscriptionKey } from "@getpaseo/protocol/terminal-subscription-key";
 const MAX_TERMINAL_STREAM_SLOTS = 256;
 const TERMINAL_MESSAGE_TYPES = new Set([
     "subscribe_terminals_request",
@@ -17,7 +18,11 @@ const TERMINAL_MESSAGE_TYPES = new Set([
 ]);
 export class TerminalSessionController {
     constructor(options) {
-        this.subscribedDirectories = new Set();
+        // A subscription is scoped to a (cwd, workspaceId) pair, keyed by
+        // terminalSubscriptionKey: two workspaces sharing a cwd subscribe and unsub
+        // independently, and each only receives its own workspace's terminals. The
+        // workspaceId is absent for old clients, which key to the cwd alone.
+        this.subscribedDirectories = new Map();
         this.unsubscribeTerminalsChanged = null;
         this.exitSubscriptions = new Map();
         this.activeStreams = new Map();
@@ -31,6 +36,7 @@ export class TerminalSessionController {
         this.sessionLogger = options.sessionLogger;
         this.listTerminalWorkspaceRoots = options.listTerminalWorkspaceRoots ?? (async () => []);
         this.clientSupportsWrapReflow = options.clientSupportsWrapReflow ?? (() => false);
+        this.getClientBufferedAmount = options.getClientBufferedAmount ?? (() => 0);
     }
     start() {
         if (!this.terminalManager) {
@@ -120,14 +126,12 @@ export class TerminalSessionController {
         this.killTracked(terminalId, { emitExit: true });
         return { terminalId, success: true };
     }
-    async killTerminalsUnderPath(rootPath) {
-        return killWorktreeTerminalsUnderPath({
-            isPathWithinRoot: (pathRoot, candidatePath) => this.isPathWithinRoot(pathRoot, candidatePath),
-            killTrackedTerminal: (terminalId, options) => this.killTracked(terminalId, options),
+    async killTerminalsForWorkspace(workspaceId) {
+        return killWorkspaceTerminals({
             detachTerminalStream: (terminalId, options) => void this.detachStream(terminalId, options),
             sessionLogger: this.sessionLogger,
             terminalManager: this.terminalManager,
-        }, rootPath);
+        }, workspaceId);
     }
     dispose() {
         if (this.unsubscribeTerminalsChanged) {
@@ -171,10 +175,13 @@ export class TerminalSessionController {
     }
     toTerminalInfo(terminal) {
         const title = terminal.getTitle();
+        const activity = terminal.getActivity();
         return {
             id: terminal.id,
             name: terminal.name,
+            workspaceId: terminal.workspaceId,
             ...(title ? { title } : {}),
+            activity,
         };
     }
     async handleTerminalsChanged(event) {
@@ -183,37 +190,39 @@ export class TerminalSessionController {
         // or above the terminal's cwd, keyed by that root, carrying the full
         // aggregated list — so the client's cache replacement doesn't drop the
         // terminals that live directly at the root.
-        const matchingRoots = Array.from(this.subscribedDirectories).filter((root) => this.isPathWithinRoot(root, event.cwd));
-        for (const root of matchingRoots) {
-            await this.emitTerminalsSnapshotForRoot(root);
+        const matchingSubscriptions = Array.from(this.subscribedDirectories.values()).filter((subscription) => this.isPathWithinRoot(subscription.cwd, event.cwd));
+        for (const subscription of matchingSubscriptions) {
+            await this.emitTerminalsSnapshotForSubscription(subscription);
         }
     }
     handleSubscribeTerminalsRequest(msg) {
-        this.subscribedDirectories.add(msg.cwd);
-        void this.emitTerminalsSnapshotForRoot(msg.cwd);
+        const subscription = { cwd: msg.cwd, workspaceId: msg.workspaceId };
+        this.subscribedDirectories.set(terminalSubscriptionKey(msg.cwd, msg.workspaceId), subscription);
+        void this.emitTerminalsSnapshotForSubscription(subscription);
     }
     handleUnsubscribeTerminalsRequest(msg) {
-        this.subscribedDirectories.delete(msg.cwd);
+        this.subscribedDirectories.delete(terminalSubscriptionKey(msg.cwd, msg.workspaceId));
     }
-    async emitTerminalsSnapshotForRoot(cwd) {
-        if (!this.terminalManager || !this.subscribedDirectories.has(cwd)) {
+    async emitTerminalsSnapshotForSubscription(subscription) {
+        const key = terminalSubscriptionKey(subscription.cwd, subscription.workspaceId);
+        if (!this.terminalManager || !this.subscribedDirectories.has(key)) {
             return;
         }
         try {
-            const terminals = await this.getTerminalsForWorkspaceRoot(cwd);
+            const terminals = await this.getTerminalsForWorkspaceRoot(subscription.cwd, subscription.workspaceId);
             for (const terminal of terminals) {
                 this.ensureExitSubscription(terminal);
             }
-            if (!this.subscribedDirectories.has(cwd)) {
+            if (!this.subscribedDirectories.has(key)) {
                 return;
             }
             this.emitTerminalsChangedSnapshot({
-                cwd,
+                cwd: subscription.cwd,
                 terminals: terminals.map((terminal) => this.toTerminalInfo(terminal)),
             });
         }
         catch (error) {
-            this.sessionLogger.warn({ err: error, cwd }, "Failed to emit initial terminal snapshot");
+            this.sessionLogger.warn({ err: error, cwd: subscription.cwd }, "Failed to emit initial terminal snapshot");
         }
     }
     async handleListTerminalsRequest(msg) {
@@ -230,7 +239,7 @@ export class TerminalSessionController {
         }
         try {
             const terminals = typeof msg.cwd === "string"
-                ? await this.getTerminalsForWorkspaceRoot(msg.cwd)
+                ? await this.getTerminalsForWorkspaceRoot(msg.cwd, msg.workspaceId)
                 : await this.getAllTerminalSessions();
             for (const terminal of terminals) {
                 this.ensureExitSubscription(terminal);
@@ -265,11 +274,11 @@ export class TerminalSessionController {
         const terminalsByDirectory = await Promise.all(directories.map((cwd) => manager.getTerminals(cwd)));
         return terminalsByDirectory.flat();
     }
-    async getTerminalsForWorkspaceRoot(cwd) {
+    async getTerminalsForWorkspaceRoot(cwd, workspaceId) {
         if (!this.terminalManager) {
             return [];
         }
-        const terminals = await this.terminalManager.getTerminals(cwd);
+        const terminals = await this.terminalManager.getTerminals(cwd, { workspaceId });
         const workspaceRoots = await this.listTerminalWorkspaceRoots();
         if (workspaceRoots.length === 0) {
             return terminals;
@@ -322,8 +331,20 @@ export class TerminalSessionController {
                 });
                 return;
             }
+            if (!msg.workspaceId) {
+                this.emit({
+                    type: "create_terminal_response",
+                    payload: {
+                        terminal: null,
+                        error: "workspaceId is required",
+                        requestId: msg.requestId,
+                    },
+                });
+                return;
+            }
             const session = await this.terminalManager.createTerminal({
                 cwd: msg.cwd,
+                workspaceId: msg.workspaceId,
                 name: msg.name,
                 command: msg.command,
                 args: msg.args,
@@ -336,7 +357,9 @@ export class TerminalSessionController {
                         id: session.id,
                         name: session.name,
                         cwd: session.cwd,
+                        workspaceId: session.workspaceId,
                         ...(session.getTitle() ? { title: session.getTitle() } : {}),
+                        activity: session.getActivity(),
                     },
                     error: null,
                     requestId: msg.requestId,
@@ -571,7 +594,19 @@ export class TerminalSessionController {
                         return;
                     }
                     activeStream.outputBytesSinceSnapshot += payload.byteLength;
-                    if (activeStream.outputBytesSinceSnapshot > MAX_TERMINAL_OUTPUT_FRAME_BYTES) {
+                    // Catch up via a snapshot only when the client is BOTH far behind in
+                    // produced output AND actually backed up on the wire. A client that
+                    // keeps draining reports ~0 buffered, so it streams continuously even
+                    // past the byte threshold. outputBytesSinceSnapshot keeps accumulating
+                    // in that case — it's harmless, it only gates the snapshot decision at
+                    // the instant backpressure appears, and trySendSnapshot resets it to 0.
+                    // A null reading means the transport exposes no backpressure signal
+                    // (e.g. the multiplexed relay socket); there we can't tell a slow client
+                    // from a fast one, so fall back unconditionally at the byte threshold to
+                    // keep a slow relay client from falling unboundedly behind.
+                    const clientBufferedAmount = this.getClientBufferedAmount();
+                    if (activeStream.outputBytesSinceSnapshot > MAX_TERMINAL_OUTPUT_FRAME_BYTES &&
+                        (clientBufferedAmount === null || clientBufferedAmount > MAX_CLIENT_BUFFERED_BYTES)) {
                         activeStream.restore = resolveRestoreAfterOutputOverflow(activeStream.restore);
                         activeStream.needsSnapshot = true;
                         void this.trySendSnapshot(activeStream);
@@ -671,6 +706,9 @@ export class TerminalSessionController {
             slot: activeStream.slot,
             snapshot,
         }));
+        // The snapshot frame went out-of-band; keep the replay that follows on the
+        // coalescer's trailing path so it doesn't flush back-to-back with it.
+        activeStream.outputCoalescer.markFlushed();
         return { shouldContinue: true, replayRevision: snapshot.revision };
     }
     async emitRestoreSnapshot(activeStream, terminalManager, restore) {
@@ -693,6 +731,9 @@ export class TerminalSessionController {
             slot: activeStream.slot,
             snapshot,
         }));
+        // The restore frame went out-of-band; keep the replay that follows on the
+        // coalescer's trailing path so it doesn't flush back-to-back with it.
+        activeStream.outputCoalescer.markFlushed();
         return { shouldContinue: true, replayRevision: snapshot.revision };
     }
     replayTerminalOutputAfterSnapshot(activeStream, terminal, replayRevision) {

package/dist/server/terminal/terminal-worker-process.js

@@ -1,8 +1,22 @@
 import { createTerminalManager } from "./terminal-manager.js";
 import { captureTerminalLines } from "./terminal-capture.js";
+import { TerminalOutputCoalescer } from "./terminal-output-coalescer.js";
 const manager = createTerminalManager();
 const unsubscribeByTerminalId = new Map();
+const outputCoalescerByTerminalId = new Map();
 let ipcClosing = false;
+let inFlightTerminalCreateRequest = null;
+// The conpty failure signal is process-scoped, not request-scoped. Serializing
+// creates keeps an async spawn failure attributable to exactly one request.
+let createTerminalQueue = Promise.resolve();
+// node-pty completes its Windows conpty spawn asynchronously on a separate
+// conout worker thread. When that spawn fails (bad cwd, missing command, etc.)
+// it throws an exception there that cannot be caught at the call site and would
+// otherwise crash this worker process and sever every existing terminal.
+process.on("uncaughtException", (error) => {
+    console.error("Terminal worker uncaught exception (kept alive):", error);
+    reportInFlightTerminalCreateFailure(error);
+});
 function sendToParent(message) {
     if (ipcClosing || !process.connected || !process.send) {
         return;
@@ -18,14 +32,37 @@ function sendToParent(message) {
         ipcClosing = true;
     }
 }
+function buildTerminalStateResult(session, options) {
+    if (!session) {
+        return null;
+    }
+    return { ...session.getStateSnapshot(options), replayPreamble: session.getReplayPreamble() };
+}
 function toTerminalInfo(session) {
     return {
         id: session.id,
         name: session.name,
         cwd: session.cwd,
+        workspaceId: session.workspaceId,
         ...(session.getTitle() ? { title: session.getTitle() } : {}),
+        activity: session.getActivity(),
     };
 }
+function terminalWorkerErrorMessage(error) {
+    return error instanceof Error ? error.message : "Terminal worker request failed";
+}
+function reportInFlightTerminalCreateFailure(error) {
+    if (!inFlightTerminalCreateRequest || inFlightTerminalCreateRequest.errorReported) {
+        return;
+    }
+    inFlightTerminalCreateRequest.errorReported = true;
+    sendToParent({
+        type: "response",
+        requestId: inFlightTerminalCreateRequest.requestId,
+        ok: false,
+        error: terminalWorkerErrorMessage(error),
+    });
+}
 function clearTerminalSubscriptions(terminalId) {
     const subscriptions = unsubscribeByTerminalId.get(terminalId);
     if (subscriptions) {
@@ -39,10 +76,41 @@ function clearTerminalSubscriptions(terminalId) {
         }
     }
     unsubscribeByTerminalId.delete(terminalId);
+    const coalescer = outputCoalescerByTerminalId.get(terminalId);
+    if (coalescer) {
+        coalescer.dispose();
+        outputCoalescerByTerminalId.delete(terminalId);
+    }
 }
 function watchTerminal(session) {
     clearTerminalSubscriptions(session.id);
+    // Coalesce pty output chunks into a single IPC message per ~5ms window so a
+    // burst of small chunks no longer costs one process.send each. The batch
+    // carries the LAST chunk's revision (the highest) so downstream snapshot
+    // replay dedup stays correct.
+    let pendingOutputRevision;
+    const outputCoalescer = new TerminalOutputCoalescer({
+        timers: { setTimeout, clearTimeout },
+        onFlush: ({ payload }) => {
+            const revision = pendingOutputRevision;
+            pendingOutputRevision = undefined;
+            sendToParent({
+                type: "terminalMessage",
+                terminalId: session.id,
+                message: { type: "output", data: payload.toString("utf8"), revision },
+            });
+        },
+    });
+    outputCoalescerByTerminalId.set(session.id, outputCoalescer);
     const unsubscribeMessage = session.subscribe((message) => {
+        if (message.type === "output") {
+            pendingOutputRevision = message.revision;
+            outputCoalescer.handle(message.data);
+            return;
+        }
+        // Non-output messages (snapshot/snapshotReady/titleChange) must not jump
+        // ahead of buffered output: flush the coalescer first, then forward.
+        outputCoalescer.flush();
         sendToParent({
             type: "terminalMessage",
             terminalId: session.id,
@@ -50,6 +118,7 @@ function watchTerminal(session) {
         });
     });
     const unsubscribeExit = session.onExit((info) => {
+        outputCoalescer.flush();
         clearTerminalSubscriptions(session.id);
         sendToParent({
             type: "terminalExit",
@@ -58,6 +127,7 @@ function watchTerminal(session) {
         });
     });
     const unsubscribeTitle = session.onTitleChange((title) => {
+        outputCoalescer.flush();
         sendToParent({
             type: "terminalTitleChange",
             terminalId: session.id,
@@ -65,56 +135,80 @@ function watchTerminal(session) {
         });
     });
     const unsubscribeCommandFinished = session.onCommandFinished((info) => {
+        outputCoalescer.flush();
         sendToParent({
             type: "terminalCommandFinished",
             terminalId: session.id,
             info,
         });
     });
+    const unsubscribeActivity = session.onActivityChange((transition) => {
+        sendToParent({
+            type: "terminalActivityChange",
+            terminalId: session.id,
+            activity: transition.activity,
+            previous: transition.previous,
+        });
+    });
     unsubscribeByTerminalId.set(session.id, [
         unsubscribeMessage,
         unsubscribeExit,
         unsubscribeTitle,
         unsubscribeCommandFinished,
+        unsubscribeActivity,
     ]);
 }
-manager.subscribeTerminalsChanged((event) => {
-    sendToParent({
-        type: "terminalsChanged",
-        cwd: event.cwd,
-        terminals: event.terminals,
-    });
-});
-async function handleRequest(message) {
-    switch (message.type) {
-        case "getTerminals": {
-            const terminals = await manager.getTerminals(message.cwd);
-            sendToParent({
-                type: "response",
-                requestId: message.requestId,
-                ok: true,
-                result: terminals.map(toTerminalInfo),
-            });
+function enqueueCreateTerminalRequest(message) {
+    const nextRequest = createTerminalQueue.then(() => handleCreateTerminalRequest(message));
+    createTerminalQueue = nextRequest.catch(() => { });
+    return nextRequest;
+}
+async function handleCreateTerminalRequest(message) {
+    const request = {
+        requestId: message.requestId,
+        errorReported: false,
+    };
+    inFlightTerminalCreateRequest = request;
+    try {
+        const { workspaceId } = message.options;
+        if (!workspaceId) {
+            throw new Error("workspaceId is required");
+        }
+        const session = await manager.createTerminal({ ...message.options, workspaceId });
+        if (request.errorReported) {
+            session.kill();
             return;
         }
-        case "createTerminal": {
-            const session = await manager.createTerminal(message.options);
-            watchTerminal(session);
-            const initialSnapshot = session.getStateSnapshot();
-            sendToParent({
-                type: "terminalCreated",
+        watchTerminal(session);
+        const initialSnapshot = session.getStateSnapshot();
+        sendToParent({
+            type: "terminalCreated",
+            terminal: toTerminalInfo(session),
+            state: initialSnapshot.state,
+        });
+        sendToParent({
+            type: "response",
+            requestId: message.requestId,
+            ok: true,
+            result: {
                 terminal: toTerminalInfo(session),
                 state: initialSnapshot.state,
-            });
-            sendToParent({
-                type: "response",
-                requestId: message.requestId,
-                ok: true,
-                result: {
-                    terminal: toTerminalInfo(session),
-                    state: initialSnapshot.state,
-                },
-            });
+            },
+        });
+    }
+    catch (error) {
+        reportInFlightTerminalCreateFailure(error);
+    }
+    finally {
+        if (inFlightTerminalCreateRequest === request) {
+            inFlightTerminalCreateRequest = null;
+        }
+    }
+}
+async function handleRequest(message) {
+    switch (message.type) {
+        case "createTerminal": {
+            await enqueueCreateTerminalRequest(message);
             return;
         }
         case "registerCwdEnv": {
@@ -122,52 +216,41 @@ async function handleRequest(message) {
             sendToParent({ type: "response", requestId: message.requestId, ok: true });
             return;
         }
+        case "setActivity": {
+            await manager.setTerminalActivity(message.terminalId, message.state);
+            sendToParent({ type: "response", requestId: message.requestId, ok: true });
+            return;
+        }
+        case "clearAttention": {
+            await manager.clearTerminalAttention(message.terminalId);
+            sendToParent({ type: "response", requestId: message.requestId, ok: true });
+            return;
+        }
         case "killTerminal": {
-            const session = manager.getTerminal(message.terminalId);
-            const cwd = session?.cwd;
             manager.killTerminal(message.terminalId);
+            // Removal is owned by session.onExit -> terminalExit; the parent mirror
+            // clears contribution and emits terminalsChanged from that single path.
             clearTerminalSubscriptions(message.terminalId);
-            if (cwd) {
-                sendToParent({
-                    type: "terminalRemoved",
-                    terminalId: message.terminalId,
-                    cwd,
-                });
-            }
             sendToParent({ type: "response", requestId: message.requestId, ok: true });
             return;
         }
         case "killTerminalAndWait": {
-            const session = manager.getTerminal(message.terminalId);
-            const cwd = session?.cwd;
             await manager.killTerminalAndWait(message.terminalId, message.options);
             clearTerminalSubscriptions(message.terminalId);
-            if (cwd) {
-                sendToParent({
-                    type: "terminalRemoved",
-                    terminalId: message.terminalId,
-                    cwd,
-                });
-            }
             sendToParent({ type: "response", requestId: message.requestId, ok: true });
             return;
         }
         case "getTerminalState": {
-            const session = manager.getTerminal(message.terminalId);
-            sendToParent({
-                type: "response",
-                requestId: message.requestId,
-                ok: true,
-                result: session?.getStateSnapshot(message.options) ?? null,
-            });
-            return;
-        }
-        case "listDirectories": {
+            // Flush buffered output before snapshotting: the headless state already includes it,
+            // so if the coalescer emitted it afterward (in a batch carrying a revision past the
+            // snapshot's) the controller's revision dedup wouldn't drop it and the client would
+            // see the bytes twice. Flushing first sends them with a revision <= the snapshot's.
+            outputCoalescerByTerminalId.get(message.terminalId)?.flush();
             sendToParent({
                 type: "response",
                 requestId: message.requestId,
                 ok: true,
-                result: manager.listDirectories(),
+                result: buildTerminalStateResult(manager.getTerminal(message.terminalId), message.options),
             });
             return;
         }
@@ -210,7 +293,7 @@ process.on("message", (message) => {
             type: "response",
             requestId: message.requestId,
             ok: false,
-            error: error instanceof Error ? error.message : "Terminal worker request failed",
+            error: terminalWorkerErrorMessage(error),
         });
     });
 });

package/dist/server/terminal/terminal-worker-protocol.d.ts

@@ -1,30 +1,32 @@
 import type { TerminalExitInfo, ServerMessage, ClientMessage, TerminalStateSnapshot, TerminalStateSnapshotOptions } from "./terminal.js";
 import type { TerminalState } from "@getpaseo/protocol/messages";
+import type { TerminalActivity, TerminalActivityState } from "@getpaseo/protocol/terminal-activity";
 import type { CaptureTerminalLinesResult } from "./terminal-capture.js";
 export interface WorkerTerminalInfo {
     id: string;
     name: string;
     cwd: string;
+    workspaceId?: string;
     title?: string;
+    activity: TerminalActivity | null;
 }
 export interface WorkerCreateTerminalOptions {
     id?: string;
     cwd: string;
+    workspaceId?: string;
     name?: string;
     title?: string;
     env?: Record<string, string>;
     command?: string;
     args?: string[];
+    activityToken?: string;
+    activityUrl?: string | null;
 }
 export interface WorkerKillAndWaitOptions {
     gracefulTimeoutMs?: number;
     forceTimeoutMs?: number;
 }
 export type TerminalWorkerRequest = {
-    type: "getTerminals";
-    requestId: string;
-    cwd: string;
-} | {
     type: "createTerminal";
     requestId: string;
     options: WorkerCreateTerminalOptions;
@@ -33,6 +35,15 @@ export type TerminalWorkerRequest = {
     requestId: string;
     cwd: string;
     env: Record<string, string>;
+} | {
+    type: "setActivity";
+    requestId: string;
+    terminalId: string;
+    state: TerminalActivityState;
+} | {
+    type: "clearAttention";
+    requestId: string;
+    terminalId: string;
 } | {
     type: "killTerminal";
     requestId: string;
@@ -54,9 +65,6 @@ export type TerminalWorkerRequest = {
     start?: number;
     end?: number;
     stripAnsi?: boolean;
-} | {
-    type: "listDirectories";
-    requestId: string;
 } | {
     type: "killAll";
     requestId: string;
@@ -81,10 +89,6 @@ export type TerminalWorkerEvent = {
     type: "terminalCreated";
     terminal: WorkerTerminalInfo;
     state: TerminalState;
-} | {
-    type: "terminalRemoved";
-    terminalId: string;
-    cwd: string;
 } | {
     type: "terminalMessage";
     terminalId: string;
@@ -104,9 +108,10 @@ export type TerminalWorkerEvent = {
         exitCode: number | null;
     };
 } | {
-    type: "terminalsChanged";
-    cwd: string;
-    terminals: WorkerTerminalInfo[];
+    type: "terminalActivityChange";
+    terminalId: string;
+    activity: TerminalActivity | null;
+    previous: TerminalActivity | null;
 };
 export type TerminalWorkerToParentMessage = TerminalWorkerResponse | TerminalWorkerEvent;
 export type TerminalWorkerCaptureResult = CaptureTerminalLinesResult;