@minionry/minion 0.7.36

package/dist/server/services/websocket/tab-event-buffer.js

@@ -0,0 +1,110 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export class SeqEventBuffer {
+    maxEvents;
+    maxAgeMs;
+    now;
+    maxTotalBytes;
+    events = [];
+    nextSeq = 1;
+    evictedThroughSeq = 0;
+    totalBytes = 0;
+    constructor(maxEvents = DEFAULT_MAX_EVENTS, maxAgeMs = DEFAULT_MAX_AGE_MS, now = Date.now, maxTotalBytes = DEFAULT_MAX_TOTAL_BYTES) {
+        this.maxEvents = maxEvents;
+        this.maxAgeMs = maxAgeMs;
+        this.now = now;
+        this.maxTotalBytes = maxTotalBytes;
+    }
+    record(type, data) {
+        const seq = this.nextSeq++;
+        const byteSize = estimateByteSize(data);
+        this.events.push({ seq, type, data, timestamp: this.now(), byteSize });
+        this.totalBytes += byteSize;
+        this.evict();
+        return seq;
+    }
+    getSince(afterSeq) {
+        this.evict();
+        const out = [];
+        for (const event of this.events) {
+            if (event.seq > afterSeq)
+                out.push(event);
+        }
+        return out;
+    }
+    hasGapSince(afterSeq) {
+        this.evict();
+        return afterSeq < this.evictedThroughSeq;
+    }
+    getEvictedThroughSeq() {
+        return this.evictedThroughSeq;
+    }
+    currentSeq() {
+        return this.nextSeq - 1;
+    }
+    size() {
+        return this.events.length;
+    }
+    byteSize() {
+        return this.totalBytes;
+    }
+    evict() {
+        const cutoff = this.now() - this.maxAgeMs;
+        while (this.events.length > 0 && this.events[0].timestamp < cutoff) {
+            this.popOldest();
+        }
+        while (this.events.length > this.maxEvents) {
+            this.popOldest();
+        }
+        while (this.events.length > 0 && this.totalBytes > this.maxTotalBytes) {
+            this.popOldest();
+        }
+    }
+    popOldest() {
+        const evicted = this.events.shift();
+        if (!evicted)
+            return;
+        this.evictedThroughSeq = evicted.seq;
+        this.totalBytes -= evicted.byteSize;
+        if (this.totalBytes < 0)
+            this.totalBytes = 0;
+    }
+}
+function estimateByteSize(data) {
+    if (data === undefined || data === null)
+        return 0;
+    try {
+        return JSON.stringify(data).length;
+    }
+    catch {
+        return 256;
+    }
+}
+export class SeqEventBufferRegistry {
+    bufferFactory;
+    buffers = new Map();
+    constructor(bufferFactory = () => new SeqEventBuffer()) {
+        this.bufferFactory = bufferFactory;
+    }
+    getOrCreate(key) {
+        let buffer = this.buffers.get(key);
+        if (!buffer) {
+            buffer = this.bufferFactory();
+            this.buffers.set(key, buffer);
+        }
+        return buffer;
+    }
+    get(key) {
+        return this.buffers.get(key);
+    }
+    delete(key) {
+        this.buffers.delete(key);
+    }
+    clear() {
+        this.buffers.clear();
+    }
+}
+export { SeqEventBuffer as TabEventBuffer, SeqEventBufferRegistry as TabEventBufferRegistry };
+export const DEFAULT_MAX_EVENTS = 20_000;
+export const DEFAULT_MAX_AGE_MS = 60 * 60 * 1000;
+export const DEFAULT_MAX_TOTAL_BYTES = 32 * 1024 * 1024;

package/dist/server/services/websocket/tab-event-replay.js

@@ -0,0 +1,47 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { captureException } from '../sentry.js';
+export function planSeqReplay(buffer, afterSeq) {
+    if (buffer.hasGapSince(afterSeq)) {
+        return {
+            kind: 'gap',
+            evictedThroughSeq: buffer.getEvictedThroughSeq(),
+            currentSeq: buffer.currentSeq(),
+        };
+    }
+    return { kind: 'replay', events: buffer.getSince(afterSeq) };
+}
+export function replayTabEventsSince(ctx, ws, tabId, lastSeenSeq) {
+    if (lastSeenSeq === undefined)
+        return { sentCount: 0, hadGap: false };
+    const buffer = ctx.tabEventBuffers.get(tabId);
+    if (!buffer)
+        return { sentCount: 0, hadGap: false };
+    const plan = planSeqReplay(buffer, lastSeenSeq);
+    if (plan.kind === 'gap') {
+        const evictedThroughSeq = plan.evictedThroughSeq;
+        const message = `[tab-replay] gap detected for tab=${tabId}: web requested replay from seq=${lastSeenSeq}, ` +
+            `but buffer has evicted through seq=${evictedThroughSeq}. ` +
+            `Events (${lastSeenSeq + 1}..${evictedThroughSeq}) are unavailable; the web's ` +
+            `incremental state is stale and a full snapshot will be sent instead.`;
+        console.warn(message);
+        try {
+            captureException(new Error('TabEventBuffer replay gap'), {
+                context: 'tab-event-replay',
+                tabId,
+                lastSeenSeq,
+                evictedThroughSeq,
+                bufferCurrentSeq: plan.currentSeq,
+                gapSize: evictedThroughSeq - lastSeenSeq,
+            });
+        }
+        catch {
+        }
+        return { sentCount: 0, hadGap: true, evictedThroughSeq, lastSeenSeq };
+    }
+    const { events } = plan;
+    for (const event of events) {
+        ctx.send(ws, { type: event.type, tabId, data: event.data, seq: event.seq });
+    }
+    return { sentCount: events.length, hadGap: false, lastSeenSeq };
+}

package/dist/server/services/websocket/tab-handlers.js

@@ -0,0 +1,211 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
+import { cancelAppRunForClosedTab } from '../sdk/agents.js';
+import { getEffortLevel, getModel } from '../settings.js';
+import { clearScope, scopeRepoPath, scopeRepoWorktrees, scopeWorktreePath } from './handler-context.js';
+import { resolveEngineForSession, restoreWorktreeFromRegistry, setupSessionListeners } from './session-handlers.js';
+import { DEFAULT_ENGINE_ID, isEngineId } from './types.js';
+function hasSettledMovements(session) {
+    return session.getHistory().movements.some((movement) => (movement.durationMs ?? 0) > 0);
+}
+function buildActiveTabData(regTab, session, git) {
+    return {
+        tabName: regTab.tabName,
+        createdAt: regTab.createdAt,
+        order: regTab.order,
+        hasUnviewedCompletion: regTab.hasUnviewedCompletion,
+        engine: resolveEngineForSession(session),
+        sessionInfo: session.getSessionInfo(),
+        isExecuting: session.isExecuting,
+        outputHistory: [],
+        hasStoredHistory: hasSettledMovements(session) || regTab.hasPersistedHistory === true,
+        ...(session.isExecuting && session.executionStartTimestamp ? { executionStartTimestamp: session.executionStartTimestamp } : {}),
+        ...(git.worktreePath ? { worktreePath: git.worktreePath, worktreeBranch: git.worktreeBranch } : {}),
+        ...(git.repoPath ? { repoPath: git.repoPath } : {}),
+        repoWorktrees: git.repoWorktrees,
+        ...(regTab.engineOverride ? { engineOverride: regTab.engineOverride } : {}),
+        ...(regTab.appLink ? { appLink: regTab.appLink } : {}),
+    };
+}
+function buildInactiveTabData(regTab, git) {
+    return {
+        tabName: regTab.tabName,
+        createdAt: regTab.createdAt,
+        order: regTab.order,
+        hasUnviewedCompletion: regTab.hasUnviewedCompletion,
+        engine: DEFAULT_ENGINE_ID,
+        sessionId: regTab.sessionId,
+        isExecuting: false,
+        outputHistory: [],
+        hasStoredHistory: regTab.hasPersistedHistory === true,
+        ...(git.worktreePath ? { worktreePath: git.worktreePath, worktreeBranch: git.worktreeBranch } : {}),
+        ...(git.repoPath ? { repoPath: git.repoPath } : {}),
+        repoWorktrees: git.repoWorktrees,
+        ...(regTab.engineOverride ? { engineOverride: regTab.engineOverride } : {}),
+        ...(regTab.appLink ? { appLink: regTab.appLink } : {}),
+    };
+}
+export function handleGetActiveTabs(ctx, ws, workingDir) {
+    const registry = ctx.getRegistry(workingDir);
+    const allTabs = registry.getAllTabs();
+    const tabs = {};
+    for (const [tabId, regTab] of Object.entries(allTabs)) {
+        if (regTab.webManaged)
+            continue;
+        const session = ctx.sessions.get(regTab.sessionId);
+        restoreWorktreeFromRegistry(ctx, registry, tabId);
+        const git = {
+            worktreePath: scopeWorktreePath(ctx, tabId),
+            worktreeBranch: ctx.gitBranches.get(tabId),
+            repoPath: scopeRepoPath(ctx, tabId),
+            repoWorktrees: scopeRepoWorktrees(ctx, tabId),
+        };
+        tabs[tabId] = session ? buildActiveTabData(regTab, session, git) : buildInactiveTabData(regTab, git);
+    }
+    ctx.send(ws, { type: 'activeTabs', data: { tabs } });
+}
+export function handleSyncTabMeta(ctx, _ws, msg, tabId, workingDir) {
+    const registry = ctx.getRegistry(workingDir);
+    if (msg.data?.tabName) {
+        registry.updateTabName(tabId, msg.data.tabName);
+        ctx.broadcastToAll({
+            type: 'tabRenamed',
+            data: { tabId, tabName: msg.data.tabName }
+        });
+    }
+}
+export function handleRemoveTab(ctx, _ws, tabId, workingDir) {
+    cancelAppRunForClosedTab(tabId);
+    const registry = ctx.getRegistry(workingDir);
+    registry.unregisterTab(tabId);
+    clearScope(ctx, tabId);
+    ctx.gitBranches.delete(tabId);
+    ctx.tabEventBuffers.delete(tabId);
+    ctx.chatTimelines.delete(tabId);
+    ctx.msgIdTracker.forget(tabId);
+    ctx.broadcastToAll({
+        type: 'tabRemoved',
+        data: { tabId }
+    });
+}
+export function handleMarkTabViewed(ctx, _ws, tabId, workingDir) {
+    const registry = ctx.getRegistry(workingDir);
+    registry.markTabViewed(tabId);
+    ctx.broadcastToAll({
+        type: 'tabViewed',
+        data: { tabId }
+    });
+}
+export function handleSetTabEngine(ctx, _ws, msg, tabId, workingDir) {
+    const raw = msg.data?.override;
+    let override;
+    if (raw === null || raw === undefined) {
+        override = null;
+    }
+    else {
+        const parsed = parseTabEngineOverride(raw);
+        if (!parsed) {
+            return;
+        }
+        override = parsed;
+    }
+    const registry = ctx.getRegistry(workingDir);
+    registry.updateTabEngineOverride(tabId, override);
+    ctx.broadcastToAll({
+        type: 'tabEngineOverride',
+        tabId,
+        data: { tabId, override },
+    });
+}
+export function parseTabEngineOverride(raw) {
+    if (typeof raw !== 'object' ||
+        !isEngineId(raw.engine) ||
+        typeof raw.model !== 'string' || raw.model.length === 0 ||
+        typeof raw.effortLevel !== 'string' || raw.effortLevel.length === 0) {
+        return null;
+    }
+    const override = {
+        engine: raw.engine,
+        model: raw.model,
+        effortLevel: raw.effortLevel,
+        ...(typeof raw.fastMode === 'boolean' ? { fastMode: raw.fastMode } : {}),
+        ...(typeof raw.ultracode === 'boolean' ? { ultracode: raw.ultracode } : {}),
+        ...(typeof raw.systemPromptProfile === 'string' && raw.systemPromptProfile.length > 0
+            ? { systemPromptProfile: raw.systemPromptProfile }
+            : {}),
+        ...(typeof raw.systemPromptLang === 'string' && raw.systemPromptLang.length > 0
+            ? { systemPromptLang: raw.systemPromptLang }
+            : {}),
+    };
+    if (override.effortLevel === 'ultracode') {
+        override.effortLevel = 'auto';
+        override.ultracode = true;
+    }
+    return override;
+}
+export async function handleCreateTab(ctx, ws, workingDir, tabName, optimisticTabId) {
+    const registry = ctx.getRegistry(workingDir);
+    const tabId = optimisticTabId || `tab-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const existingSession = registry.getTabSession(tabId);
+    if (existingSession) {
+        const regTab = registry.getTab(tabId);
+        const existingSessionObj = ctx.sessions.get(existingSession);
+        const engine = resolveEngineForSession(existingSessionObj);
+        ctx.send(ws, {
+            type: 'tabCreated',
+            engine,
+            data: {
+                tabId,
+                tabName: regTab?.tabName || 'Agent',
+                createdAt: regTab?.createdAt,
+                order: regTab?.order,
+                engine,
+                sessionInfo: existingSessionObj?.getSessionInfo(),
+            }
+        });
+        return;
+    }
+    const session = new ImprovisationSessionManager({ workingDir, model: getModel(), effortLevel: getEffortLevel() });
+    setupSessionListeners(ctx, session, ws, tabId);
+    const sessionId = session.getSessionInfo().sessionId;
+    ctx.sessions.set(sessionId, session);
+    const tabMap = ctx.connections.get(ws);
+    if (tabMap)
+        tabMap.set(tabId, sessionId);
+    registry.registerTab(tabId, sessionId, tabName);
+    const registeredTab = registry.getTab(tabId);
+    const engine = resolveEngineForSession(session);
+    ctx.broadcastToAll({
+        type: 'tabCreated',
+        engine,
+        data: {
+            tabId,
+            tabName: registeredTab?.tabName || 'Agent',
+            createdAt: registeredTab?.createdAt,
+            order: registeredTab?.order,
+            engine,
+            sessionInfo: session.getSessionInfo(),
+        }
+    });
+    ctx.send(ws, {
+        type: 'tabInitialized',
+        tabId,
+        engine,
+        data: session.getSessionInfo()
+    });
+}
+export function handleReorderTabs(ctx, _ws, workingDir, tabOrder) {
+    if (!Array.isArray(tabOrder))
+        return;
+    const registry = ctx.getRegistry(workingDir);
+    registry.reorderTabs(tabOrder);
+    const allTabs = registry.getAllTabs();
+    const orderMap = tabOrder
+        .filter((id) => allTabs[id])
+        .map((id) => ({ tabId: id, order: allTabs[id].order }));
+    ctx.broadcastToAll({
+        type: 'tabsReordered',
+        data: { tabOrder: orderMap }
+    });
+}

package/dist/server/services/websocket/terminal-handlers.js

@@ -0,0 +1,268 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { statSync } from 'node:fs';
+import { platform } from 'node:os';
+import { isAbsolute } from 'node:path';
+import { AnalyticsEvents, trackEvent } from '../analytics.js';
+import { getPTYManager, reloadPty } from '../terminal/pty-manager.js';
+import { notifySdkTerminalSessionOpened } from './sdk-terminal-host.js';
+export async function handleTerminalMessage(ctx, ws, msg, tabId, workingDir) {
+    const termId = msg.terminalId || tabId;
+    switch (msg.type) {
+        case 'terminalInit':
+            await handleTerminalInit(ctx, ws, termId, workingDir, msg.data?.cwd, msg.data?.shell, msg.data?.cols, msg.data?.rows);
+            break;
+        case 'terminalReconnect':
+            handleTerminalReconnect(ctx, ws, termId);
+            break;
+        case 'terminalList':
+            handleTerminalList(ctx, ws);
+            break;
+        case 'terminalInput':
+            handleTerminalInput(ctx, ws, termId, msg.data?.input);
+            break;
+        case 'terminalResize':
+            handleTerminalResize(ctx, termId, msg.data?.cols, msg.data?.rows);
+            break;
+        case 'terminalClose':
+            handleTerminalClose(ctx, ws, termId);
+            break;
+    }
+}
+async function handleTerminalInit(ctx, ws, terminalId, workingDir, requestedCwd, requestedShell, cols, rows) {
+    const ptyManager = getPTYManager();
+    if (!ptyManager.isPtyAvailable()) {
+        await reloadPty();
+    }
+    if (!ptyManager.isPtyAvailable()) {
+        ctx.send(ws, {
+            type: 'terminalError',
+            terminalId,
+            data: {
+                error: 'PTY_NOT_AVAILABLE',
+                instructions: ptyManager.getPtyInstallInstructions()
+            }
+        });
+        return;
+    }
+    addTerminalSubscriber(ctx, terminalId, ws);
+    setupTerminalBroadcastListeners(ctx, terminalId);
+    const effectiveCwd = resolveEffectiveCwd(requestedCwd, workingDir);
+    try {
+        const { shell, cwd, isReconnect, platform } = await ptyManager.create(terminalId, effectiveCwd, cols || 80, rows || 24, requestedShell);
+        if (!isReconnect) {
+            ctx.broadcastToOthers(ws, {
+                type: 'terminalCreated',
+                data: { terminalId, shell, cwd }
+            });
+            notifySdkTerminalSessionOpened(terminalId);
+        }
+        ctx.send(ws, {
+            type: 'terminalReady',
+            terminalId,
+            data: { shell, cwd, isReconnect, platform }
+        });
+        if (isReconnect) {
+            const scrollback = ptyManager.getScrollback(terminalId);
+            if (scrollback) {
+                ctx.send(ws, { type: 'terminalScrollback', terminalId, data: { scrollback } });
+            }
+        }
+        trackEvent(AnalyticsEvents.TERMINAL_SESSION_CREATED, {
+            shell,
+            is_reconnect: isReconnect,
+        });
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`[WebSocketImproviseHandler] Failed to create terminal:`, error);
+        ctx.send(ws, {
+            type: 'terminalError',
+            terminalId,
+            data: { error: errorMsg || 'Failed to create terminal' }
+        });
+        removeTerminalSubscriber(ctx, terminalId, ws);
+    }
+}
+function handleTerminalReconnect(ctx, ws, terminalId) {
+    const ptyManager = getPTYManager();
+    const sessionInfo = ptyManager.getSessionInfo(terminalId);
+    if (!sessionInfo) {
+        ctx.send(ws, {
+            type: 'terminalError',
+            terminalId,
+            data: { error: 'Terminal session not found', sessionNotFound: true }
+        });
+        return;
+    }
+    addTerminalSubscriber(ctx, terminalId, ws);
+    setupTerminalBroadcastListeners(ctx, terminalId);
+    ctx.send(ws, {
+        type: 'terminalReady',
+        terminalId,
+        data: {
+            shell: sessionInfo.shell,
+            cwd: sessionInfo.cwd,
+            isReconnect: true,
+            platform: platform(),
+        }
+    });
+    const scrollback = ptyManager.getScrollback(terminalId);
+    if (scrollback) {
+        ctx.send(ws, { type: 'terminalScrollback', terminalId, data: { scrollback } });
+    }
+    ptyManager.resize(terminalId, sessionInfo.cols, sessionInfo.rows);
+}
+function handleTerminalList(ctx, ws) {
+    const ptyManager = getPTYManager();
+    const terminalIds = ptyManager.getActiveTerminals();
+    const terminals = terminalIds.map(id => {
+        const info = ptyManager.getSessionInfo(id);
+        return info ? { id, ...info } : null;
+    }).filter(Boolean);
+    ctx.send(ws, {
+        type: 'terminalList',
+        data: { terminals }
+    });
+}
+function handleTerminalInput(ctx, ws, terminalId, input) {
+    if (!input)
+        return;
+    const ptyManager = getPTYManager();
+    const success = ptyManager.write(terminalId, input);
+    if (!success) {
+        ctx.send(ws, {
+            type: 'terminalError',
+            terminalId,
+            data: { error: 'Terminal not found or write failed' }
+        });
+    }
+}
+function handleTerminalResize(_ctx, terminalId, cols, rows) {
+    if (!cols || !rows)
+        return;
+    const ptyManager = getPTYManager();
+    ptyManager.resize(terminalId, cols, rows);
+}
+function handleTerminalClose(ctx, ws, terminalId) {
+    trackEvent(AnalyticsEvents.TERMINAL_SESSION_CLOSED);
+    const listenerCleanup = ctx.terminalListenerCleanups.get(terminalId);
+    if (listenerCleanup) {
+        listenerCleanup();
+        ctx.terminalListenerCleanups.delete(terminalId);
+    }
+    const ptyManager = getPTYManager();
+    const ownerLabel = ptyManager.getSessionInfo(terminalId)?.ownerLabel;
+    ptyManager.close(terminalId);
+    ctx.terminalSubscribers.delete(terminalId);
+    ctx.broadcastToOthers(ws, {
+        type: 'terminalClosed',
+        data: { terminalId, ...(ownerLabel !== undefined ? { ownerLabel } : {}) }
+    });
+}
+function addTerminalSubscriber(ctx, terminalId, ws) {
+    let subs = ctx.terminalSubscribers.get(terminalId);
+    if (!subs) {
+        subs = new Set();
+        ctx.terminalSubscribers.set(terminalId, subs);
+    }
+    subs.add(ws);
+}
+function removeTerminalSubscriber(ctx, terminalId, ws) {
+    const subs = ctx.terminalSubscribers.get(terminalId);
+    if (!subs)
+        return;
+    subs.delete(ws);
+    if (subs.size > 0)
+        return;
+    ctx.terminalSubscribers.delete(terminalId);
+    const cleanup = ctx.terminalListenerCleanups.get(terminalId);
+    if (cleanup) {
+        cleanup();
+        ctx.terminalListenerCleanups.delete(terminalId);
+    }
+}
+function setupTerminalBroadcastListeners(ctx, terminalId) {
+    if (ctx.terminalListenerCleanups.has(terminalId))
+        return;
+    const ptyManager = getPTYManager();
+    const onOutput = (tid, data) => {
+        if (tid === terminalId) {
+            const subs = ctx.terminalSubscribers.get(terminalId);
+            if (subs) {
+                for (const ws of subs) {
+                    ctx.send(ws, { type: 'terminalOutput', terminalId, data: { output: data } });
+                }
+            }
+        }
+    };
+    const onExit = (tid, exitCode) => {
+        if (tid === terminalId) {
+            const subs = ctx.terminalSubscribers.get(terminalId);
+            if (subs) {
+                for (const ws of subs) {
+                    ctx.send(ws, { type: 'terminalExit', terminalId, data: { exitCode } });
+                }
+            }
+            ptyManager.off('output', onOutput);
+            ptyManager.off('exit', onExit);
+            ptyManager.off('error', onError);
+            ctx.terminalListenerCleanups.delete(terminalId);
+            ctx.terminalSubscribers.delete(terminalId);
+        }
+    };
+    const onError = (tid, error) => {
+        if (tid === terminalId) {
+            const subs = ctx.terminalSubscribers.get(terminalId);
+            if (subs) {
+                for (const ws of subs) {
+                    ctx.send(ws, { type: 'terminalError', terminalId, data: { error } });
+                }
+            }
+        }
+    };
+    ptyManager.on('output', onOutput);
+    ptyManager.on('exit', onExit);
+    ptyManager.on('error', onError);
+    ctx.terminalListenerCleanups.set(terminalId, () => {
+        ptyManager.off('output', onOutput);
+        ptyManager.off('exit', onExit);
+        ptyManager.off('error', onError);
+    });
+}
+export function resolveEffectiveCwd(requestedCwd, workingDir) {
+    if (!requestedCwd || typeof requestedCwd !== 'string')
+        return workingDir;
+    if (!isAbsolute(requestedCwd)) {
+        console.warn(`[terminalInit] Ignoring non-absolute cwd: ${requestedCwd}`);
+        return workingDir;
+    }
+    try {
+        if (!statSync(requestedCwd).isDirectory()) {
+            console.warn(`[terminalInit] Ignoring non-directory cwd: ${requestedCwd}`);
+            return workingDir;
+        }
+    }
+    catch {
+        console.warn(`[terminalInit] Ignoring inaccessible cwd: ${requestedCwd}`);
+        return workingDir;
+    }
+    return requestedCwd;
+}
+export function cleanupTerminalSubscribers(ctx, ws) {
+    const emptyTerminals = [];
+    for (const [terminalId, subs] of ctx.terminalSubscribers) {
+        subs.delete(ws);
+        if (subs.size === 0) {
+            emptyTerminals.push(terminalId);
+        }
+    }
+    for (const terminalId of emptyTerminals) {
+        ctx.terminalSubscribers.delete(terminalId);
+        const cleanup = ctx.terminalListenerCleanups.get(terminalId);
+        if (cleanup) {
+            cleanup();
+            ctx.terminalListenerCleanups.delete(terminalId);
+        }
+    }
+}