@jack200714/mafw 4.5.1

package/gateway/dist/python/kernel-service.js

@@ -0,0 +1,762 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionKernels = exports.KernelManager = exports.KernelBusyAfterInterruptError = void 0;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const zeromq_1 = require("zeromq");
+const logger_1 = require("../core/utils/logger");
+const DELIM = Buffer.from('<IDS|MSG>');
+const PROTOCOL_VERSION = '5.3';
+const DEFAULT_MAX_OUTPUT_CHARS = 65536;
+const DEFAULT_TIMEOUT_MS = 120_000;
+const PORTS_RESOLVE_TIMEOUT_MS = 5000;
+const READY_TIMEOUT_MS = 5000;
+const ABORT_GRACE_MS = 1000;
+const KERNEL_BUSY_AFTER_INTERRUPT_MS = 5000;
+const CONNECTION_PORT_KEYS = ['shell_port', 'iopub_port', 'stdin_port', 'control_port', 'hb_port'];
+function textOf(data) {
+    return typeof data?.['text/plain'] === 'string' ? data['text/plain'] : undefined;
+}
+/**
+ * Serialize a value the way Python's json.dumps does (separators ", " / ": ",
+ * ensure_ascii=False) so Jupyter HMAC signatures match the ipykernel side.
+ */
+function pyJsonStringify(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string')
+        return pyJsonString(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value))
+        return '[' + value.map(pyJsonStringify).join(', ') + ']';
+    const obj = value;
+    const entries = Object.keys(obj).map((k) => pyJsonString(k) + ': ' + pyJsonStringify(obj[k]));
+    return '{' + entries.join(', ') + '}';
+}
+function pyJsonString(value) {
+    let out = '"';
+    for (const ch of value) {
+        const code = ch.codePointAt(0);
+        if (ch === '"')
+            out += '\\"';
+        else if (ch === '\\')
+            out += '\\\\';
+        else if (ch === '\n')
+            out += '\\n';
+        else if (ch === '\r')
+            out += '\\r';
+        else if (ch === '\t')
+            out += '\\t';
+        else if (ch === '\b')
+            out += '\\b';
+        else if (ch === '\f')
+            out += '\\f';
+        else if (code < 0x20)
+            out += '\\u' + code.toString(16).padStart(4, '0');
+        else
+            out += ch;
+    }
+    return out + '"';
+}
+function makeConnection() {
+    const info = {
+        ip: '127.0.0.1',
+        transport: 'tcp',
+        shell_port: 0,
+        iopub_port: 0,
+        stdin_port: 0,
+        control_port: 0,
+        hb_port: 0,
+        signature_scheme: 'hmac-sha256',
+        key: (0, crypto_1.randomBytes)(16).toString('hex'),
+        kernel_name: 'python3',
+    };
+    const tempDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'mafw-pykernel-'));
+    const path = (0, path_1.join)(tempDir, 'connection.json');
+    (0, fs_1.writeFileSync)(path, JSON.stringify(info, null, 2), { mode: 0o600 });
+    return { info, path, tempDir };
+}
+class KernelBusyAfterInterruptError extends Error {
+    constructor() {
+        super('内核仍在运行上一个被中断的单元，请稍后重试或重启内核');
+        this.name = 'KernelBusyAfterInterruptError';
+    }
+}
+exports.KernelBusyAfterInterruptError = KernelBusyAfterInterruptError;
+class KernelManager {
+    pythonBin;
+    username;
+    info;
+    connectionPath;
+    tempDir;
+    shell;
+    control;
+    iopub;
+    kernel;
+    kernelStderr = '';
+    dead = false;
+    started;
+    pending = new Map();
+    queue = [];
+    draining = false;
+    iopubActive = false;
+    shellActive = false;
+    sessionId;
+    restartNotice = false;
+    constructor(sessionId, pythonBin, username = 'mafw') {
+        this.pythonBin = pythonBin;
+        this.username = username;
+        this.sessionId = sessionId;
+        const c = makeConnection();
+        this.info = c.info;
+        this.connectionPath = c.path;
+        this.tempDir = c.tempDir;
+    }
+    /** Lazily start the kernel; concurrent callers share the same startup. */
+    ensureStarted() {
+        if (!this.started)
+            this.started = this.start();
+        return this.started;
+    }
+    async start() {
+        if (this.kernel && !this.dead)
+            return;
+        // Fresh connection file per start: dead kernels may still hold old ports.
+        try {
+            (0, fs_1.rmSync)(this.tempDir, { recursive: true, force: true });
+        }
+        catch {
+            /* ignore */
+        }
+        const c = makeConnection();
+        this.info = c.info;
+        this.connectionPath = c.path;
+        this.tempDir = c.tempDir;
+        this.kernelStderr = '';
+        this.dead = false;
+        this.kernelInfoReceived = false;
+        this.kernel = (0, child_process_1.spawn)(this.pythonBin, ['-m', 'ipykernel_launcher', '-f', this.connectionPath], {
+            // stdout is unused (kernel output arrives over iopub); stderr carries
+            // startup diagnostics. Ignoring stdout avoids a dangling pipe handle.
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        this.kernel.stderr?.on('data', (buf) => {
+            this.kernelStderr += buf.toString();
+        });
+        this.kernel.on('exit', (code, signal) => {
+            if (!this.dead) {
+                this.dead = true;
+                this.restartNotice = true;
+                logger_1.log.warn(`[PyKernel] session ${this.sessionId} kernel exited code=${code} signal=${signal} stderr=${this.kernelStderr.slice(0, 400)}`);
+                this.closeSockets();
+                this.failPending(new Error('内核进程已退出'));
+                this.started = undefined;
+            }
+        });
+        this.kernel.on('error', (err) => {
+            this.dead = true;
+            this.started = undefined;
+            logger_1.log.error(`[PyKernel] spawn error: ${err.message}`);
+        });
+        // The kernel rewrites the connection file with the actual ports.
+        await this.waitForPorts();
+        await this.connectSockets();
+        await this.handshake();
+        logger_1.log.info(`[PyKernel] session ${this.sessionId} kernel ready`);
+    }
+    async waitForPorts() {
+        const deadline = Date.now() + PORTS_RESOLVE_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            try {
+                const raw = await import('fs').then((fs) => fs.promises.readFile(this.connectionPath, 'utf8'));
+                const info = JSON.parse(raw);
+                if (CONNECTION_PORT_KEYS.every((k) => Number.isInteger(info[k]) && info[k] > 0)) {
+                    this.info = info;
+                    return;
+                }
+            }
+            catch {
+                /* file may be mid-write */
+            }
+            await sleep(50);
+        }
+        throw new Error('内核端口解析超时');
+    }
+    async connectSockets() {
+        this.shell = new zeromq_1.Dealer();
+        await this.shell.connect(`tcp://${this.info.ip}:${this.info.shell_port}`);
+        this.shell.unref?.(); // never keep the process alive (tests / daemon exit)
+        this.control = new zeromq_1.Dealer();
+        await this.control.connect(`tcp://${this.info.ip}:${this.info.control_port}`);
+        this.control.unref?.();
+        this.iopub = new zeromq_1.Subscriber();
+        await this.iopub.connect(`tcp://${this.info.ip}:${this.info.iopub_port}`);
+        this.iopub.subscribe();
+        this.iopub.unref?.();
+        this.iopubActive = true;
+        this.shellActive = true;
+        void this.readIopubLoop();
+        void this.readShellLoop();
+    }
+    async handshake() {
+        await this.shellExecute('kernel_info_request', {});
+        const deadline = Date.now() + READY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            await sleep(20);
+            if (this.kernelInfoReceived)
+                return;
+        }
+        throw new Error('内核握手超时');
+    }
+    async shellExecute(msgType, content) {
+        if (!this.shell)
+            throw new Error('shell 未连接');
+        const msg = this.buildMessage(msgType, content);
+        await this.shell.send(this.encode(msg));
+        // handshake readiness is observed on iopub; tracked via kernel_info_reply
+        return { ready: this.kernelInfoReceived };
+    }
+    kernelInfoReceived = false;
+    buildMessage(msgType, content) {
+        return {
+            header: {
+                // Key order must match jupyter_client.msg_header: msg_id, msg_type,
+                // username, session, date, version — JSON key order is part of the HMAC.
+                msg_id: (0, crypto_1.randomBytes)(16).toString('hex'),
+                msg_type: msgType,
+                username: this.username,
+                session: this.sessionId,
+                date: new Date().toISOString(),
+                version: PROTOCOL_VERSION,
+            },
+            parent_header: {},
+            metadata: {},
+            content,
+        };
+    }
+    encode(msg) {
+        const frames = [];
+        frames.push(DELIM);
+        const sig = this.sign([msg.header, msg.parent_header, msg.metadata, msg.content]);
+        // The signature frame is the hex digest encoded as UTF-8 bytes
+        // (jupyter_client: h.hexdigest().encode()).
+        frames.push(Buffer.from(sig));
+        for (const part of [msg.header, msg.parent_header, msg.metadata, msg.content]) {
+            frames.push(Buffer.from(pyJsonStringify(part)));
+        }
+        return frames;
+    }
+    sign(parts) {
+        const hmac = (0, crypto_1.createHmac)('sha256', this.info.key);
+        for (const p of parts)
+            hmac.update(pyJsonStringify(p));
+        return hmac.digest('hex');
+    }
+    decode(frames) {
+        const delimIdx = frames.findIndex((f) => f.equals(DELIM));
+        if (delimIdx < 0 || frames.length < delimIdx + 6)
+            return null;
+        try {
+            return {
+                header: JSON.parse(frames[delimIdx + 2].toString()),
+                parentHeader: JSON.parse(frames[delimIdx + 3].toString()),
+                metadata: JSON.parse(frames[delimIdx + 4].toString()),
+                content: JSON.parse(frames[delimIdx + 5].toString()),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async readIopubLoop() {
+        const socket = this.iopub;
+        if (!socket)
+            return;
+        let failures = 0;
+        let recvPromise = null;
+        while (socket === this.iopub && this.iopubActive) {
+            try {
+                if (!recvPromise)
+                    recvPromise = socket.receive().finally(() => { recvPromise = null; });
+                const pollMs = this.pending.size > 0 ? 2000 : 10000;
+                const frames = await Promise.race([recvPromise, sleep(pollMs).then(() => 'timeout')]);
+                failures = 0;
+                if (frames === 'timeout') {
+                    // No message during the poll window. Only treat as dead while
+                    // executions are outstanding; the receive promise stays pending
+                    // (no "ghost receive" that would swallow later messages).
+                    failures = this.pending.size > 0 ? failures + 1 : 0;
+                    if (failures >= 3) {
+                        this.markKernelDead('iopub 通道无响应');
+                        return;
+                    }
+                    continue;
+                }
+                const topic = frames[0]?.toString() || '';
+                const msg = this.decode(frames);
+                if (msg)
+                    this.handleIopubMessage(topic, msg);
+            }
+            catch (err) {
+                if (!this.iopubActive || socket !== this.iopub)
+                    return; // closing or replaced
+                failures++;
+                if (failures >= 3 || socket.closed) {
+                    this.markKernelDead('iopub 通道无响应');
+                    return;
+                }
+            }
+        }
+    }
+    async readShellLoop() {
+        const socket = this.shell;
+        if (!socket)
+            return;
+        let failures = 0;
+        let recvPromise = null;
+        while (socket === this.shell && this.shellActive) {
+            try {
+                if (!recvPromise)
+                    recvPromise = socket.receive().finally(() => { recvPromise = null; });
+                const pollMs = this.pending.size > 0 ? 2000 : 10000;
+                const frames = await Promise.race([recvPromise, sleep(pollMs).then(() => 'timeout')]);
+                failures = 0;
+                if (frames === 'timeout') {
+                    failures = this.pending.size > 0 ? failures + 1 : 0;
+                    if (failures >= 3) {
+                        this.markKernelDead('shell 通道无响应');
+                        return;
+                    }
+                    continue;
+                }
+                const msg = this.decode(frames);
+                if (!msg)
+                    continue;
+                const type = msg.header?.msg_type;
+                if (type === 'kernel_info_reply') {
+                    this.kernelInfoReceived = true;
+                    continue;
+                }
+                if (type === 'execute_reply') {
+                    const parentId = msg.parentHeader?.msg_id;
+                    const pending = this.pending.get(parentId);
+                    if (!pending)
+                        continue;
+                    const c = msg.content || {};
+                    if (c.status === 'error' && !pending.error) {
+                        pending.error = {
+                            ename: c.ename || 'Error',
+                            evalue: c.evalue || '',
+                            traceback: Array.isArray(c.traceback) ? c.traceback.map(String) : [],
+                        };
+                    }
+                    if (c.status === 'aborted' && !pending.settled) {
+                        // 内核侧中止（interrupt 后）——显式收尾，等待 iopub idle 的兜底由超时覆盖
+                        pending.settled = true;
+                        this.pending.delete(parentId);
+                        pending.resolve({
+                            stdout: pending.stdout,
+                            stderr: pending.stderr,
+                            result: pending.result,
+                            error: pending.error,
+                            status: 'aborted',
+                            durationMs: Date.now() - pending.startedAt,
+                            truncated: pending.truncated,
+                            attachments: pending.attachments,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                if (!this.shellActive || socket !== this.shell)
+                    return; // closing or replaced
+                failures++;
+                if (failures >= 3 || socket.closed) {
+                    this.markKernelDead('shell 通道无响应');
+                    return;
+                }
+            }
+        }
+    }
+    /** Kill the kernel process and clear state so the next execute() restarts it. */
+    markKernelDead(reason) {
+        if (this.dead)
+            return;
+        this.dead = true;
+        this.restartNotice = true;
+        logger_1.log.warn(`[PyKernel] session ${this.sessionId} kernel dead: ${reason}`);
+        this.failPending(new Error(`内核通道故障：${reason}`));
+        this.started = undefined;
+        const proc = this.kernel;
+        this.kernel = undefined;
+        if (proc) {
+            proc.kill('SIGKILL');
+            if (process.platform === 'win32' && proc.pid) {
+                const killer = (0, child_process_1.spawn)('taskkill', ['/F', '/T', '/PID', String(proc.pid)], {
+                    stdio: 'ignore',
+                    windowsHide: true,
+                });
+                killer.unref?.();
+            }
+            proc.on('exit', () => undefined);
+        }
+    }
+    handleIopubMessage(topic, msg) {
+        if (msg.header?.msg_type === 'kernel_info_reply') {
+            this.kernelInfoReceived = true;
+            return;
+        }
+        const parentId = msg.parentHeader?.msg_id;
+        if (!parentId)
+            return;
+        const pending = this.pending.get(parentId);
+        if (!pending)
+            return;
+        const c = msg.content || {};
+        switch (msg.header?.msg_type) {
+            case 'stream':
+                if (c.name === 'stderr')
+                    this.appendStream(pending, 'stderr', c.text ?? '');
+                else
+                    this.appendStream(pending, 'stdout', c.text ?? '');
+                break;
+            case 'execute_result':
+                pending.result = textOf(c.data) ?? pending.result;
+                break;
+            case 'display_data':
+                this.handleDisplayData(pending, c);
+                break;
+            case 'error':
+                pending.error = { ename: c.ename || 'Error', evalue: c.evalue || '', traceback: Array.isArray(c.traceback) ? c.traceback.map(String) : [] };
+                break;
+            case 'status':
+                if (c.execution_state === 'idle')
+                    this.settle(pending);
+                break;
+            default:
+                break;
+        }
+    }
+    appendStream(pending, name, text) {
+        const max = pending.maxChars;
+        const field = name;
+        if (!pending[field])
+            pending[field] = '';
+        if (pending[field].length >= max) {
+            pending.truncated = true;
+            return;
+        }
+        const remaining = max - pending[field].length;
+        pending[field] += text.slice(0, remaining);
+        if (text.length > remaining)
+            pending.truncated = true;
+    }
+    handleDisplayData(pending, content) {
+        const data = content.data || {};
+        if (typeof data['text/plain'] === 'string') {
+            pending.result = data['text/plain'];
+        }
+        if (typeof data['image/png'] === 'string') {
+            pending.attachments.push({ mimeType: 'image/png', data: data['image/png'] });
+        }
+        else if (typeof data['image/jpeg'] === 'string') {
+            pending.attachments.push({ mimeType: 'image/jpeg', data: data['image/jpeg'] });
+        }
+    }
+    settle(pending) {
+        if (pending.settled)
+            return;
+        pending.settled = true;
+        this.pending.delete(pending.msgId);
+        const elapsed = Date.now() - pending.startedAt;
+        const result = {
+            stdout: pending.stdout ?? '',
+            stderr: pending.stderr ?? '',
+            result: pending.result,
+            error: pending.error,
+            status: pending.error ? 'error' : 'ok',
+            durationMs: elapsed,
+            truncated: pending.truncated || false,
+            attachments: pending.attachments,
+            kernelRestarted: pending.kernelRestarted,
+        };
+        pending.resolve(result);
+    }
+    failPending(err) {
+        for (const [id, p] of this.pending) {
+            if (p.settled)
+                continue;
+            p.settled = true;
+            this.pending.delete(id);
+            p.reject(err);
+        }
+    }
+    /** Serialized execution: the kernel is single-threaded. */
+    execute(code, opts = {}) {
+        return this.enqueue(() => this.executeInner(code, opts));
+    }
+    async executeInner(code, opts) {
+        const started = Date.now();
+        const maxChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+        const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const kernelRestarted = this.restartNotice;
+        this.restartNotice = false;
+        logger_1.log.info(`[PyKernel] read restartNotice=${kernelRestarted} for: ${code.slice(0, 40)}`);
+        await this.ensureStarted();
+        const pending = {
+            msgId: '',
+            resolve: () => undefined,
+            reject: () => undefined,
+            settled: false,
+            startedAt: started,
+            stdout: '',
+            stderr: '',
+            truncated: false,
+            attachments: [],
+            maxChars,
+        };
+        const resultPromise = new Promise((resolve, reject) => {
+            pending.resolve = resolve;
+            pending.reject = reject;
+        });
+        const msg = this.buildMessage('execute_request', {
+            code,
+            silent: false,
+            store_history: true,
+            user_expressions: {},
+            allow_stdin: false,
+            stop_on_error: true,
+        });
+        pending.msgId = msg.header.msg_id;
+        this.pending.set(pending.msgId, pending);
+        let abortTimer;
+        const clearAbortTimer = () => {
+            if (abortTimer) {
+                clearTimeout(abortTimer);
+                abortTimer = undefined;
+            }
+        };
+        const forceAbort = () => {
+            if (pending.settled)
+                return;
+            pending.settled = true;
+            this.pending.delete(pending.msgId);
+            logger_1.log.warn(`[PyKernel] execute force-abort (timeout) for ${pending.msgId}`);
+            pending.reject(new Error('执行超时（已中断内核）'));
+        };
+        const onAbort = () => {
+            void this.interrupt().catch(() => undefined);
+            clearAbortTimer();
+            abortTimer = setTimeout(forceAbort, ABORT_GRACE_MS);
+            if (typeof abortTimer === 'object' && 'unref' in abortTimer)
+                abortTimer.unref();
+        };
+        try {
+            if (opts.signal?.aborted) {
+                return { stdout: '', stderr: '', status: 'aborted', durationMs: Date.now() - started, truncated: false, attachments: [] };
+            }
+            opts.signal?.addEventListener('abort', onAbort, { once: true });
+            abortTimer = setTimeout(forceAbort, timeoutMs);
+            if (typeof abortTimer === 'object' && 'unref' in abortTimer)
+                abortTimer.unref();
+            logger_1.log.info(`[PyKernel] sending execute, pending=${this.pending.size}`);
+            await this.shell.send(this.encode(msg));
+            logger_1.log.info(`[PyKernel] execute started: ${code.slice(0, 60).replace(/\n/g, ' ')}`);
+            const result = await resultPromise;
+            logger_1.log.info(`[PyKernel] execute done: status=${result.status} dur=${Date.now() - started}ms`);
+            if (kernelRestarted)
+                result.kernelRestarted = true;
+            if (result.status === 'ok' && result.error)
+                result.status = 'error';
+            return result;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message === '执行超时（已中断内核）') {
+                // Wait briefly to see whether the kernel drains back to idle.
+                await sleep(Math.min(KERNEL_BUSY_AFTER_INTERRUPT_MS, 1000));
+                throw new KernelBusyAfterInterruptError();
+            }
+            throw err;
+        }
+        finally {
+            clearAbortTimer();
+            opts.signal?.removeEventListener('abort', onAbort);
+            if (!pending.settled) {
+                pending.settled = true;
+                this.pending.delete(pending.msgId);
+            }
+        }
+    }
+    async interrupt() {
+        if (!this.control)
+            return;
+        const msg = this.buildMessage('interrupt_request', {});
+        await this.control.send(this.encode(msg));
+    }
+    async restart() {
+        this.restartNotice = true;
+        this.dead = true;
+        this.failPending(new Error('内核重启中'));
+        this.iopubActive = false;
+        this.shellActive = false;
+        await this.closeSockets().catch(() => undefined);
+        this.killProc();
+        this.started = undefined;
+        await this.ensureStarted();
+    }
+    dispose() {
+        this.dead = true;
+        this.failPending(new Error('内核已关闭'));
+        this.iopubActive = false;
+        this.shellActive = false;
+        void this.closeSockets();
+        this.killProc();
+        this.cleanupTempDir();
+    }
+    /**
+     * Awaitable variant of dispose() for teardown paths that must not leave
+     * zeromq handles behind (tests, daemon shutdown). zeromq sockets hold
+     * native handles until close() resolves, so a fire-and-forget dispose can
+     * keep the process alive.
+     */
+    async disposeAsync() {
+        this.dead = true;
+        this.failPending(new Error('内核已关闭'));
+        this.iopubActive = false;
+        this.shellActive = false;
+        await this.closeSockets().catch(() => undefined);
+        this.killProc();
+        this.cleanupTempDir();
+    }
+    killProc() {
+        const proc = this.kernel;
+        this.kernel = undefined;
+        if (proc) {
+            // Windows: child.kill('SIGKILL') claims success but often leaves the
+            // process alive (venv python launcher) — force-kill via taskkill.
+            // Use spawnSync so the process is dead before the caller continues; a
+            // still-alive child keeps its piped stderr open and blocks process
+            // exit (tests / daemon shutdown).
+            proc.kill('SIGKILL');
+            if (process.platform === 'win32' && proc.pid) {
+                try {
+                    (0, child_process_1.spawnSync)('taskkill', ['/F', '/T', '/PID', String(proc.pid)], {
+                        stdio: 'ignore',
+                        windowsHide: true,
+                    });
+                }
+                catch { /* already dead */ }
+            }
+            proc.on('exit', () => undefined);
+        }
+    }
+    cleanupTempDir() {
+        try {
+            (0, fs_1.rmSync)(this.tempDir, { recursive: true, force: true });
+        }
+        catch {
+            /* OS tmp cleanup */
+        }
+    }
+    closeSockets() {
+        const sockets = [this.shell, this.control, this.iopub].filter(Boolean);
+        this.shell = undefined;
+        this.control = undefined;
+        this.iopub = undefined;
+        return Promise.all(sockets.map((s) => Promise.resolve(s.close()))).then(() => undefined);
+    }
+    enqueue(fn) {
+        return new Promise((resolve, reject) => {
+            this.queue.push(() => fn().then(resolve, reject));
+            void this.drain();
+        });
+    }
+    async drain() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        while (this.queue.length > 0) {
+            const next = this.queue.shift();
+            await next();
+        }
+        this.draining = false;
+    }
+}
+exports.KernelManager = KernelManager;
+// ---------------------------------------------------------------------------
+// Session-scoped kernel pool
+const TTL_MS = 60 * 60 * 1000;
+class SessionKernels {
+    pythonBin;
+    kernels = new Map();
+    cleanupTimer;
+    constructor(pythonBin) {
+        this.pythonBin = pythonBin;
+        this.cleanupTimer = setInterval(() => this.sweep(), 5 * 60 * 1000);
+        if (this.cleanupTimer && typeof this.cleanupTimer === 'object' && 'unref' in this.cleanupTimer)
+            this.cleanupTimer.unref();
+    }
+    get(sessionId) {
+        const entry = this.kernels.get(sessionId);
+        if (entry) {
+            entry.lastUsed = Date.now();
+            return entry.kernel;
+        }
+        const kernel = new KernelManager(sessionId, this.pythonBin);
+        this.kernels.set(sessionId, { kernel, lastUsed: Date.now() });
+        return kernel;
+    }
+    async restart(sessionId) {
+        const entry = this.kernels.get(sessionId);
+        if (!entry)
+            return;
+        entry.lastUsed = Date.now();
+        await entry.kernel.restart();
+    }
+    status(sessionId) {
+        const entry = this.kernels.get(sessionId);
+        return { running: !!entry && !!entry.kernel && !entry.kernel.dead && !!entry.kernel.kernel };
+    }
+    disposeAll() {
+        if (this.cleanupTimer)
+            clearInterval(this.cleanupTimer);
+        for (const { kernel } of this.kernels.values())
+            kernel.dispose();
+        this.kernels.clear();
+    }
+    sweep() {
+        const now = Date.now();
+        for (const [id, entry] of this.kernels) {
+            if (now - entry.lastUsed > TTL_MS) {
+                entry.kernel.dispose();
+                this.kernels.delete(id);
+            }
+        }
+    }
+}
+exports.SessionKernels = SessionKernels;
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/** Receive with a poll window so close() always lets loops exit promptly. */
+async function receiveWithTimeout(socket, ms) {
+    let timer;
+    try {
+        return await Promise.race([
+            socket.receive(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error('receive timeout')), ms);
+                if (typeof timer === 'object' && 'unref' in timer)
+                    timer.unref();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}