@jingyi0605/codingns 0.1.0

package/dist/server/modules/terminal/terminal-service.js

@@ -0,0 +1,794 @@
+import { EventEmitter } from "node:events";
+import path from "node:path";
+import { AppError } from "../../shared/errors/app-error.js";
+import { createId } from "../../shared/utils/id.js";
+import { nowIso } from "../../shared/utils/time.js";
+import { resolveWorkspaceCwd } from "./terminal-paths.js";
+import { getDefaultShell, resolveRequestedShell } from "./terminal-shell.js";
+import { captureTmuxPaneContent } from "./runtime/adapters/tmux-runtime-adapter.js";
+import { TerminalLogFileStore } from "./runtime/terminal-log-file-store.js";
+import { TerminalLogSpooler } from "./runtime/terminal-log-spooler.js";
+import { TerminalOutputBuffer } from "./runtime/terminal-output-buffer.js";
+import { TerminalRuntimeManager } from "./runtime/terminal-runtime-manager.js";
+export class TerminalService extends EventEmitter {
+    db;
+    terminalInstanceRepository;
+    terminalRuntimeSessionRepository;
+    workspaceService;
+    outputBuffer = new TerminalOutputBuffer();
+    runtimeManager = new TerminalRuntimeManager();
+    lastPersistedActivity = new Map();
+    terminalSubscriptionCounts = new Map();
+    pendingCloseReasons = new Map();
+    pendingDeletedTerminalIds = new Set();
+    terminalLogSpooler;
+    terminalLogFileRepository;
+    terminalLogSegmentRepository;
+    terminalLogFileStore;
+    isDisposing = false;
+    constructor(db, terminalInstanceRepository, terminalRuntimeSessionRepository, workspaceService, _idleTimeoutSeconds, options = {}) {
+        super();
+        this.db = db;
+        this.terminalInstanceRepository = terminalInstanceRepository;
+        this.terminalRuntimeSessionRepository = terminalRuntimeSessionRepository;
+        this.workspaceService = workspaceService;
+        this.terminalLogFileRepository = options.terminalLogFileRepository ?? null;
+        this.terminalLogSegmentRepository = options.terminalLogSegmentRepository ?? null;
+        this.terminalLogFileStore = options.terminalLogRootDir
+            ? new TerminalLogFileStore(options.terminalLogRootDir)
+            : null;
+        this.terminalLogSpooler =
+            options.terminalLogRootDir &&
+                options.terminalLogFileRepository &&
+                options.terminalLogSegmentRepository
+                ? new TerminalLogSpooler({
+                    logRootDir: options.terminalLogRootDir,
+                    fileRepository: options.terminalLogFileRepository,
+                    segmentRepository: options.terminalLogSegmentRepository
+                })
+                : null;
+        this.runtimeManager.on("output", (event) => {
+            this.handleRuntimeOutput(event.terminalId, event.content);
+        });
+        this.runtimeManager.on("exit", (event) => {
+            this.handleRuntimeExit(event);
+        });
+        this.recoverRuntimeStates();
+    }
+    createTerminal(input) {
+        const workspace = this.workspaceService.getWorkspaceOrThrow(input.workspaceId);
+        const now = nowIso();
+        const shell = resolveRequestedShell(sanitizeShell(input.shell) ?? getDefaultShell());
+        const cwd = resolveWorkspaceCwd(workspace.path, input.cwd);
+        const runtimeType = resolveRequestedRuntimeType(input.runtimeType);
+        const runtimeSessionId = createId();
+        const attachTarget = buildAttachTarget(runtimeType, runtimeSessionId);
+        const terminal = {
+            id: createId(),
+            workspaceId: workspace.id,
+            name: input.name?.trim() || buildDefaultTerminalName(cwd),
+            cwd,
+            shell,
+            runtimeType,
+            runtimeSessionId,
+            attachTarget,
+            status: "creating",
+            processId: null,
+            createdByUserId: input.createdByUserId,
+            createdAt: now,
+            lastActiveAt: now,
+            closedAt: null,
+            exitCode: null,
+            statusDetail: null
+        };
+        const runtimeSession = {
+            id: runtimeSessionId,
+            terminalId: terminal.id,
+            runtimeType,
+            sessionKey: runtimeSessionId,
+            attachTarget,
+            hostInstanceId: null,
+            agentPid: null,
+            shellPid: null,
+            state: "starting",
+            lastHeartbeatAt: null,
+            lastCheckedAt: now,
+            lastErrorDetail: null,
+            createdAt: now,
+            updatedAt: now
+        };
+        const persist = this.db.transaction(() => {
+            this.terminalInstanceRepository.create(terminal);
+            this.terminalRuntimeSessionRepository.create(runtimeSession);
+        });
+        persist();
+        try {
+            const env = buildTerminalEnv(input.env);
+            const createdInspection = this.runtimeManager.createPersistentSession(terminal, runtimeSession, env);
+            const attachmentProcessId = this.runtimeManager.ensureAttached(terminal, runtimeSession, env);
+            const processId = createdInspection.shellPid ?? attachmentProcessId;
+            const runningTerminal = {
+                ...terminal,
+                status: "running",
+                processId
+            };
+            this.terminalInstanceRepository.updateLifecycle({
+                id: runningTerminal.id,
+                status: runningTerminal.status,
+                processId: runningTerminal.processId,
+                lastActiveAt: runningTerminal.lastActiveAt,
+                closedAt: null,
+                exitCode: null,
+                statusDetail: null
+            });
+            this.terminalRuntimeSessionRepository.updateState({
+                id: runtimeSession.id,
+                shellPid: processId,
+                state: "running",
+                lastCheckedAt: nowIso(),
+                lastErrorDetail: createdInspection.detail,
+                updatedAt: nowIso()
+            });
+            this.emit("status", runningTerminal);
+            return runningTerminal;
+        }
+        catch (error) {
+            const failedAt = nowIso();
+            this.terminalInstanceRepository.updateLifecycle({
+                id: terminal.id,
+                status: "error",
+                processId: terminal.processId,
+                lastActiveAt: failedAt,
+                closedAt: failedAt,
+                exitCode: null,
+                statusDetail: error instanceof Error ? error.message : "PTY 启动失败"
+            });
+            this.terminalRuntimeSessionRepository.updateState({
+                id: runtimeSession.id,
+                shellPid: null,
+                state: "error",
+                lastCheckedAt: failedAt,
+                lastErrorDetail: error instanceof Error ? error.message : "PTY 启动失败",
+                updatedAt: failedAt
+            });
+            const failedTerminal = this.getTerminalOrThrow(terminal.id);
+            this.emit("status", failedTerminal);
+            throw error;
+        }
+    }
+    listTerminals(workspaceId) {
+        this.workspaceService.getWorkspaceOrThrow(workspaceId);
+        const terminals = this.terminalInstanceRepository.listByWorkspace(workspaceId);
+        let hasLifecycleChange = false;
+        for (const terminal of terminals) {
+            if (this.reconcileTerminalRuntime(terminal)) {
+                hasLifecycleChange = true;
+            }
+        }
+        return hasLifecycleChange
+            ? this.terminalInstanceRepository.listByWorkspace(workspaceId)
+            : terminals;
+    }
+    getTerminalOrThrow(terminalId) {
+        const terminal = this.terminalInstanceRepository.findById(terminalId);
+        if (!terminal) {
+            throw new AppError({
+                statusCode: 404,
+                errorCode: "TERMINAL_NOT_FOUND",
+                detail: "指定终端不存在"
+            });
+        }
+        return terminal;
+    }
+    getRuntimeSessionOrThrow(runtimeSessionId) {
+        const session = this.terminalRuntimeSessionRepository.findById(runtimeSessionId);
+        if (!session) {
+            throw new AppError({
+                statusCode: 404,
+                errorCode: "RUNTIME_SESSION_NOT_FOUND",
+                detail: "指定终端运行时会话不存在"
+            });
+        }
+        return session;
+    }
+    closeTerminal(terminalId, reason = "user_closed") {
+        const terminal = this.getTerminalOrThrow(terminalId);
+        const session = this.getRuntimeSessionOrThrow(terminal.runtimeSessionId);
+        this.pendingCloseReasons.set(terminalId, reason);
+        if (terminal.status === "closed" || terminal.status === "error") {
+            this.pendingCloseReasons.delete(terminalId);
+            return { success: true };
+        }
+        this.flushTerminalLogs(terminalId);
+        const willEmitExit = this.runtimeManager.terminateSession(terminal, session);
+        if (!willEmitExit) {
+            this.finalizeTerminalClosure(terminal, session, {
+                requestedClose: true,
+                exitCode: 0,
+                sessionAlive: false,
+                sessionDetail: null,
+                shellPid: null
+            });
+        }
+        return { success: true };
+    }
+    deleteTerminal(terminalId) {
+        const terminal = this.getTerminalOrThrow(terminalId);
+        const session = this.getRuntimeSessionOrThrow(terminal.runtimeSessionId);
+        this.pendingCloseReasons.delete(terminalId);
+        this.lastPersistedActivity.delete(terminalId);
+        this.flushTerminalLogs(terminalId);
+        this.pendingDeletedTerminalIds.add(terminalId);
+        const deleteRecords = this.db.transaction(() => {
+            this.terminalRuntimeSessionRepository.deleteByTerminalId(terminalId);
+            this.terminalInstanceRepository.delete(terminalId);
+        });
+        try {
+            deleteRecords();
+        }
+        catch (error) {
+            this.pendingDeletedTerminalIds.delete(terminalId);
+            throw error;
+        }
+        let willEmitExit = false;
+        try {
+            willEmitExit = this.runtimeManager.terminateSession(terminal, session);
+        }
+        catch (error) {
+            this.pendingDeletedTerminalIds.delete(terminalId);
+            this.clearTerminalLogs(terminalId);
+            console.warn("[terminal-delete-runtime-cleanup-failed]", {
+                terminalId,
+                runtimeSessionId: session.id,
+                runtimeType: session.runtimeType,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        if (!willEmitExit) {
+            this.pendingDeletedTerminalIds.delete(terminalId);
+            this.clearTerminalLogs(terminalId);
+        }
+        return { success: true };
+    }
+    writeInput(terminalId, content) {
+        if (!content) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "INVALID_INPUT",
+                detail: "终端输入不能为空",
+                field: "content"
+            });
+        }
+        const terminal = this.ensureTerminalInteractive(terminalId);
+        this.runtimeManager.write(terminal.id, content);
+        this.touchLastActiveAt(terminalId);
+        return { accepted: true };
+    }
+    resizeTerminal(terminalId, cols, rows) {
+        if (!Number.isInteger(cols) || !Number.isInteger(rows) || cols < 20 || rows < 5) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "INVALID_TERMINAL_SIZE",
+                detail: "终端尺寸不合法",
+                field: "cols"
+            });
+        }
+        const terminal = this.ensureTerminalInteractive(terminalId);
+        this.runtimeManager.resize(terminal.id, cols, rows);
+        this.touchLastActiveAt(terminalId);
+        return { accepted: true };
+    }
+    subscribeTerminal(terminalId, lastCursor, callbacks) {
+        const outputListener = (event) => {
+            if (event.terminalId !== terminalId) {
+                return;
+            }
+            for (const chunk of event.chunks) {
+                void callbacks.onOutput(chunk);
+            }
+        };
+        const statusListener = (nextTerminal) => {
+            if (nextTerminal.id !== terminalId) {
+                return;
+            }
+            void callbacks.onStatus(nextTerminal);
+        };
+        const exitListener = (event) => {
+            if (event.terminal.id !== terminalId) {
+                return;
+            }
+            void callbacks.onExit(event);
+        };
+        this.on("output", outputListener);
+        this.on("status", statusListener);
+        this.on("exit", exitListener);
+        this.retainTerminalSubscription(terminalId);
+        try {
+            const current = this.ensureTerminalAttachedForSubscription(terminalId);
+            const backfill = this.outputBuffer.readSince(terminalId, lastCursor);
+            void callbacks.onStatus(current);
+            void callbacks.onBackfill(backfill);
+        }
+        catch (error) {
+            this.off("output", outputListener);
+            this.off("status", statusListener);
+            this.off("exit", exitListener);
+            this.releaseTerminalSubscription(terminalId);
+            throw error;
+        }
+        let closed = false;
+        return {
+            close: () => {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                this.off("output", outputListener);
+                this.off("status", statusListener);
+                this.off("exit", exitListener);
+                this.releaseTerminalSubscription(terminalId);
+            }
+        };
+    }
+    async dispose() {
+        this.isDisposing = true;
+        this.terminalLogSpooler?.flushAll();
+        this.runtimeManager.closeAllAttachments();
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    readTerminalHistory(terminalId, beforeSeq, limit) {
+        const terminal = this.getTerminalOrThrow(terminalId);
+        const runtimeSession = terminal.runtimeSessionId
+            ? this.terminalRuntimeSessionRepository.findById(terminal.runtimeSessionId)
+            : null;
+        if (beforeSeq === 1 && runtimeSession?.runtimeType === "tmux") {
+            const capturedContent = normalizeTerminalHistoryContent(captureTmuxPaneContent(runtimeSession.sessionKey));
+            const capturedLineCount = countTerminalHistoryLines(capturedContent);
+            return {
+                terminalId,
+                content: capturedContent,
+                lineCount: capturedLineCount,
+                anchorLine: 0,
+                replaceContent: true,
+                hasMore: false,
+                nextBeforeSeq: null
+            };
+        }
+        const historyPage = this.readTerminalHistorySegments(terminalId, beforeSeq, limit);
+        const orderedSegments = [...historyPage.segments].reverse();
+        const content = normalizeTerminalHistoryContent(orderedSegments.map((segment) => segment.content).join(""));
+        const lineCount = countTerminalHistoryLines(content);
+        const shouldFallbackToTmuxPane = runtimeSession?.runtimeType === "tmux" &&
+            !historyPage.hasMore &&
+            historyPage.nextBeforeSeq === 1;
+        return {
+            terminalId,
+            content,
+            lineCount,
+            anchorLine: lineCount,
+            hasMore: shouldFallbackToTmuxPane ? true : historyPage.hasMore,
+            nextBeforeSeq: historyPage.nextBeforeSeq
+        };
+    }
+    readTerminalHistorySegments(terminalId, beforeSeq, limit) {
+        this.getTerminalOrThrow(terminalId);
+        if (!this.terminalLogSegmentRepository || !this.terminalLogFileRepository || !this.terminalLogFileStore) {
+            return {
+                terminalId,
+                segments: [],
+                hasMore: false,
+                nextBeforeSeq: null
+            };
+        }
+        const terminalLogSegmentRepository = this.terminalLogSegmentRepository;
+        const terminalLogFileRepository = this.terminalLogFileRepository;
+        const terminalLogFileStore = this.terminalLogFileStore;
+        const segments = this.terminalLogSegmentRepository.listBeforeSeq(terminalId, beforeSeq, limit);
+        const historySegments = segments.map((segment) => {
+            const logFile = terminalLogFileRepository.findById(segment.fileId);
+            if (!logFile) {
+                throw new AppError({
+                    statusCode: 409,
+                    errorCode: "TERMINAL_LOG_INDEX_INVALID",
+                    detail: "终端日志索引缺少对应文件记录"
+                });
+            }
+            try {
+                return {
+                    id: segment.id,
+                    fileId: segment.fileId,
+                    startSeq: segment.startSeq,
+                    endSeq: segment.endSeq,
+                    content: terminalLogFileStore.read(logFile.relativePath, segment.startOffset, segment.byteLength),
+                    byteLength: segment.byteLength,
+                    createdAt: segment.createdAt
+                };
+            }
+            catch (error) {
+                throw new AppError({
+                    statusCode: 409,
+                    errorCode: "TERMINAL_LOG_FILE_MISSING",
+                    detail: error instanceof Error ? error.message : "终端日志文件不存在，无法回放历史"
+                });
+            }
+        });
+        const oldestSeq = historySegments.at(-1)?.startSeq ?? null;
+        const hasMore = oldestSeq !== null
+            ? terminalLogSegmentRepository.listBeforeSeq(terminalId, oldestSeq, 1).length > 0
+            : false;
+        return {
+            terminalId,
+            segments: historySegments,
+            hasMore,
+            nextBeforeSeq: oldestSeq
+        };
+    }
+    handleRuntimeOutput(terminalId, content) {
+        if (this.isDisposing) {
+            return;
+        }
+        const chunks = this.outputBuffer.append(terminalId, content);
+        if (chunks.length === 0) {
+            return;
+        }
+        this.terminalLogSpooler?.appendChunks(terminalId, chunks);
+        this.touchLastActiveAt(terminalId);
+        this.emit("output", {
+            terminalId,
+            chunks
+        });
+    }
+    handleRuntimeExit(event) {
+        if (this.isDisposing) {
+            return;
+        }
+        if (this.pendingDeletedTerminalIds.delete(event.terminalId)) {
+            this.pendingCloseReasons.delete(event.terminalId);
+            this.lastPersistedActivity.delete(event.terminalId);
+            this.clearTerminalLogs(event.terminalId);
+            return;
+        }
+        this.flushTerminalLogs(event.terminalId);
+        const current = this.getTerminalOrThrow(event.terminalId);
+        const session = this.getRuntimeSessionOrThrow(current.runtimeSessionId);
+        if (event.sessionAlive && !event.requestedClose) {
+            this.markTerminalRunning(current, session, event.shellPid, event.sessionDetail);
+            return;
+        }
+        this.finalizeTerminalClosure(current, session, event);
+    }
+    touchLastActiveAt(terminalId) {
+        if (this.isDisposing) {
+            return;
+        }
+        const now = Date.now();
+        const previous = this.lastPersistedActivity.get(terminalId) ?? 0;
+        if (now - previous >= 500) {
+            this.lastPersistedActivity.set(terminalId, now);
+            this.terminalInstanceRepository.touchLastActiveAt(terminalId, nowIso(new Date(now)));
+        }
+    }
+    ensureTerminalInteractive(terminalId) {
+        const terminal = this.getTerminalOrThrow(terminalId);
+        const session = this.getRuntimeSessionOrThrow(terminal.runtimeSessionId);
+        const nextTerminal = this.ensureTerminalRunning(terminal, session, true);
+        if (nextTerminal.status !== "running") {
+            throw new AppError({
+                statusCode: 409,
+                errorCode: "TERMINAL_NOT_RUNNING",
+                detail: nextTerminal.statusDetail ?? "终端当前不可写入"
+            });
+        }
+        return nextTerminal;
+    }
+    ensureTerminalAttachedForSubscription(terminalId) {
+        const terminal = this.getTerminalOrThrow(terminalId);
+        const session = this.getRuntimeSessionOrThrow(terminal.runtimeSessionId);
+        return this.ensureTerminalRunning(terminal, session, true);
+    }
+    ensureTerminalRunning(terminal, session, ensureAttached) {
+        if (terminal.status === "closed" || terminal.status === "error") {
+            return terminal;
+        }
+        const inspection = this.runtimeManager.inspectPersistentSession(terminal, session);
+        if (!inspection.alive) {
+            if (shouldMarkRuntimeLost(terminal, inspection.detail)) {
+                return this.markTerminalLost(terminal, session, inspection.detail);
+            }
+            return this.markTerminalError(terminal, session, inspection.detail ?? buildMissingProcessStatusDetail(terminal));
+        }
+        if (ensureAttached) {
+            const attachmentProcessId = this.runtimeManager.ensureAttached(terminal, session, buildTerminalEnv());
+            return this.markTerminalRunning(terminal, session, inspection.shellPid ?? attachmentProcessId, inspection.detail);
+        }
+        return this.markTerminalRunning(terminal, session, inspection.shellPid, inspection.detail);
+    }
+    reconcileTerminalRuntime(terminal) {
+        if (terminal.status === "closed" || terminal.status === "error") {
+            return false;
+        }
+        const before = JSON.stringify({
+            status: terminal.status,
+            processId: terminal.processId,
+            statusDetail: terminal.statusDetail
+        });
+        const session = this.getRuntimeSessionOrThrow(terminal.runtimeSessionId);
+        const nextTerminal = this.ensureTerminalRunning(terminal, session, false);
+        const after = JSON.stringify({
+            status: nextTerminal.status,
+            processId: nextTerminal.processId,
+            statusDetail: nextTerminal.statusDetail
+        });
+        return before !== after;
+    }
+    markTerminalRunning(terminal, session, processId, detail) {
+        const shouldUpdate = terminal.status !== "running" ||
+            terminal.processId !== processId ||
+            terminal.closedAt !== null ||
+            (terminal.statusDetail ?? null) !== (detail ?? null) ||
+            session.state !== "running" ||
+            session.shellPid !== processId ||
+            (session.lastErrorDetail ?? null) !== (detail ?? null);
+        if (!shouldUpdate) {
+            return terminal;
+        }
+        const updatedAt = nowIso();
+        this.terminalInstanceRepository.updateLifecycle({
+            id: terminal.id,
+            status: "running",
+            processId,
+            lastActiveAt: terminal.lastActiveAt,
+            closedAt: null,
+            exitCode: null,
+            statusDetail: detail ?? null
+        });
+        this.terminalRuntimeSessionRepository.updateState({
+            id: session.id,
+            shellPid: processId,
+            state: "running",
+            lastCheckedAt: updatedAt,
+            lastErrorDetail: detail ?? null,
+            updatedAt
+        });
+        const updated = this.getTerminalOrThrow(terminal.id);
+        this.emit("status", updated);
+        return updated;
+    }
+    markTerminalLost(terminal, session, detail) {
+        const updatedAt = nowIso();
+        this.terminalRuntimeSessionRepository.updateState({
+            id: session.id,
+            shellPid: terminal.processId,
+            state: "lost",
+            lastCheckedAt: updatedAt,
+            lastErrorDetail: detail ?? "RUNTIME_LOST",
+            updatedAt
+        });
+        this.terminalInstanceRepository.updateLifecycle({
+            id: terminal.id,
+            status: "running",
+            processId: terminal.processId,
+            lastActiveAt: terminal.lastActiveAt,
+            closedAt: null,
+            exitCode: null,
+            statusDetail: detail ?? terminal.statusDetail
+        });
+        const updated = this.getTerminalOrThrow(terminal.id);
+        this.emit("status", updated);
+        return updated;
+    }
+    markTerminalError(terminal, session, detail) {
+        const closedAt = nowIso();
+        this.terminalInstanceRepository.updateLifecycle({
+            id: terminal.id,
+            status: "error",
+            processId: terminal.processId,
+            lastActiveAt: closedAt,
+            closedAt,
+            exitCode: terminal.exitCode,
+            statusDetail: detail
+        });
+        this.terminalRuntimeSessionRepository.updateState({
+            id: session.id,
+            shellPid: terminal.processId,
+            state: "error",
+            lastCheckedAt: closedAt,
+            lastErrorDetail: detail,
+            updatedAt: closedAt
+        });
+        const updated = this.getTerminalOrThrow(terminal.id);
+        this.emit("status", updated);
+        return updated;
+    }
+    finalizeTerminalClosure(terminal, session, event) {
+        const closeReason = this.pendingCloseReasons.get(terminal.id) ?? "user_closed";
+        this.pendingCloseReasons.delete(terminal.id);
+        const finishedAt = nowIso();
+        const status = event.requestedClose || event.exitCode === 0 ? "closed" : "error";
+        const statusDetail = status === "error"
+            ? event.sessionDetail ?? `终端异常退出，exitCode=${event.exitCode ?? "unknown"}`
+            : resolveClosedStatusDetail(closeReason, terminal.statusDetail);
+        this.terminalInstanceRepository.updateLifecycle({
+            id: terminal.id,
+            status,
+            processId: event.shellPid ?? terminal.processId,
+            lastActiveAt: finishedAt,
+            closedAt: finishedAt,
+            exitCode: event.exitCode,
+            statusDetail
+        });
+        this.terminalRuntimeSessionRepository.updateState({
+            id: session.id,
+            shellPid: event.shellPid,
+            state: status === "closed" ? "closed" : "error",
+            lastCheckedAt: finishedAt,
+            lastErrorDetail: status === "error" ? statusDetail : null,
+            updatedAt: finishedAt
+        });
+        const updated = this.getTerminalOrThrow(terminal.id);
+        this.emit("status", updated);
+        this.emit("exit", {
+            terminal: updated,
+            requestedClose: event.requestedClose
+        });
+        if (status === "closed") {
+            this.clearTerminalLogs(terminal.id);
+        }
+    }
+    recoverRuntimeStates() {
+        const terminals = this.terminalInstanceRepository.listRecoverable();
+        for (const terminal of terminals) {
+            const session = this.terminalRuntimeSessionRepository.findById(terminal.runtimeSessionId);
+            if (!session) {
+                this.markTerminalError(terminal, {
+                    id: terminal.runtimeSessionId,
+                    terminalId: terminal.id,
+                    runtimeType: terminal.runtimeType,
+                    sessionKey: terminal.runtimeSessionId,
+                    attachTarget: terminal.attachTarget,
+                    hostInstanceId: null,
+                    agentPid: null,
+                    shellPid: terminal.processId,
+                    state: "error",
+                    lastHeartbeatAt: null,
+                    lastCheckedAt: null,
+                    lastErrorDetail: "RUNTIME_SESSION_MISSING",
+                    createdAt: terminal.createdAt,
+                    updatedAt: terminal.lastActiveAt
+                }, "RUNTIME_SESSION_MISSING");
+                continue;
+            }
+            this.ensureTerminalRunning(terminal, session, false);
+        }
+    }
+    retainTerminalSubscription(terminalId) {
+        const currentCount = this.terminalSubscriptionCounts.get(terminalId) ?? 0;
+        this.terminalSubscriptionCounts.set(terminalId, currentCount + 1);
+    }
+    releaseTerminalSubscription(terminalId) {
+        const currentCount = this.terminalSubscriptionCounts.get(terminalId) ?? 0;
+        if (currentCount <= 1) {
+            this.terminalSubscriptionCounts.delete(terminalId);
+            this.detachRuntimeAttachmentIfIdle(terminalId);
+            return;
+        }
+        this.terminalSubscriptionCounts.set(terminalId, currentCount - 1);
+    }
+    detachRuntimeAttachmentIfIdle(terminalId) {
+        if (this.isDisposing) {
+            return;
+        }
+        const terminal = this.terminalInstanceRepository.findById(terminalId);
+        if (!terminal || terminal.status !== "running") {
+            return;
+        }
+        const session = this.terminalRuntimeSessionRepository.findById(terminal.runtimeSessionId);
+        if (!session || session.runtimeType === "embedded-pty") {
+            return;
+        }
+        this.runtimeManager.detach(terminalId);
+    }
+    flushTerminalLogs(terminalId) {
+        this.terminalLogSpooler?.flushTerminal(terminalId);
+    }
+    clearTerminalLogs(terminalId) {
+        this.outputBuffer.clear(terminalId);
+        this.terminalLogSegmentRepository?.deleteByTerminalId(terminalId);
+        this.terminalLogFileRepository?.deleteByTerminalId(terminalId);
+        this.terminalLogSpooler?.deleteTerminalLogs(terminalId);
+    }
+}
+function normalizeTerminalHistoryContent(content) {
+    return content
+        .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, "")
+        .replace(/\u001bP[\s\S]*?\u001b\\/g, "")
+        .replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "")
+        .replace(/\r/g, "");
+}
+function countTerminalHistoryLines(content) {
+    if (!content) {
+        return 0;
+    }
+    const normalized = content.endsWith("\n") ? content.slice(0, -1) : content;
+    if (!normalized) {
+        return 0;
+    }
+    return normalized.split("\n").length;
+}
+function sanitizeShell(shell) {
+    const value = shell?.trim();
+    if (!value) {
+        return null;
+    }
+    if (value.includes("\0") || value.includes("\n") || value.includes("\r")) {
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "INVALID_SHELL",
+            detail: "shell 不能包含非法控制字符",
+            field: "shell"
+        });
+    }
+    return value;
+}
+function resolveRequestedRuntimeType(input) {
+    const runtimeType = input ?? (process.platform === "win32" ? "embedded-pty" : "tmux");
+    if (runtimeType !== "embedded-pty" &&
+        runtimeType !== "tmux") {
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "UNSUPPORTED_TERMINAL_RUNTIME",
+            detail: `当前 Host 还未实现 runtime=${runtimeType}`
+        });
+    }
+    return runtimeType;
+}
+function buildAttachTarget(runtimeType, runtimeSessionId) {
+    if (runtimeType === "embedded-pty") {
+        return `embedded:${runtimeSessionId}`;
+    }
+    return `${runtimeType}:${runtimeSessionId}`;
+}
+function buildTerminalEnv(extraEnv) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (typeof value === "string") {
+            env[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(extraEnv ?? {})) {
+        env[key] = value;
+    }
+    return env;
+}
+function buildDefaultTerminalName(cwd) {
+    const folderName = path.basename(cwd).trim();
+    return folderName || "终端";
+}
+function buildMissingProcessStatusDetail(terminal) {
+    if (terminal.processId && !isProcessAlive(terminal.processId)) {
+        return `终端绑定进程已停止，PID=${terminal.processId}`;
+    }
+    if (terminal.processId) {
+        return `终端运行时已经失联，PID=${terminal.processId}`;
+    }
+    return "终端运行时已经失联";
+}
+function isProcessAlive(processId) {
+    try {
+        process.kill(processId, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveClosedStatusDetail(reason, currentStatusDetail) {
+    if (reason === "idle_timeout") {
+        return "TERMINAL_IDLE_TIMEOUT";
+    }
+    return currentStatusDetail;
+}
+function shouldMarkRuntimeLost(terminal, detail) {
+    return terminal.runtimeType !== "embedded-pty" && Boolean(detail?.includes("检查失败"));
+}
+//# sourceMappingURL=terminal-service.js.map