akemon 0.3.6 → 0.3.7

package/dist/workbench-session.js

@@ -0,0 +1,1074 @@
+import { randomUUID } from "crypto";
+import { execFileSync } from "child_process";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, readSync, statSync, writeFileSync, } from "fs";
+import { isAbsolute, join, relative, resolve as resolvePath } from "path";
+import { StreamingRedactor, redactSecrets } from "./redaction.js";
+import { getRuntimePlatform } from "./runtime-platform.js";
+import { logBestEffortError } from "./best-effort.js";
+import { resolveWorkdirSafety } from "./software-agent-peripheral.js";
+const DEFAULT_MAX_SESSIONS = 3;
+const DEFAULT_MAX_COMPLETED_SESSIONS = 20;
+const DEFAULT_MAX_BUFFER_CHARS = 200_000;
+const DEFAULT_FORCE_KILL_AFTER_MS = 3_000;
+const DEFAULT_COLS = 100;
+const DEFAULT_ROWS = 30;
+const TMUX_CAPTURE_BUFFER_MULTIPLIER = 4;
+const TMUX_CAPTURE_MIN_BUFFER_BYTES = 1_000_000;
+const TMUX_CAPTURE_MAX_BUFFER_BYTES = 16_000_000;
+const LOG_TAIL_READ_MULTIPLIER = 8;
+const LOG_TAIL_MIN_READ_BYTES = 256_000;
+const LOG_TAIL_MAX_READ_BYTES = 4_000_000;
+const SPLIT_SUBMIT_DELAY_MS = 35;
+const DEFAULT_TUI_INPUT_TOOLS = new Set(["codex", "cursor"]);
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+const DEFAULT_WORKBENCH_ENV_ALLOWLIST = [
+    "CI",
+    "COLORTERM",
+    "COMSPEC",
+    "ComSpec",
+    "HOME",
+    "HOMEDRIVE",
+    "HOMEPATH",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "LOCALAPPDATA",
+    "LOGNAME",
+    "PATH",
+    "Path",
+    "PATHEXT",
+    "PROGRAMFILES",
+    "ProgramFiles",
+    "PROGRAMFILES(X86)",
+    "ProgramFiles(x86)",
+    "PSModulePath",
+    "SHELL",
+    "SystemDrive",
+    "SystemRoot",
+    "TEMP",
+    "TERM",
+    "TMP",
+    "TMPDIR",
+    "USER",
+    "USERDOMAIN",
+    "USERNAME",
+    "USERPROFILE",
+    "WINDIR",
+    "windir",
+];
+const DIRECT_PTY_WORKBENCH_BACKEND = {
+    kind: "direct-pty",
+    recoverable: false,
+    async start(request) {
+        return request.ptyFactory(request.record.command, request.record.args, {
+            name: "xterm-256color",
+            cols: request.cols,
+            rows: request.rows,
+            cwd: request.cwd,
+            env: request.env,
+        });
+    },
+    stop(session, mode, runtime) {
+        killPtyProcess(session.pty, mode, runtime);
+    },
+    detach(session, runtime) {
+        killPtyProcess(session.pty, "term", runtime);
+    },
+};
+const TMUX_WORKBENCH_BACKEND = {
+    kind: "tmux",
+    recoverable: true,
+    async start(request) {
+        if (request.checkBackendAvailability)
+            assertTmuxAvailable();
+        if (!request.record.backendSessionId) {
+            throw new Error("tmux Workbench sessions require backendSessionId");
+        }
+        return request.ptyFactory("tmux", [
+            "new-session",
+            "-A",
+            "-s",
+            request.record.backendSessionId,
+            "-c",
+            request.cwd,
+            "--",
+            request.record.command,
+            ...request.record.args,
+        ], {
+            name: "xterm-256color",
+            cols: request.cols,
+            rows: request.rows,
+            cwd: request.cwd,
+            env: request.env,
+        });
+    },
+    async reattach(request) {
+        if (request.checkBackendAvailability)
+            assertTmuxAvailable();
+        if (!request.record.backendSessionId)
+            return null;
+        if (request.checkBackendAvailability && !hasTmuxSession(request.record.backendSessionId))
+            return null;
+        return request.ptyFactory("tmux", [
+            "attach-session",
+            "-t",
+            request.record.backendSessionId,
+        ], {
+            name: "xterm-256color",
+            cols: request.cols,
+            rows: request.rows,
+            cwd: request.cwd,
+            env: request.env,
+        });
+    },
+    stop(session, mode, runtime) {
+        if (session.record.backendSessionId) {
+            try {
+                execFileSync("tmux", ["kill-session", "-t", session.record.backendSessionId], { stdio: "ignore" });
+            }
+            catch (error) {
+                logBestEffortError("workbench tmux kill-session", error);
+            }
+        }
+        killPtyProcess(session.pty, mode, runtime);
+    },
+    detach(session, runtime) {
+        killPtyProcess(session.pty, "term", runtime);
+    },
+};
+export class WorkbenchSessionManager {
+    config;
+    sessions = new Map();
+    subscribers = new Set();
+    readyPromise;
+    activeSessionId = "";
+    constructor(config) {
+        if (config.envAllowlist !== undefined && config.envFilter !== undefined) {
+            throw new Error("Workbench env configuration is ambiguous: pass either envAllowlist or envFilter, not both");
+        }
+        this.config = {
+            ...config,
+            baseWorkdir: resolvePath(config.baseWorkdir),
+            maxSessions: config.maxSessions || DEFAULT_MAX_SESSIONS,
+            maxCompletedSessions: config.maxCompletedSessions ?? DEFAULT_MAX_COMPLETED_SESSIONS,
+            maxBufferChars: config.maxBufferChars || DEFAULT_MAX_BUFFER_CHARS,
+            forceKillAfterMs: config.forceKillAfterMs ?? DEFAULT_FORCE_KILL_AFTER_MS,
+            sourceEnv: config.sourceEnv || process.env,
+            backend: config.backend || resolveDefaultWorkbenchBackend(config),
+        };
+        this.readyPromise = new Promise((resolve, reject) => {
+            setImmediate(() => {
+                this.recoverPersistedSessions().then(resolve, reject);
+            });
+        });
+    }
+    async ready() {
+        await this.readyPromise;
+    }
+    async startSession(request) {
+        await this.readyPromise;
+        const runningCount = Array.from(this.sessions.values())
+            .filter((session) => session.record.status === "running").length;
+        if (runningCount >= this.config.maxSessions) {
+            throw new Error(`Workbench session limit reached (${this.config.maxSessions})`);
+        }
+        const runtime = this.config.runtime || getRuntimePlatform();
+        if (!runtime.capabilities.canStartPty) {
+            throw new Error(`Workbench PTY sessions are not supported on platform: ${runtime.platform}`);
+        }
+        const workdirSafety = resolveWorkdirSafety(this.config.baseWorkdir, request.workdir || this.config.baseWorkdir, request.allowOutsideWorkdir === true);
+        const command = resolveWorkbenchCommand(request, runtime);
+        const factory = await this.resolvePtyFactory();
+        const sessionId = `wb_${Date.now()}_${randomUUID().slice(0, 8)}`;
+        const backend = this.resolveBackend(this.config.backend);
+        const backendSessionId = backend.kind === "tmux" ? `akemon_${safeWorkbenchSessionFilename(sessionId)}` : undefined;
+        const cols = clampTerminalDimension(request.cols, DEFAULT_COLS);
+        const rows = clampTerminalDimension(request.rows, DEFAULT_ROWS);
+        const inputMode = request.inputMode || defaultWorkbenchInputMode(request.tool);
+        const startedAt = new Date().toISOString();
+        const absoluteLogPath = join(this.sessionDirectory(), `${safeWorkbenchSessionFilename(sessionId)}.jsonl`);
+        const logPath = this.relativeSessionPath(absoluteLogPath);
+        const childEnvironment = buildWorkbenchChildEnvironment(this.config.sourceEnv, {
+            allowlist: this.config.envAllowlist,
+            filter: this.config.envFilter,
+        });
+        mkdirSync(this.sessionDirectory(), { recursive: true });
+        const record = {
+            schemaVersion: 1,
+            sessionId,
+            label: normalizeOptionalString(request.label),
+            tool: request.tool,
+            status: "running",
+            workdir: workdirSafety.effectiveWorkdir,
+            workdirSafety,
+            backend: backend.kind,
+            backendSessionId,
+            recoverable: backend.recoverable,
+            command: command.command,
+            args: command.args,
+            commandLineDisplay: formatCommandLineDisplay(command.command, command.args),
+            inputMode,
+            cols,
+            rows,
+            startedAt,
+            updatedAt: startedAt,
+            logPath,
+            transmittedEnvKeys: childEnvironment.transmittedEnvKeys,
+            ownerDirectInputCount: 0,
+            ownerDirectInputBytes: 0,
+            outputChars: 0,
+        };
+        let ptyProcess;
+        try {
+            ptyProcess = await backend.start({
+                record,
+                ptyFactory: factory,
+                checkBackendAvailability: !this.config.ptyFactory,
+                cols,
+                rows,
+                cwd: workdirSafety.effectiveWorkdir,
+                env: childEnvironment.env,
+            });
+        }
+        catch (err) {
+            throw new Error(`Failed to start Workbench session: ${err.message || String(err)}`);
+        }
+        const session = {
+            record,
+            pty: ptyProcess,
+            backend,
+            rollingBuffer: "",
+            outputRedactor: new StreamingRedactor(),
+        };
+        this.sessions.set(sessionId, session);
+        this.activeSessionId = sessionId;
+        this.writeLog(session, {
+            type: "start",
+            tool: record.tool,
+            commandLineDisplay: record.commandLineDisplay,
+            inputMode: record.inputMode,
+            backend: record.backend,
+            recoverable: record.recoverable,
+            workdir: record.workdir,
+            label: record.label,
+            transmittedEnvKeys: record.transmittedEnvKeys,
+        });
+        this.writeMetadata(record);
+        this.emitStreamEvent({ type: "status", sessionId, snapshot: this.snapshot(session) });
+        this.attachPtyHandlers(session);
+        if (request.initialInput) {
+            this.writeInput(sessionId, { input: request.initialInput });
+        }
+        return this.snapshot(session);
+    }
+    listSessions() {
+        return Array.from(this.sessions.values())
+            .sort((left, right) => right.record.startedAt.localeCompare(left.record.startedAt))
+            .map((session) => this.snapshot(session));
+    }
+    getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session ? this.snapshot(session) : null;
+    }
+    getActiveSession() {
+        if (!this.activeSessionId)
+            return null;
+        const session = this.sessions.get(this.activeSessionId);
+        if (!session) {
+            this.activeSessionId = "";
+            return null;
+        }
+        return this.snapshot(session);
+    }
+    getActiveSessionId() {
+        return this.getActiveSession()?.sessionId || null;
+    }
+    setActiveSession(sessionId) {
+        const session = this.requireSession(sessionId);
+        this.activeSessionId = sessionId;
+        this.refreshRecoverableDisplayBuffer(session);
+        return this.snapshot(session);
+    }
+    setInputMode(sessionId, inputMode) {
+        const session = this.requireSession(sessionId);
+        session.record.inputMode = inputMode;
+        session.record.updatedAt = new Date().toISOString();
+        this.writeLog(session, {
+            type: "input_mode",
+            inputMode,
+        });
+        this.writeMetadata(session.record);
+        this.emitStreamEvent({ type: "status", sessionId, snapshot: this.snapshot(session) });
+        return this.snapshot(session);
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+    writeInput(sessionId, request) {
+        const session = this.requireSession(sessionId);
+        if (session.record.status !== "running") {
+            throw new Error(`Workbench session ${sessionId} is not running`);
+        }
+        if (!session.pty) {
+            throw new Error(`Workbench session ${sessionId} is not attached`);
+        }
+        if (typeof request.input !== "string" || request.input.length === 0) {
+            throw new Error("Missing required string field: input");
+        }
+        writeInputToPty(session, request.input, request.inputMode);
+        session.record.ownerDirectInputCount += 1;
+        session.record.ownerDirectInputBytes += Buffer.byteLength(request.input, "utf8");
+        session.record.updatedAt = new Date().toISOString();
+        this.writeLog(session, {
+            type: "owner_input",
+            mode: "owner-direct",
+            inputMode: request.inputMode || session.record.inputMode,
+            summary: summarizeOwnerInput(request.input),
+        });
+        this.writeMetadata(session.record);
+        this.emitStreamEvent({ type: "status", sessionId, snapshot: this.snapshot(session) });
+        return this.snapshot(session);
+    }
+    resizeSession(sessionId, request) {
+        const session = this.requireSession(sessionId);
+        if (session.record.status !== "running") {
+            throw new Error(`Workbench session ${sessionId} is not running`);
+        }
+        if (!session.pty) {
+            throw new Error(`Workbench session ${sessionId} is not attached`);
+        }
+        const cols = clampTerminalDimension(request.cols, DEFAULT_COLS);
+        const rows = clampTerminalDimension(request.rows, DEFAULT_ROWS);
+        session.pty.resize(cols, rows);
+        session.record.cols = cols;
+        session.record.rows = rows;
+        session.record.updatedAt = new Date().toISOString();
+        this.writeLog(session, { type: "resize", cols, rows });
+        this.writeMetadata(session.record);
+        this.emitStreamEvent({ type: "status", sessionId, snapshot: this.snapshot(session) });
+        return this.snapshot(session);
+    }
+    stopSession(sessionId) {
+        const session = this.requireSession(sessionId);
+        if (session.record.status === "running") {
+            this.stopRunningSession(session, "owner-request");
+        }
+        return this.snapshot(session);
+    }
+    async stopAll() {
+        for (const session of this.sessions.values()) {
+            if (session.record.status === "running") {
+                try {
+                    this.stopRunningSession(session, "shutdown");
+                }
+                catch (error) {
+                    logBestEffortError("workbench stop session", error);
+                }
+            }
+        }
+    }
+    async shutdown() {
+        for (const session of this.sessions.values()) {
+            if (session.record.status !== "running")
+                continue;
+            try {
+                if (session.record.recoverable) {
+                    session.record.updatedAt = new Date().toISOString();
+                    this.writeLog(session, {
+                        type: "detach",
+                        reason: "server-shutdown",
+                        backend: session.record.backend,
+                    });
+                    session.detaching = true;
+                    session.backend.detach(session, this.config.runtime || getRuntimePlatform());
+                    session.pty = undefined;
+                    session.detaching = false;
+                    this.writeMetadata(session.record);
+                    this.emitStreamEvent({
+                        type: "status",
+                        sessionId: session.record.sessionId,
+                        snapshot: this.snapshot(session),
+                    });
+                }
+                else {
+                    this.stopRunningSession(session, "shutdown");
+                }
+            }
+            catch (error) {
+                logBestEffortError("workbench shutdown session", error);
+            }
+        }
+    }
+    async recoverPersistedSessions() {
+        const sessionDir = this.sessionDirectory();
+        if (!existsSync(sessionDir))
+            return;
+        let files;
+        try {
+            files = readdirSync(sessionDir)
+                .filter((file) => file.endsWith(".json"))
+                .sort();
+        }
+        catch (error) {
+            logBestEffortError("workbench session recovery scan", error);
+            return;
+        }
+        let ptyFactory = null;
+        let childEnvironment = null;
+        const records = [];
+        for (const file of files) {
+            const record = this.readMetadataFile(join(sessionDir, file));
+            if (!record || this.sessions.has(record.sessionId))
+                continue;
+            records.push(record);
+        }
+        for (const record of this.selectRecordsForRecovery(records)) {
+            const backend = this.resolveBackend(record.backend || "direct-pty");
+            const session = {
+                record: {
+                    ...record,
+                    backend: record.backend || "direct-pty",
+                    recoverable: record.recoverable === true,
+                },
+                backend,
+                rollingBuffer: this.readTailFromLog(record),
+                outputRedactor: new StreamingRedactor(),
+            };
+            this.sessions.set(record.sessionId, session);
+            if (session.record.status !== "running")
+                continue;
+            if (!session.record.recoverable || !backend.reattach) {
+                this.markRecoveredSessionFailed(session, "not-recoverable");
+                continue;
+            }
+            try {
+                if (!ptyFactory)
+                    ptyFactory = await this.resolvePtyFactory();
+                if (!childEnvironment) {
+                    childEnvironment = buildWorkbenchChildEnvironment(this.config.sourceEnv, {
+                        allowlist: this.config.envAllowlist,
+                        filter: this.config.envFilter,
+                    });
+                }
+                const pty = await backend.reattach({
+                    record: session.record,
+                    ptyFactory,
+                    checkBackendAvailability: !this.config.ptyFactory,
+                    cols: session.record.cols,
+                    rows: session.record.rows,
+                    cwd: session.record.workdir,
+                    env: childEnvironment.env,
+                });
+                if (!pty) {
+                    this.markRecoveredSessionFailed(session, "backend-session-not-found");
+                    continue;
+                }
+                session.pty = pty;
+                session.record.updatedAt = new Date().toISOString();
+                this.writeLog(session, {
+                    type: "reattach",
+                    backend: session.record.backend,
+                    backendSessionId: session.record.backendSessionId,
+                });
+                this.writeMetadata(session.record);
+                this.attachPtyHandlers(session);
+                if (!this.activeSessionId)
+                    this.activeSessionId = session.record.sessionId;
+            }
+            catch (error) {
+                this.markRecoveredSessionFailed(session, error?.message || "reattach-failed");
+            }
+        }
+        this.evictCompletedSessions();
+    }
+    selectRecordsForRecovery(records) {
+        const running = records.filter((record) => record.status === "running");
+        const completed = records
+            .filter((record) => record.status !== "running")
+            .sort(compareSessionRecordNewestFirst)
+            .slice(0, this.config.maxCompletedSessions);
+        return [...running, ...completed].sort(compareSessionRecordOldestFirst);
+    }
+    attachPtyHandlers(session) {
+        if (!session.pty)
+            return;
+        const { sessionId } = session.record;
+        session.pty.onData((data) => {
+            if (session.record.status !== "running")
+                return;
+            const safeData = session.outputRedactor.push(data);
+            if (!safeData)
+                return;
+            session.record.outputChars += safeData.length;
+            session.record.updatedAt = new Date().toISOString();
+            session.rollingBuffer = appendRollingBuffer(session.rollingBuffer, safeData, this.config.maxBufferChars);
+            this.writeLog(session, { type: "output", data: safeData });
+            this.writeMetadata(session.record);
+            this.emitStreamEvent({
+                type: "output",
+                sessionId,
+                chunk: safeData,
+                snapshot: this.snapshot(session),
+            });
+        });
+        session.pty.onExit((event) => {
+            if (session.forceKillTimer) {
+                clearTimeout(session.forceKillTimer);
+                session.forceKillTimer = undefined;
+            }
+            if (session.detaching && session.record.recoverable) {
+                session.pty = undefined;
+                session.detaching = false;
+                session.record.updatedAt = new Date().toISOString();
+                this.writeMetadata(session.record);
+                return;
+            }
+            const flushed = session.outputRedactor.flush();
+            if (flushed) {
+                session.record.outputChars += flushed.length;
+                session.rollingBuffer = appendRollingBuffer(session.rollingBuffer, flushed, this.config.maxBufferChars);
+                this.writeLog(session, { type: "output", data: flushed });
+                this.emitStreamEvent({
+                    type: "output",
+                    sessionId,
+                    chunk: flushed,
+                    snapshot: this.snapshot(session),
+                });
+            }
+            session.pty = undefined;
+            session.record.status = session.record.status === "stopped"
+                ? "stopped"
+                : event.exitCode === 0 ? "exited" : "failed";
+            session.record.exitCode = event.exitCode;
+            session.record.signal = event.signal;
+            session.record.endedAt = new Date().toISOString();
+            session.record.updatedAt = session.record.endedAt;
+            this.writeLog(session, {
+                type: "exit",
+                exitCode: event.exitCode,
+                signal: event.signal,
+            });
+            this.writeMetadata(session.record);
+            this.emitStreamEvent({
+                type: "exit",
+                sessionId,
+                exitCode: event.exitCode,
+                signal: event.signal,
+                snapshot: this.snapshot(session),
+            });
+            this.evictCompletedSessions();
+        });
+    }
+    stopRunningSession(session, reason) {
+        session.record.status = "stopped";
+        session.record.updatedAt = new Date().toISOString();
+        this.writeLog(session, { type: "stop", reason });
+        this.killSessionPty(session, "term");
+        this.scheduleForceKill(session, reason);
+        this.writeMetadata(session.record);
+        this.emitStreamEvent({
+            type: "status",
+            sessionId: session.record.sessionId,
+            snapshot: this.snapshot(session),
+        });
+    }
+    markRecoveredSessionFailed(session, reason) {
+        const now = new Date().toISOString();
+        session.record.status = "failed";
+        session.record.error = `Workbench session could not be reattached: ${reason}`;
+        session.record.endedAt = now;
+        session.record.updatedAt = now;
+        this.writeLog(session, {
+            type: "recovery_failed",
+            reason,
+            backend: session.record.backend,
+            backendSessionId: session.record.backendSessionId,
+        });
+        this.writeMetadata(session.record);
+    }
+    requireSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Workbench session not found: ${sessionId}`);
+        return session;
+    }
+    snapshot(session) {
+        return {
+            ...redactSecrets(session.record),
+            tail: session.rollingBuffer,
+        };
+    }
+    refreshRecoverableDisplayBuffer(session) {
+        if (session.record.status !== "running")
+            return;
+        if (session.record.backend !== "tmux" || !session.record.backendSessionId)
+            return;
+        if (this.config.ptyFactory && !this.config.tmuxCapturePane)
+            return;
+        const capturePane = this.config.tmuxCapturePane || captureTmuxPaneHistory;
+        const captured = capturePane(session.record.backendSessionId, this.config.maxBufferChars);
+        if (!captured)
+            return;
+        session.rollingBuffer = capturedPaneToDisplayBuffer(captured, this.config.maxBufferChars);
+    }
+    sessionDirectory() {
+        return this.config.sessionDir
+            || join(this.config.baseWorkdir, ".akemon", "agents", this.config.agentName, "workbench", "sessions");
+    }
+    relativeSessionPath(absolutePath) {
+        const rel = relative(this.config.baseWorkdir, absolutePath);
+        if (!rel || rel.startsWith("..") || isAbsolute(rel))
+            return absolutePath;
+        return rel;
+    }
+    absoluteSessionPath(storedPath) {
+        return isAbsolute(storedPath) ? storedPath : join(this.config.baseWorkdir, storedPath);
+    }
+    resolveBackend(kind) {
+        return kind === "tmux" ? TMUX_WORKBENCH_BACKEND : DIRECT_PTY_WORKBENCH_BACKEND;
+    }
+    async resolvePtyFactory() {
+        if (this.config.ptyFactory)
+            return this.config.ptyFactory;
+        const pty = await import("node-pty");
+        return (command, args, options) => pty.spawn(command, args, options);
+    }
+    writeLog(session, event) {
+        try {
+            appendFileSync(this.absoluteSessionPath(session.record.logPath), `${JSON.stringify(redactSecrets({
+                schemaVersion: 1,
+                ts: new Date().toISOString(),
+                sessionId: session.record.sessionId,
+                ...event,
+            }))}\n`);
+        }
+        catch (error) {
+            logBestEffortError("workbench log append", error);
+        }
+    }
+    writeMetadata(record) {
+        try {
+            const file = join(this.sessionDirectory(), `${safeWorkbenchSessionFilename(record.sessionId)}.json`);
+            writeFileSync(file, `${JSON.stringify(redactSecrets(record), null, 2)}\n`);
+        }
+        catch (error) {
+            logBestEffortError("workbench metadata write", error);
+        }
+    }
+    readMetadataFile(file) {
+        try {
+            const parsed = JSON.parse(readFileSync(file, "utf8"));
+            if (!parsed || parsed.schemaVersion !== 1 || typeof parsed.sessionId !== "string")
+                return null;
+            return parsed;
+        }
+        catch (error) {
+            logBestEffortError("workbench metadata read", error);
+            return null;
+        }
+    }
+    readTailFromLog(record) {
+        try {
+            const file = this.absoluteSessionPath(record.logPath);
+            if (!existsSync(file))
+                return "";
+            const chunks = [];
+            let recoveredChars = 0;
+            const lines = this.readLogTailText(file).split(/\r?\n/);
+            for (let index = lines.length - 1; index >= 0; index -= 1) {
+                const line = lines[index];
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    if (event?.type === "output" && typeof event.data === "string") {
+                        chunks.push(event.data);
+                        recoveredChars += event.data.length;
+                        if (recoveredChars >= this.config.maxBufferChars)
+                            break;
+                    }
+                }
+                catch {
+                    // Ignore corrupt log lines; Workbench logs are best-effort observability.
+                }
+            }
+            let tail = "";
+            for (let index = chunks.length - 1; index >= 0; index -= 1) {
+                tail = appendRollingBuffer(tail, chunks[index], this.config.maxBufferChars);
+            }
+            return tail;
+        }
+        catch (error) {
+            logBestEffortError("workbench log tail read", error);
+            return "";
+        }
+    }
+    readLogTailText(file) {
+        const stats = statSync(file);
+        if (stats.size <= 0)
+            return "";
+        const readLimit = Math.min(Math.max(this.config.maxBufferChars * LOG_TAIL_READ_MULTIPLIER, LOG_TAIL_MIN_READ_BYTES), LOG_TAIL_MAX_READ_BYTES);
+        const readBytes = Math.min(stats.size, readLimit);
+        const start = stats.size - readBytes;
+        const fd = openSync(file, "r");
+        try {
+            const buffer = Buffer.allocUnsafe(readBytes);
+            const bytesRead = readSync(fd, buffer, 0, readBytes, start);
+            let text = buffer.subarray(0, bytesRead).toString("utf8");
+            if (start > 0) {
+                const firstLineEnd = text.indexOf("\n");
+                text = firstLineEnd >= 0 ? text.slice(firstLineEnd + 1) : "";
+            }
+            return text;
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    scheduleForceKill(session, reason) {
+        if (session.forceKillTimer || session.record.endedAt)
+            return;
+        session.forceKillTimer = setTimeout(() => {
+            session.forceKillTimer = undefined;
+            if (session.record.endedAt)
+                return;
+            try {
+                this.writeLog(session, { type: "force_kill", reason, signal: "SIGKILL" });
+                this.killSessionPty(session, "kill");
+            }
+            catch (error) {
+                logBestEffortError("workbench force kill", error);
+            }
+        }, this.config.forceKillAfterMs);
+        session.forceKillTimer.unref?.();
+    }
+    evictCompletedSessions() {
+        const completed = Array.from(this.sessions.values())
+            .filter((session) => session.record.status !== "running")
+            .sort((left, right) => left.record.updatedAt.localeCompare(right.record.updatedAt));
+        const overflow = completed.length - this.config.maxCompletedSessions;
+        if (overflow <= 0)
+            return;
+        for (const session of completed.slice(0, overflow)) {
+            this.sessions.delete(session.record.sessionId);
+            if (this.activeSessionId === session.record.sessionId)
+                this.activeSessionId = "";
+        }
+    }
+    emitStreamEvent(event) {
+        for (const subscriber of this.subscribers) {
+            try {
+                subscriber(event);
+            }
+            catch (error) {
+                logBestEffortError("workbench stream subscriber", error);
+            }
+        }
+    }
+    killSessionPty(session, mode) {
+        session.backend.stop(session, mode, this.config.runtime || getRuntimePlatform());
+    }
+}
+function resolveDefaultWorkbenchBackend(config) {
+    if (config.backend)
+        return config.backend;
+    const configured = normalizeOptionalWorkbenchBackendKind(process.env.AKEMON_WORKBENCH_BACKEND);
+    if (configured)
+        return configured;
+    if (config.ptyFactory)
+        return "direct-pty";
+    const runtime = config.runtime || getRuntimePlatform();
+    if (runtime.platform !== "win32" && isTmuxAvailable())
+        return "tmux";
+    return "direct-pty";
+}
+function normalizeOptionalWorkbenchBackendKind(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (normalized === "direct" || normalized === "direct-pty" || normalized === "pty")
+        return "direct-pty";
+    if (normalized === "tmux")
+        return "tmux";
+    throw new Error("Invalid Workbench backend: expected direct-pty or tmux");
+}
+function isTmuxAvailable() {
+    try {
+        execFileSync("tmux", ["-V"], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assertTmuxAvailable() {
+    if (!isTmuxAvailable()) {
+        throw new Error("tmux Workbench backend requires tmux to be installed and available on PATH");
+    }
+}
+function hasTmuxSession(sessionName) {
+    try {
+        execFileSync("tmux", ["has-session", "-t", sessionName], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function captureTmuxPaneHistory(sessionName, maxChars) {
+    try {
+        const maxBuffer = Math.min(Math.max(maxChars * TMUX_CAPTURE_BUFFER_MULTIPLIER, TMUX_CAPTURE_MIN_BUFFER_BYTES), TMUX_CAPTURE_MAX_BUFFER_BYTES);
+        return execFileSync("tmux", [
+            "capture-pane",
+            "-p",
+            "-S",
+            "-",
+            "-t",
+            sessionName,
+        ], {
+            encoding: "utf8",
+            maxBuffer,
+        });
+    }
+    catch (error) {
+        logBestEffortError("workbench tmux capture-pane", error);
+        return "";
+    }
+}
+function capturedPaneToDisplayBuffer(captured, maxBufferChars) {
+    if (!captured)
+        return "";
+    const display = captured.endsWith("\n") ? captured : `${captured}\n`;
+    return appendRollingBuffer("", display, maxBufferChars);
+}
+function killPtyProcess(pty, mode, runtime) {
+    if (!pty)
+        return;
+    if (runtime.platform === "win32") {
+        pty.kill();
+        return;
+    }
+    pty.kill(mode === "kill" ? "SIGKILL" : "SIGTERM");
+}
+export function resolveWorkbenchCommand(request, runtime = getRuntimePlatform()) {
+    const args = normalizeStringArray(request.args, "args");
+    const command = normalizeOptionalString(request.command);
+    switch (request.tool) {
+        case "codex": {
+            const resolvedCommand = command || "codex";
+            return {
+                command: resolvedCommand,
+                args: commandLooksLikeCodex(resolvedCommand) ? withCodexNoAltScreen(args) : args,
+            };
+        }
+        case "claude":
+            return { command: command || "claude", args };
+        case "cursor":
+            return { command: command || "agent", args };
+        case "shell":
+            return { command: command || runtime.defaultShell, args };
+        case "custom":
+            if (!command)
+                throw new Error("Custom Workbench sessions require command");
+            return { command, args };
+        default:
+            throw new Error(`Invalid Workbench tool: ${String(request.tool)}`);
+    }
+}
+function commandLooksLikeCodex(command) {
+    const basename = command.split(/[\\/]/).pop() || command;
+    return basename === "codex";
+}
+function withCodexNoAltScreen(args) {
+    if (args.includes("--no-alt-screen"))
+        return args;
+    return ["--no-alt-screen", ...args];
+}
+export function normalizeWorkbenchTool(value) {
+    const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+    if (normalized === "codex"
+        || normalized === "claude"
+        || normalized === "cursor"
+        || normalized === "shell"
+        || normalized === "custom") {
+        return normalized;
+    }
+    throw new Error("Invalid tool: expected codex, claude, cursor, shell, or custom");
+}
+export function normalizeWorkbenchStartRequest(body) {
+    return {
+        tool: normalizeWorkbenchTool(body?.tool),
+        command: normalizeOptionalString(body?.command),
+        args: normalizeStringArray(body?.args, "args"),
+        workdir: normalizeOptionalString(body?.workdir),
+        allowOutsideWorkdir: body?.allowOutsideWorkdir === true,
+        cols: normalizeOptionalPositiveInt(body?.cols, "cols"),
+        rows: normalizeOptionalPositiveInt(body?.rows, "rows"),
+        initialInput: normalizeOptionalRawString(body?.initialInput, "initialInput"),
+        label: normalizeOptionalString(body?.label),
+        inputMode: normalizeOptionalWorkbenchInputMode(body?.inputMode),
+    };
+}
+export function normalizeWorkbenchInputRequest(body) {
+    const input = typeof body?.input === "string" ? body.input : "";
+    if (!input)
+        throw new Error("Missing required string field: input");
+    return {
+        input,
+        inputMode: normalizeOptionalWorkbenchInputMode(body?.inputMode),
+    };
+}
+export function normalizeWorkbenchInputMode(value) {
+    if (value === "line" || value === "tui")
+        return value;
+    throw new Error("Invalid inputMode: expected line or tui");
+}
+function normalizeOptionalWorkbenchInputMode(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    return normalizeWorkbenchInputMode(value);
+}
+export function normalizeWorkbenchResizeRequest(body) {
+    return {
+        cols: normalizeRequiredPositiveInt(body?.cols, "cols"),
+        rows: normalizeRequiredPositiveInt(body?.rows, "rows"),
+    };
+}
+function normalizeOptionalString(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error("Invalid string field");
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function normalizeOptionalRawString(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error(`Invalid ${field}: expected string`);
+    return value.length > 0 ? value : undefined;
+}
+function normalizeStringArray(value, field) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error(`Invalid ${field}: expected string array`);
+    return value.map((item) => {
+        if (typeof item !== "string")
+            throw new Error(`Invalid ${field}: expected string array`);
+        return item;
+    });
+}
+function normalizeOptionalPositiveInt(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    return normalizeRequiredPositiveInt(value, field);
+}
+function normalizeRequiredPositiveInt(value, field) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`Invalid ${field}: expected positive integer`);
+    }
+    return value;
+}
+function clampTerminalDimension(value, fallback) {
+    if (!Number.isInteger(value) || (value || 0) <= 0)
+        return fallback;
+    return Math.min(Math.max(value || fallback, 10), 500);
+}
+function compareSessionRecordNewestFirst(left, right) {
+    return sessionRecordActivityKey(right).localeCompare(sessionRecordActivityKey(left))
+        || right.sessionId.localeCompare(left.sessionId);
+}
+function compareSessionRecordOldestFirst(left, right) {
+    return sessionRecordActivityKey(left).localeCompare(sessionRecordActivityKey(right))
+        || left.sessionId.localeCompare(right.sessionId);
+}
+function sessionRecordActivityKey(record) {
+    return record.updatedAt || record.startedAt || record.sessionId;
+}
+function appendRollingBuffer(current, chunk, maxChars) {
+    const next = current + chunk;
+    if (next.length <= maxChars)
+        return next;
+    return next.slice(-maxChars);
+}
+function safeWorkbenchSessionFilename(sessionId) {
+    return sessionId.replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
+function defaultWorkbenchInputMode(tool) {
+    return DEFAULT_TUI_INPUT_TOOLS.has(tool) ? "tui" : "line";
+}
+function writeInputToPty(session, input, inputMode = session.record.inputMode) {
+    const pty = session.pty;
+    if (!pty)
+        throw new Error(`Workbench session ${session.record.sessionId} is not attached`);
+    const splitSubmit = splitTuiSubmitInput(inputMode, input);
+    if (!splitSubmit) {
+        pty.write(input);
+        return;
+    }
+    pty.write(formatTuiSubmitText(splitSubmit.text));
+    setTimeout(() => {
+        if (session.record.status !== "running")
+            return;
+        try {
+            pty.write(splitSubmit.submit);
+        }
+        catch (err) {
+            logBestEffortError("workbench delayed submit write", err);
+        }
+    }, SPLIT_SUBMIT_DELAY_MS);
+}
+function splitTuiSubmitInput(inputMode, input) {
+    if (inputMode !== "tui")
+        return null;
+    const match = input.match(/(\r\n|\r|\n)$/);
+    if (!match)
+        return null;
+    const submit = match[1];
+    const text = input.slice(0, -submit.length);
+    if (!text)
+        return null;
+    return { text, submit };
+}
+function formatTuiSubmitText(text) {
+    if (text.includes("\x1b"))
+        return text;
+    return `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+}
+function summarizeOwnerInput(input) {
+    const preview = input.replace(/\r\n|\r|\n/g, "\\n").slice(0, 160);
+    return redactSecrets({
+        chars: input.length,
+        bytes: Buffer.byteLength(input, "utf8"),
+        lines: input ? input.split(/\r\n|\r|\n/).length : 0,
+        preview,
+        truncated: input.replace(/\r\n|\r|\n/g, "\\n").length > 160,
+    });
+}
+export function buildWorkbenchChildEnvironment(sourceEnv, options = {}) {
+    const allowlist = new Set(options.allowlist || DEFAULT_WORKBENCH_ENV_ALLOWLIST);
+    const entries = Object.entries(sourceEnv)
+        .filter((entry) => typeof entry[1] === "string")
+        .filter(([key, value]) => options.filter ? options.filter(key, value) : allowlist.has(key))
+        .sort(([left], [right]) => left.localeCompare(right));
+    return {
+        env: Object.fromEntries(entries),
+        transmittedEnvKeys: entries.map(([key]) => key),
+    };
+}
+function formatCommandLineDisplay(command, args) {
+    return [command, ...args].map(quoteCommandLinePart).join(" ");
+}
+function quoteCommandLinePart(part) {
+    if (/^[a-zA-Z0-9_./:=@+-]+$/.test(part))
+        return part;
+    return JSON.stringify(part);
+}