@wingman-ai/gateway 0.2.2 → 0.2.4

package/dist/agent/tools/terminal_session_manager.cjs

@@ -0,0 +1,321 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    TerminalSessionManager: ()=>TerminalSessionManager,
+    getSharedTerminalSessionManager: ()=>getSharedTerminalSessionManager
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_events_namespaceObject = require("node:events");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_MAX_SESSIONS_PER_OWNER = 4;
+const DEFAULT_MAX_BUFFERED_CHARS = 256000;
+const DEFAULT_MAX_RUNTIME_MS = 1800000;
+const DEFAULT_IDLE_TIMEOUT_MS = 900000;
+const DEFAULT_COMPLETED_RETENTION_MS = 900000;
+const DEFAULT_TERMINATION_GRACE_MS = 2000;
+const DEFAULT_POLL_WAIT_MS = 1000;
+const DEFAULT_MAX_POLL_OUTPUT_CHARS = 8000;
+class TerminalSessionManager {
+    dispose() {
+        clearInterval(this.cleanupTimer);
+        for (const record of this.sessions.values()){
+            if (record.runtimeTimer) clearTimeout(record.runtimeTimer);
+            if ("running" === record.status) this.safeKill(record.process, "SIGKILL");
+            record.emitter.removeAllListeners();
+        }
+        this.sessions.clear();
+        this.ownerIndex.clear();
+    }
+    startSession(input) {
+        const ownerId = this.normalizeOwnerId(input.ownerId);
+        const existing = this.ownerIndex.get(ownerId);
+        if ((existing?.size || 0) >= this.maxSessionsPerOwner) throw new Error(`Owner "${ownerId}" reached terminal session limit (${this.maxSessionsPerOwner})`);
+        const runtimeLimitMs = Math.max(1000, input.runtimeLimitMs ?? this.maxRuntimeMs);
+        const process = (0, external_node_child_process_namespaceObject.spawn)(input.command, [], {
+            cwd: input.cwd,
+            env: input.env,
+            shell: true,
+            stdio: [
+                "pipe",
+                "pipe",
+                "pipe"
+            ],
+            windowsHide: true
+        });
+        const now = Date.now();
+        const sessionId = (0, external_node_crypto_namespaceObject.randomUUID)();
+        const record = {
+            sessionId,
+            ownerId,
+            command: input.command,
+            cwd: input.cwd,
+            process,
+            status: "running",
+            startedAt: now,
+            updatedAt: now,
+            output: "",
+            cursor: 0,
+            droppedChars: 0,
+            killRequested: false,
+            runtimeLimitMs,
+            runtimeTimer: null,
+            emitter: new external_node_events_namespaceObject.EventEmitter()
+        };
+        record.runtimeTimer = setTimeout(()=>{
+            if ("running" !== record.status) return;
+            record.status = "timed_out";
+            record.killRequested = true;
+            this.appendOutput(record, `\n[terminal] Session timed out after ${Math.floor(runtimeLimitMs / 1000)}s\n`);
+            this.safeKill(record.process, "SIGTERM");
+            setTimeout(()=>{
+                if ("running" === record.status || !record.finishedAt) this.safeKill(record.process, "SIGKILL");
+            }, this.terminationGraceMs).unref?.();
+        }, runtimeLimitMs);
+        record.runtimeTimer.unref?.();
+        process.stdout?.on("data", (chunk)=>{
+            this.appendOutput(record, chunk.toString());
+        });
+        process.stderr?.on("data", (chunk)=>{
+            this.appendOutput(record, chunk.toString());
+        });
+        process.on("error", (error)=>{
+            if ("running" === record.status) record.status = "error";
+            this.appendOutput(record, `\n[terminal:error] ${error.message}\n`);
+            this.finalizeRecord(record, null, null);
+        });
+        process.on("exit", (code, signal)=>{
+            if ("running" === record.status) if (record.killRequested || signal) record.status = "killed";
+            else if ("number" == typeof code && 0 !== code) record.status = "error";
+            else record.status = "completed";
+            this.finalizeRecord(record, code, signal);
+        });
+        this.sessions.set(sessionId, record);
+        if (existing) existing.add(sessionId);
+        else this.ownerIndex.set(ownerId, new Set([
+            sessionId
+        ]));
+        return this.toSnapshot(record);
+    }
+    async pollSession(input) {
+        const record = this.getOwnedRecord(input.ownerId, input.sessionId);
+        const waitMs = Math.max(0, input.waitMs ?? DEFAULT_POLL_WAIT_MS);
+        const maxOutputChars = Math.max(1, input.maxOutputChars ?? DEFAULT_MAX_POLL_OUTPUT_CHARS);
+        if (waitMs > 0 && "running" === record.status && record.cursor >= record.output.length) await this.waitForUpdate(record, waitMs);
+        const available = Math.max(0, record.output.length - record.cursor);
+        const readChars = Math.min(maxOutputChars, available);
+        const output = readChars > 0 ? record.output.slice(record.cursor, record.cursor + readChars) : "";
+        record.cursor += readChars;
+        return {
+            ...this.toSnapshot(record),
+            output,
+            hasMore: record.cursor < record.output.length
+        };
+    }
+    writeSession(input) {
+        const record = this.getOwnedRecord(input.ownerId, input.sessionId);
+        if ("running" !== record.status) throw new Error(`Terminal session ${record.sessionId} is not running`);
+        if (!record.process.stdin || record.process.stdin.destroyed) throw new Error(`Terminal session ${record.sessionId} has no writable stdin`);
+        record.process.stdin.write(input.chars);
+        record.updatedAt = Date.now();
+        record.emitter.emit("update");
+        return this.toSnapshot(record);
+    }
+    killSession(input) {
+        const record = this.getOwnedRecord(input.ownerId, input.sessionId);
+        if ("running" !== record.status) return this.toSnapshot(record);
+        const signal = input.signal || "SIGTERM";
+        record.killRequested = true;
+        this.safeKill(record.process, signal);
+        if ("SIGKILL" !== signal) setTimeout(()=>{
+            if ("running" === record.status) {
+                record.killRequested = true;
+                this.safeKill(record.process, "SIGKILL");
+            }
+        }, this.terminationGraceMs).unref?.();
+        return this.toSnapshot(record);
+    }
+    listSessions(ownerId) {
+        const normalizedOwnerId = this.normalizeOwnerId(ownerId);
+        const sessionIds = this.ownerIndex.get(normalizedOwnerId);
+        if (!sessionIds || 0 === sessionIds.size) return [];
+        return [
+            ...sessionIds
+        ].map((sessionId)=>this.sessions.get(sessionId)).filter((entry)=>Boolean(entry)).sort((a, b)=>b.startedAt - a.startedAt).map((entry)=>this.toSnapshot(entry));
+    }
+    waitForUpdate(record, waitMs) {
+        return new Promise((resolve)=>{
+            let resolved = false;
+            const onUpdate = ()=>{
+                if (resolved) return;
+                resolved = true;
+                clearTimeout(timer);
+                record.emitter.off("update", onUpdate);
+                resolve();
+            };
+            const timer = setTimeout(()=>{
+                if (resolved) return;
+                resolved = true;
+                record.emitter.off("update", onUpdate);
+                resolve();
+            }, waitMs);
+            timer.unref?.();
+            record.emitter.on("update", onUpdate);
+        });
+    }
+    appendOutput(record, chunk) {
+        if (!chunk) return;
+        record.output += chunk;
+        if (record.output.length > this.maxBufferedCharsPerSession) {
+            const overflow = record.output.length - this.maxBufferedCharsPerSession;
+            record.output = record.output.slice(overflow);
+            record.droppedChars += overflow;
+            record.cursor = Math.max(0, record.cursor - overflow);
+        }
+        record.updatedAt = Date.now();
+        record.emitter.emit("update");
+    }
+    finalizeRecord(record, code, signal) {
+        record.exitCode = code;
+        record.signal = signal;
+        record.finishedAt = Date.now();
+        record.updatedAt = record.finishedAt;
+        if (record.runtimeTimer) {
+            clearTimeout(record.runtimeTimer);
+            record.runtimeTimer = null;
+        }
+        record.emitter.emit("update");
+    }
+    cleanupExpiredSessions() {
+        const now = Date.now();
+        for (const record of this.sessions.values()){
+            if ("running" === record.status) {
+                const idleForMs = now - record.updatedAt;
+                if (idleForMs > this.idleTimeoutMs) {
+                    record.status = "timed_out";
+                    record.killRequested = true;
+                    this.appendOutput(record, `\n[terminal] Session idle timeout after ${Math.floor(this.idleTimeoutMs / 1000)}s\n`);
+                    this.safeKill(record.process, "SIGTERM");
+                    setTimeout(()=>{
+                        if ("running" === record.status) this.safeKill(record.process, "SIGKILL");
+                    }, this.terminationGraceMs).unref?.();
+                }
+                continue;
+            }
+            if (record.finishedAt && now - record.finishedAt > this.completedSessionRetentionMs) this.deleteSession(record.sessionId);
+        }
+    }
+    deleteSession(sessionId) {
+        const record = this.sessions.get(sessionId);
+        if (!record) return;
+        if (record.runtimeTimer) {
+            clearTimeout(record.runtimeTimer);
+            record.runtimeTimer = null;
+        }
+        record.emitter.removeAllListeners();
+        this.sessions.delete(sessionId);
+        const ownerSessions = this.ownerIndex.get(record.ownerId);
+        if (!ownerSessions) return;
+        ownerSessions.delete(sessionId);
+        if (0 === ownerSessions.size) this.ownerIndex.delete(record.ownerId);
+    }
+    getOwnedRecord(ownerId, sessionId) {
+        const normalizedOwnerId = this.normalizeOwnerId(ownerId);
+        const record = this.sessions.get(sessionId);
+        if (!record) throw new Error(`Terminal session ${sessionId} was not found`);
+        if (record.ownerId !== normalizedOwnerId) throw new Error(`Terminal session ${sessionId} is not accessible`);
+        return record;
+    }
+    toSnapshot(record) {
+        return {
+            sessionId: record.sessionId,
+            ownerId: record.ownerId,
+            command: record.command,
+            cwd: record.cwd,
+            status: record.status,
+            startedAt: record.startedAt,
+            updatedAt: record.updatedAt,
+            finishedAt: record.finishedAt,
+            exitCode: record.exitCode,
+            signal: record.signal,
+            droppedChars: record.droppedChars
+        };
+    }
+    normalizeOwnerId(ownerId) {
+        const trimmed = ownerId.trim();
+        if (!trimmed) throw new Error("Terminal ownerId is required");
+        return trimmed;
+    }
+    safeKill(process, signal) {
+        try {
+            process.kill(signal);
+        } catch  {}
+    }
+    constructor(options = {}){
+        _define_property(this, "sessions", new Map());
+        _define_property(this, "ownerIndex", new Map());
+        _define_property(this, "cleanupTimer", void 0);
+        _define_property(this, "maxSessionsPerOwner", void 0);
+        _define_property(this, "maxBufferedCharsPerSession", void 0);
+        _define_property(this, "maxRuntimeMs", void 0);
+        _define_property(this, "idleTimeoutMs", void 0);
+        _define_property(this, "completedSessionRetentionMs", void 0);
+        _define_property(this, "terminationGraceMs", void 0);
+        this.maxSessionsPerOwner = options.maxSessionsPerOwner ?? DEFAULT_MAX_SESSIONS_PER_OWNER;
+        this.maxBufferedCharsPerSession = options.maxBufferedCharsPerSession ?? DEFAULT_MAX_BUFFERED_CHARS;
+        this.maxRuntimeMs = options.maxRuntimeMs ?? DEFAULT_MAX_RUNTIME_MS;
+        this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+        this.completedSessionRetentionMs = options.completedSessionRetentionMs ?? DEFAULT_COMPLETED_RETENTION_MS;
+        this.terminationGraceMs = options.terminationGraceMs ?? DEFAULT_TERMINATION_GRACE_MS;
+        this.cleanupTimer = setInterval(()=>{
+            this.cleanupExpiredSessions();
+        }, 60000);
+        this.cleanupTimer.unref?.();
+    }
+}
+let sharedTerminalSessionManager = null;
+const getSharedTerminalSessionManager = ()=>{
+    if (!sharedTerminalSessionManager) sharedTerminalSessionManager = new TerminalSessionManager();
+    return sharedTerminalSessionManager;
+};
+exports.TerminalSessionManager = __webpack_exports__.TerminalSessionManager;
+exports.getSharedTerminalSessionManager = __webpack_exports__.getSharedTerminalSessionManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TerminalSessionManager",
+    "getSharedTerminalSessionManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/tools/terminal_session_manager.d.ts

@@ -0,0 +1,77 @@
+export type TerminalSessionStatus = "running" | "completed" | "error" | "killed" | "timed_out";
+export interface TerminalSessionSnapshot {
+    sessionId: string;
+    ownerId: string;
+    command: string;
+    cwd: string;
+    status: TerminalSessionStatus;
+    startedAt: number;
+    updatedAt: number;
+    finishedAt?: number;
+    exitCode?: number | null;
+    signal?: NodeJS.Signals | null;
+    droppedChars: number;
+}
+export interface TerminalPollResult extends TerminalSessionSnapshot {
+    output: string;
+    hasMore: boolean;
+}
+export interface TerminalSessionManagerOptions {
+    maxSessionsPerOwner?: number;
+    maxBufferedCharsPerSession?: number;
+    maxRuntimeMs?: number;
+    idleTimeoutMs?: number;
+    completedSessionRetentionMs?: number;
+    terminationGraceMs?: number;
+}
+export interface StartTerminalSessionInput {
+    ownerId: string;
+    command: string;
+    cwd: string;
+    env: Record<string, string>;
+    runtimeLimitMs?: number;
+}
+export interface PollTerminalSessionInput {
+    ownerId: string;
+    sessionId: string;
+    waitMs?: number;
+    maxOutputChars?: number;
+}
+export interface WriteTerminalSessionInput {
+    ownerId: string;
+    sessionId: string;
+    chars: string;
+}
+export interface KillTerminalSessionInput {
+    ownerId: string;
+    sessionId: string;
+    signal?: NodeJS.Signals;
+}
+export declare class TerminalSessionManager {
+    private readonly sessions;
+    private readonly ownerIndex;
+    private readonly cleanupTimer;
+    private readonly maxSessionsPerOwner;
+    private readonly maxBufferedCharsPerSession;
+    private readonly maxRuntimeMs;
+    private readonly idleTimeoutMs;
+    private readonly completedSessionRetentionMs;
+    private readonly terminationGraceMs;
+    constructor(options?: TerminalSessionManagerOptions);
+    dispose(): void;
+    startSession(input: StartTerminalSessionInput): TerminalSessionSnapshot;
+    pollSession(input: PollTerminalSessionInput): Promise<TerminalPollResult>;
+    writeSession(input: WriteTerminalSessionInput): TerminalSessionSnapshot;
+    killSession(input: KillTerminalSessionInput): TerminalSessionSnapshot;
+    listSessions(ownerId: string): TerminalSessionSnapshot[];
+    private waitForUpdate;
+    private appendOutput;
+    private finalizeRecord;
+    private cleanupExpiredSessions;
+    private deleteSession;
+    private getOwnedRecord;
+    private toSnapshot;
+    private normalizeOwnerId;
+    private safeKill;
+}
+export declare const getSharedTerminalSessionManager: () => TerminalSessionManager;

package/dist/agent/tools/terminal_session_manager.js

@@ -0,0 +1,284 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_MAX_SESSIONS_PER_OWNER = 4;
+const DEFAULT_MAX_BUFFERED_CHARS = 256000;
+const DEFAULT_MAX_RUNTIME_MS = 1800000;
+const DEFAULT_IDLE_TIMEOUT_MS = 900000;
+const DEFAULT_COMPLETED_RETENTION_MS = 900000;
+const DEFAULT_TERMINATION_GRACE_MS = 2000;
+const DEFAULT_POLL_WAIT_MS = 1000;
+const DEFAULT_MAX_POLL_OUTPUT_CHARS = 8000;
+class TerminalSessionManager {
+    dispose() {
+        clearInterval(this.cleanupTimer);
+        for (const record of this.sessions.values()){
+            if (record.runtimeTimer) clearTimeout(record.runtimeTimer);
+            if ("running" === record.status) this.safeKill(record.process, "SIGKILL");
+            record.emitter.removeAllListeners();
+        }
+        this.sessions.clear();
+        this.ownerIndex.clear();
+    }
+    startSession(input) {
+        const ownerId = this.normalizeOwnerId(input.ownerId);
+        const existing = this.ownerIndex.get(ownerId);
+        if ((existing?.size || 0) >= this.maxSessionsPerOwner) throw new Error(`Owner "${ownerId}" reached terminal session limit (${this.maxSessionsPerOwner})`);
+        const runtimeLimitMs = Math.max(1000, input.runtimeLimitMs ?? this.maxRuntimeMs);
+        const process = spawn(input.command, [], {
+            cwd: input.cwd,
+            env: input.env,
+            shell: true,
+            stdio: [
+                "pipe",
+                "pipe",
+                "pipe"
+            ],
+            windowsHide: true
+        });
+        const now = Date.now();
+        const sessionId = randomUUID();
+        const record = {
+            sessionId,
+            ownerId,
+            command: input.command,
+            cwd: input.cwd,
+            process,
+            status: "running",
+            startedAt: now,
+            updatedAt: now,
+            output: "",
+            cursor: 0,
+            droppedChars: 0,
+            killRequested: false,
+            runtimeLimitMs,
+            runtimeTimer: null,
+            emitter: new EventEmitter()
+        };
+        record.runtimeTimer = setTimeout(()=>{
+            if ("running" !== record.status) return;
+            record.status = "timed_out";
+            record.killRequested = true;
+            this.appendOutput(record, `\n[terminal] Session timed out after ${Math.floor(runtimeLimitMs / 1000)}s\n`);
+            this.safeKill(record.process, "SIGTERM");
+            setTimeout(()=>{
+                if ("running" === record.status || !record.finishedAt) this.safeKill(record.process, "SIGKILL");
+            }, this.terminationGraceMs).unref?.();
+        }, runtimeLimitMs);
+        record.runtimeTimer.unref?.();
+        process.stdout?.on("data", (chunk)=>{
+            this.appendOutput(record, chunk.toString());
+        });
+        process.stderr?.on("data", (chunk)=>{
+            this.appendOutput(record, chunk.toString());
+        });
+        process.on("error", (error)=>{
+            if ("running" === record.status) record.status = "error";
+            this.appendOutput(record, `\n[terminal:error] ${error.message}\n`);
+            this.finalizeRecord(record, null, null);
+        });
+        process.on("exit", (code, signal)=>{
+            if ("running" === record.status) if (record.killRequested || signal) record.status = "killed";
+            else if ("number" == typeof code && 0 !== code) record.status = "error";
+            else record.status = "completed";
+            this.finalizeRecord(record, code, signal);
+        });
+        this.sessions.set(sessionId, record);
+        if (existing) existing.add(sessionId);
+        else this.ownerIndex.set(ownerId, new Set([
+            sessionId
+        ]));
+        return this.toSnapshot(record);
+    }
+    async pollSession(input) {
+        const record = this.getOwnedRecord(input.ownerId, input.sessionId);
+        const waitMs = Math.max(0, input.waitMs ?? DEFAULT_POLL_WAIT_MS);
+        const maxOutputChars = Math.max(1, input.maxOutputChars ?? DEFAULT_MAX_POLL_OUTPUT_CHARS);
+        if (waitMs > 0 && "running" === record.status && record.cursor >= record.output.length) await this.waitForUpdate(record, waitMs);
+        const available = Math.max(0, record.output.length - record.cursor);
+        const readChars = Math.min(maxOutputChars, available);
+        const output = readChars > 0 ? record.output.slice(record.cursor, record.cursor + readChars) : "";
+        record.cursor += readChars;
+        return {
+            ...this.toSnapshot(record),
+            output,
+            hasMore: record.cursor < record.output.length
+        };
+    }
+    writeSession(input) {
+        const record = this.getOwnedRecord(input.ownerId, input.sessionId);
+        if ("running" !== record.status) throw new Error(`Terminal session ${record.sessionId} is not running`);
+        if (!record.process.stdin || record.process.stdin.destroyed) throw new Error(`Terminal session ${record.sessionId} has no writable stdin`);
+        record.process.stdin.write(input.chars);
+        record.updatedAt = Date.now();
+        record.emitter.emit("update");
+        return this.toSnapshot(record);
+    }
+    killSession(input) {
+        const record = this.getOwnedRecord(input.ownerId, input.sessionId);
+        if ("running" !== record.status) return this.toSnapshot(record);
+        const signal = input.signal || "SIGTERM";
+        record.killRequested = true;
+        this.safeKill(record.process, signal);
+        if ("SIGKILL" !== signal) setTimeout(()=>{
+            if ("running" === record.status) {
+                record.killRequested = true;
+                this.safeKill(record.process, "SIGKILL");
+            }
+        }, this.terminationGraceMs).unref?.();
+        return this.toSnapshot(record);
+    }
+    listSessions(ownerId) {
+        const normalizedOwnerId = this.normalizeOwnerId(ownerId);
+        const sessionIds = this.ownerIndex.get(normalizedOwnerId);
+        if (!sessionIds || 0 === sessionIds.size) return [];
+        return [
+            ...sessionIds
+        ].map((sessionId)=>this.sessions.get(sessionId)).filter((entry)=>Boolean(entry)).sort((a, b)=>b.startedAt - a.startedAt).map((entry)=>this.toSnapshot(entry));
+    }
+    waitForUpdate(record, waitMs) {
+        return new Promise((resolve)=>{
+            let resolved = false;
+            const onUpdate = ()=>{
+                if (resolved) return;
+                resolved = true;
+                clearTimeout(timer);
+                record.emitter.off("update", onUpdate);
+                resolve();
+            };
+            const timer = setTimeout(()=>{
+                if (resolved) return;
+                resolved = true;
+                record.emitter.off("update", onUpdate);
+                resolve();
+            }, waitMs);
+            timer.unref?.();
+            record.emitter.on("update", onUpdate);
+        });
+    }
+    appendOutput(record, chunk) {
+        if (!chunk) return;
+        record.output += chunk;
+        if (record.output.length > this.maxBufferedCharsPerSession) {
+            const overflow = record.output.length - this.maxBufferedCharsPerSession;
+            record.output = record.output.slice(overflow);
+            record.droppedChars += overflow;
+            record.cursor = Math.max(0, record.cursor - overflow);
+        }
+        record.updatedAt = Date.now();
+        record.emitter.emit("update");
+    }
+    finalizeRecord(record, code, signal) {
+        record.exitCode = code;
+        record.signal = signal;
+        record.finishedAt = Date.now();
+        record.updatedAt = record.finishedAt;
+        if (record.runtimeTimer) {
+            clearTimeout(record.runtimeTimer);
+            record.runtimeTimer = null;
+        }
+        record.emitter.emit("update");
+    }
+    cleanupExpiredSessions() {
+        const now = Date.now();
+        for (const record of this.sessions.values()){
+            if ("running" === record.status) {
+                const idleForMs = now - record.updatedAt;
+                if (idleForMs > this.idleTimeoutMs) {
+                    record.status = "timed_out";
+                    record.killRequested = true;
+                    this.appendOutput(record, `\n[terminal] Session idle timeout after ${Math.floor(this.idleTimeoutMs / 1000)}s\n`);
+                    this.safeKill(record.process, "SIGTERM");
+                    setTimeout(()=>{
+                        if ("running" === record.status) this.safeKill(record.process, "SIGKILL");
+                    }, this.terminationGraceMs).unref?.();
+                }
+                continue;
+            }
+            if (record.finishedAt && now - record.finishedAt > this.completedSessionRetentionMs) this.deleteSession(record.sessionId);
+        }
+    }
+    deleteSession(sessionId) {
+        const record = this.sessions.get(sessionId);
+        if (!record) return;
+        if (record.runtimeTimer) {
+            clearTimeout(record.runtimeTimer);
+            record.runtimeTimer = null;
+        }
+        record.emitter.removeAllListeners();
+        this.sessions.delete(sessionId);
+        const ownerSessions = this.ownerIndex.get(record.ownerId);
+        if (!ownerSessions) return;
+        ownerSessions.delete(sessionId);
+        if (0 === ownerSessions.size) this.ownerIndex.delete(record.ownerId);
+    }
+    getOwnedRecord(ownerId, sessionId) {
+        const normalizedOwnerId = this.normalizeOwnerId(ownerId);
+        const record = this.sessions.get(sessionId);
+        if (!record) throw new Error(`Terminal session ${sessionId} was not found`);
+        if (record.ownerId !== normalizedOwnerId) throw new Error(`Terminal session ${sessionId} is not accessible`);
+        return record;
+    }
+    toSnapshot(record) {
+        return {
+            sessionId: record.sessionId,
+            ownerId: record.ownerId,
+            command: record.command,
+            cwd: record.cwd,
+            status: record.status,
+            startedAt: record.startedAt,
+            updatedAt: record.updatedAt,
+            finishedAt: record.finishedAt,
+            exitCode: record.exitCode,
+            signal: record.signal,
+            droppedChars: record.droppedChars
+        };
+    }
+    normalizeOwnerId(ownerId) {
+        const trimmed = ownerId.trim();
+        if (!trimmed) throw new Error("Terminal ownerId is required");
+        return trimmed;
+    }
+    safeKill(process, signal) {
+        try {
+            process.kill(signal);
+        } catch  {}
+    }
+    constructor(options = {}){
+        _define_property(this, "sessions", new Map());
+        _define_property(this, "ownerIndex", new Map());
+        _define_property(this, "cleanupTimer", void 0);
+        _define_property(this, "maxSessionsPerOwner", void 0);
+        _define_property(this, "maxBufferedCharsPerSession", void 0);
+        _define_property(this, "maxRuntimeMs", void 0);
+        _define_property(this, "idleTimeoutMs", void 0);
+        _define_property(this, "completedSessionRetentionMs", void 0);
+        _define_property(this, "terminationGraceMs", void 0);
+        this.maxSessionsPerOwner = options.maxSessionsPerOwner ?? DEFAULT_MAX_SESSIONS_PER_OWNER;
+        this.maxBufferedCharsPerSession = options.maxBufferedCharsPerSession ?? DEFAULT_MAX_BUFFERED_CHARS;
+        this.maxRuntimeMs = options.maxRuntimeMs ?? DEFAULT_MAX_RUNTIME_MS;
+        this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+        this.completedSessionRetentionMs = options.completedSessionRetentionMs ?? DEFAULT_COMPLETED_RETENTION_MS;
+        this.terminationGraceMs = options.terminationGraceMs ?? DEFAULT_TERMINATION_GRACE_MS;
+        this.cleanupTimer = setInterval(()=>{
+            this.cleanupExpiredSessions();
+        }, 60000);
+        this.cleanupTimer.unref?.();
+    }
+}
+let sharedTerminalSessionManager = null;
+const getSharedTerminalSessionManager = ()=>{
+    if (!sharedTerminalSessionManager) sharedTerminalSessionManager = new TerminalSessionManager();
+    return sharedTerminalSessionManager;
+};
+export { TerminalSessionManager, getSharedTerminalSessionManager };