@getpaseo/server 0.1.95 → 0.1.97-beta.1

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;

package/dist/server/terminal/terminal.d.ts

@@ -1,4 +1,5 @@
 import type { TerminalState } from "@getpaseo/protocol/messages";
+import type { TerminalActivity, TerminalActivityState } from "@getpaseo/protocol/terminal-activity";
 export interface TerminalExitInfo {
     exitCode: number | null;
     signal: number | null;
@@ -10,6 +11,7 @@ export interface TerminalCommandFinishedInfo {
 export interface TerminalStateSnapshot {
     state: TerminalState;
     revision: number;
+    replayPreamble?: string;
 }
 export interface TerminalStateSnapshotOptions {
     scrollbackLines?: number;
@@ -43,19 +45,26 @@ export type ServerMessage = {
 } | {
     type: "snapshotReady";
     revision?: number;
+    replayPreamble?: string;
 } | {
     type: "titleChange";
     title?: string;
 };
+export interface TerminalActivityTransition {
+    activity: TerminalActivity | null;
+    previous: TerminalActivity | null;
+}
 export interface TerminalSession {
     id: string;
     name: string;
     cwd: string;
+    workspaceId: string;
     send(msg: ClientMessage): void;
     subscribe(listener: (msg: ServerMessage) => void, options?: TerminalSubscribeOptions): () => void;
     onExit(listener: (info: TerminalExitInfo) => void): () => void;
     onCommandFinished(listener: (info: TerminalCommandFinishedInfo) => void): () => void;
     onTitleChange(listener: (title?: string) => void): () => void;
+    onActivityChange(listener: (transition: TerminalActivityTransition) => void): () => void;
     getSize(): {
         rows: number;
         cols: number;
@@ -64,6 +73,9 @@ export interface TerminalSession {
     getStateSnapshot(options?: TerminalStateSnapshotOptions): TerminalStateSnapshot;
     getReplayPreamble(): string;
     getTitle(): string | undefined;
+    getActivity(): TerminalActivity | null;
+    setActivity(state: TerminalActivityState): void;
+    clearActivityAttention(): boolean;
     setTitle(title: string): void;
     getExitInfo(): TerminalExitInfo | null;
     kill(): void;
@@ -75,8 +87,10 @@ export interface TerminalSession {
 export interface CreateTerminalOptions {
     id?: string;
     cwd: string;
+    workspaceId: string;
     shell?: string;
     env?: Record<string, string>;
+    activityEnv?: Record<string, string>;
     rows?: number;
     cols?: number;
     name?: string;
@@ -88,6 +102,8 @@ interface BuildTerminalEnvironmentInput {
     shell: string;
     env: Record<string, string>;
     zshShellIntegrationDir?: string;
+    paseoCliBinDir?: string | null;
+    paseoHookCliPath?: string | null;
 }
 interface EnsureNodePtySpawnHelperExecutableOptions {
     packageRoot?: string;
@@ -100,7 +116,33 @@ export declare function resolveDefaultTerminalShell(options?: {
     platform?: NodeJS.Platform;
     env?: NodeJS.ProcessEnv;
 }): string;
+export interface ResolvedTerminalCommand {
+    command: string;
+    args: string[];
+}
+export interface ResolveTerminalSpawnCommandOptions {
+    platform?: NodeJS.Platform;
+    env?: Record<string, string | undefined>;
+    resolveExecutable?: (name: string) => Promise<string | null>;
+}
+/**
+ * Resolve a terminal profile command (e.g. `claude`) into something node-pty's
+ * conpty backend can actually launch on Windows.
+ *
+ * On Windows, conpty's underlying `CreateProcess` does not apply `PATHEXT`, so a
+ * bare `claude` (installed by npm as `claude.cmd`) fails with `error code: 2`
+ * (`ERROR_FILE_NOT_FOUND`). Worse, conpty completes the spawn asynchronously on
+ * its own conout worker thread, so that failure surfaces as an uncaught
+ * exception that takes down the whole terminal worker process. Resolving the
+ * real path up front — and routing `.cmd`/`.bat` shims through `cmd.exe /c`
+ * (node-pty has no `shell` option) — keeps the profile launchable.
+ *
+ * Non-Windows and the default-shell path (no explicit command) are unchanged.
+ */
+export declare function resolveTerminalSpawnCommand(command: string, args: string[], options?: ResolveTerminalSpawnCommandOptions): Promise<ResolvedTerminalCommand>;
 export declare function resolveZshShellIntegrationDir(): string;
+export declare function resolvePaseoCliBinDir(): string | null;
+export declare function resolvePaseoCliExecutablePath(): string | null;
 export declare function buildTerminalEnvironment(input: BuildTerminalEnvironmentInput): Record<string, string>;
 export declare function normalizeProcessTitle(processTitle: string): string | undefined;
 export declare function humanizeProcessTitle(processTitle: string): string | undefined;