agl 1.0.17 → 21.0.2

package/dist_ts/classes.terminalmanager.js

@@ -0,0 +1,981 @@
+import * as plugins from './plugins.js';
+import { createSanitizedRuntimeEnvironment } from './functions.runtimeenvironment.js';
+const maxTerminals = 32;
+const maxTerminalsPerProject = 8;
+const maxScrollbackBytes = 2 * 1024 * 1024;
+const maxPtyCaptureBytes = 4 * 1024 * 1024;
+const maxInputBytes = 8 * 1024;
+const maxOutputFrameBytes = 64 * 1024;
+const maxPeersPerTerminal = 32;
+const maxPendingControlOperations = 256;
+const defaultCleanupTimeoutMs = 10_000;
+const normalizeError = (errorArg) => errorArg instanceof Error ? errorArg : new Error(String(errorArg));
+const toTerminalDto = (terminalArg) => ({
+    ...terminalArg,
+    id: { ...terminalArg.id },
+});
+const appendBoundedChunk = (slabsArg, currentBytesArg, chunkArg) => {
+    if (chunkArg.byteLength === 0)
+        return currentBytesArg;
+    let sourceOffset = 0;
+    let currentBytes = currentBytesArg;
+    if (chunkArg.byteLength >= maxScrollbackBytes) {
+        slabsArg.splice(0, slabsArg.length);
+        sourceOffset = chunkArg.byteLength - maxScrollbackBytes;
+        currentBytes = 0;
+    }
+    while (sourceOffset < chunkArg.byteLength) {
+        let slab = slabsArg.at(-1);
+        if (!slab || slab.end >= slab.buffer.byteLength) {
+            slab = {
+                buffer: Buffer.allocUnsafe(maxOutputFrameBytes),
+                start: 0,
+                end: 0,
+            };
+            slabsArg.push(slab);
+        }
+        const copyBytes = Math.min(chunkArg.byteLength - sourceOffset, slab.buffer.byteLength - slab.end);
+        chunkArg.copy(slab.buffer, slab.end, sourceOffset, sourceOffset + copyBytes);
+        slab.end += copyBytes;
+        sourceOffset += copyBytes;
+        currentBytes += copyBytes;
+    }
+    let excess = currentBytes - maxScrollbackBytes;
+    while (excess > 0) {
+        const first = slabsArg[0];
+        const firstBytes = first.end - first.start;
+        if (firstBytes <= excess) {
+            slabsArg.shift();
+            currentBytes -= firstBytes;
+            excess -= firstBytes;
+        }
+        else {
+            first.start += excess;
+            currentBytes -= excess;
+            excess = 0;
+        }
+    }
+    return currentBytes;
+};
+const appendOutput = (outputArg, chunkArg) => {
+    if (chunkArg.byteLength === 0)
+        return;
+    outputArg.end += chunkArg.byteLength;
+    outputArg.bytes = appendBoundedChunk(outputArg.slabs, outputArg.bytes, chunkArg);
+    outputArg.start = outputArg.end - outputArg.bytes;
+};
+const validateExecutable = async (candidateArg, platformArg) => {
+    const pathApi = platformArg === 'win32' ? plugins.path.win32 : plugins.path.posix;
+    if (!pathApi.isAbsolute(candidateArg)) {
+        throw new Error('The terminal shell executable must be an absolute path.');
+    }
+    const executable = await plugins.fs.promises.realpath(candidateArg);
+    const stats = await plugins.fs.promises.stat(executable);
+    if (!stats.isFile())
+        throw new Error('The terminal shell executable is not a file.');
+    if (platformArg !== 'win32') {
+        await plugins.fs.promises.access(executable, plugins.fs.constants.X_OK);
+    }
+    return executable;
+};
+export const resolveControllerTerminalShell = async (environmentArg = process.env, platformArg = process.platform, validateExecutableArg = validateExecutable) => {
+    const environment = createSanitizedRuntimeEnvironment(environmentArg);
+    if (platformArg === 'win32') {
+        const candidates = [];
+        if (environmentArg.COMSPEC && plugins.path.win32.isAbsolute(environmentArg.COMSPEC)) {
+            candidates.push(environmentArg.COMSPEC);
+        }
+        const systemRoot = environmentArg.SystemRoot ?? environmentArg.SYSTEMROOT;
+        if (systemRoot && plugins.path.win32.isAbsolute(systemRoot)) {
+            candidates.push(plugins.path.win32.join(systemRoot, 'System32', 'cmd.exe'));
+        }
+        for (const candidate of [...new Set(candidates)]) {
+            try {
+                const executable = await validateExecutableArg(candidate, platformArg);
+                delete environment.SHELL;
+                environment.COMSPEC = executable;
+                return { executable, args: [], environment };
+            }
+            catch {
+                // Try the trusted SystemRoot fallback before failing closed.
+            }
+        }
+        throw new Error('No trusted Windows terminal shell executable is available.');
+    }
+    const candidates = [
+        ...(environmentArg.SHELL && plugins.path.posix.isAbsolute(environmentArg.SHELL)
+            ? [environmentArg.SHELL]
+            : []),
+        '/bin/sh',
+    ];
+    for (const candidate of [...new Set(candidates)]) {
+        try {
+            const executable = await validateExecutableArg(candidate, platformArg);
+            delete environment.COMSPEC;
+            environment.SHELL = executable;
+            return { executable, args: [], environment };
+        }
+        catch {
+            // Fall through to /bin/sh, then fail closed.
+        }
+    }
+    throw new Error('No trusted POSIX terminal shell executable is available.');
+};
+const waitUntil = async (promiseArg, deadlineAtArg) => {
+    const remainingMs = deadlineAtArg - Date.now();
+    if (remainingMs <= 0)
+        throw new Error('Terminal cleanup exceeded its deadline.');
+    let timeout;
+    try {
+        await Promise.race([
+            promiseArg,
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => reject(new Error('Terminal cleanup exceeded its deadline.')), remainingMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+};
+export class ControllerTerminalManager {
+    options;
+    ptySpawner;
+    resolveShell;
+    cleanupTimeoutMs;
+    entries = new Map();
+    projectStates = new Map();
+    activeRetirements = new Set();
+    pendingRemovalCleanups = new Map();
+    state = 'new';
+    shell;
+    initPromise;
+    closePromise;
+    pendingCreates = 0;
+    pendingCreatesByProject = new Map();
+    peerGeneration = 0;
+    constructor(options) {
+        this.options = options;
+        this.ptySpawner = options.ptySpawner ?? new plugins.smartshell.Smartshell({
+            executor: 'sh',
+            sourceFilePaths: [],
+        });
+        this.resolveShell = options.resolveShell ?? (() => resolveControllerTerminalShell());
+        this.cleanupTimeoutMs = options.cleanupTimeoutMs ?? defaultCleanupTimeoutMs;
+        if (!Number.isSafeInteger(this.cleanupTimeoutMs)
+            || this.cleanupTimeoutMs < 1
+            || this.cleanupTimeoutMs > 60_000) {
+            throw new Error('cleanupTimeoutMs must be an integer between 1 and 60000.');
+        }
+    }
+    async init() {
+        if (this.state === 'open')
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        if (this.state !== 'new')
+            throw new Error('The terminal manager cannot be initialized now.');
+        const initPromise = (async () => {
+            const [shell] = await Promise.all([
+                this.resolveShell(),
+                this.ptySpawner.ensurePtySupport(),
+            ]);
+            if (this.state !== 'new')
+                throw new Error('Terminal manager initialization was cancelled.');
+            this.shell = shell;
+            this.state = 'open';
+        })();
+        this.initPromise = initPromise;
+        try {
+            await initPromise;
+        }
+        finally {
+            if (this.initPromise === initPromise)
+                this.initPromise = undefined;
+        }
+    }
+    async listTerminals(projectIdArg) {
+        return this.runProjectOperation(projectIdArg, async () => {
+            await this.options.resolveProjectDirectory(projectIdArg);
+            return [...this.entries.values()]
+                .filter((entry) => entry.projectId === projectIdArg && entry.finalState !== 'exited')
+                .map((entry) => toTerminalDto(entry.terminal));
+        });
+    }
+    async createTerminal(projectIdArg, titleArg) {
+        return this.runProjectOperation(projectIdArg, async () => {
+            this.reserveCreate(projectIdArg);
+            try {
+                const directory = await this.options.resolveProjectDirectory(projectIdArg);
+                const shell = this.requireShell();
+                const terminalNativeId = this.createTerminalId();
+                return this.spawnTerminal({
+                    projectId: projectIdArg,
+                    terminalNativeId,
+                    title: titleArg ?? plugins.path.basename(shell.executable),
+                    command: shell.executable,
+                    args: [...shell.args],
+                    cwd: directory,
+                    environment: { ...shell.environment },
+                });
+            }
+            finally {
+                this.releaseCreate(projectIdArg);
+            }
+        });
+    }
+    async resolveTerminalResourceMetadata(projectIdArg, titleArg) {
+        const directory = await this.options.resolveProjectDirectory(projectIdArg);
+        const shell = this.requireShell();
+        return {
+            title: titleArg ?? plugins.path.basename(shell.executable),
+            terminal: {
+                command: shell.executable,
+                args: [...shell.args],
+                cwd: directory,
+                stoppedAt: new Date(),
+            },
+        };
+    }
+    async startTerminalResource(resourceArg) {
+        if (resourceArg.kind !== 'terminal' || !resourceArg.terminal) {
+            throw new Error('The resource is not a terminal.');
+        }
+        const terminal = resourceArg.terminal;
+        return this.runProjectOperation(resourceArg.projectId, async () => {
+            this.reserveCreate(resourceArg.projectId);
+            try {
+                if (this.entries.has(resourceArg.id)) {
+                    throw new Error('The terminal resource is already running.');
+                }
+                const directory = await this.options.resolveProjectDirectory(resourceArg.projectId);
+                if (directory !== terminal.cwd) {
+                    throw new Error('The terminal resource project directory binding changed.');
+                }
+                const shell = this.requireShell();
+                return this.spawnTerminal({
+                    projectId: resourceArg.projectId,
+                    terminalNativeId: resourceArg.id,
+                    title: resourceArg.title,
+                    command: terminal.command,
+                    args: [...terminal.args],
+                    cwd: directory,
+                    environment: { ...shell.environment },
+                });
+            }
+            finally {
+                this.releaseCreate(resourceArg.projectId);
+            }
+        });
+    }
+    async stopTerminalResource(projectIdArg, resourceIdArg) {
+        const entry = this.entries.get(resourceIdArg);
+        if (!entry || entry.projectId !== projectIdArg)
+            return;
+        await this.runProjectOperation(projectIdArg, async () => {
+            await this.closeEntry(entry, Date.now() + this.cleanupTimeoutMs);
+        });
+    }
+    isTerminalRunning(projectIdArg, resourceIdArg) {
+        const entry = this.entries.get(resourceIdArg);
+        return entry?.projectId === projectIdArg && entry.finalState === 'running';
+    }
+    async spawnTerminal(inputArg) {
+        let entry;
+        const output = {
+            slabs: [],
+            start: 0,
+            end: 0,
+            bytes: 0,
+        };
+        const execution = await this.ptySpawner.execSpawnStreamingInteractiveControlPty(inputArg.command, [...inputArg.args], {
+            cwd: inputArg.cwd,
+            env: { ...inputArg.environment },
+            maxBuffer: maxPtyCaptureBytes,
+            ptyCols: 120,
+            ptyRows: 30,
+            ptyTerm: 'xterm-256color',
+            onData: (chunkArg) => {
+                const chunk = Buffer.from(chunkArg, 'utf8');
+                if (entry)
+                    this.appendOutput(entry, chunk);
+                else
+                    appendOutput(output, chunk);
+            },
+        });
+        let resolveRootExit;
+        const rootExitPromise = new Promise((resolve) => {
+            resolveRootExit = resolve;
+        });
+        const createdEntry = {
+            projectId: inputArg.projectId,
+            terminal: {
+                id: { harnessId: 'controller', nativeId: inputArg.terminalNativeId },
+                title: inputArg.title,
+                command: inputArg.command,
+                cwd: inputArg.cwd,
+            },
+            execution,
+            peers: new Map(),
+            sizesByPeer: new Map(),
+            output,
+            controlQueue: Promise.resolve(),
+            pendingControlOperations: 0,
+            sizeRevision: 0,
+            sizeReconciliationActive: false,
+            closing: false,
+            finalState: 'running',
+            rootExitPromise,
+            resolveRootExit,
+        };
+        entry = createdEntry;
+        this.entries.set(inputArg.terminalNativeId, createdEntry);
+        createdEntry.exitSubscription = execution.ptyProcess.onExit((eventArg) => this.confirmRootExit(createdEntry, eventArg.exitCode));
+        if (createdEntry.finalState === 'exited')
+            createdEntry.exitSubscription.dispose();
+        void execution.finalPromise.then((resultArg) => this.confirmRootExit(createdEntry, resultArg.exitCode), (errorArg) => {
+            if (createdEntry.finalState === 'running')
+                createdEntry.finalState = 'failed-unconfirmed';
+            createdEntry.finalError = normalizeError(errorArg);
+        });
+        if (createdEntry.finalState === 'exited' || this.state !== 'open') {
+            await this.closeEntry(createdEntry, Date.now() + this.cleanupTimeoutMs);
+            throw new Error('The terminal exited while it was being created.');
+        }
+        const projectState = this.projectState(inputArg.projectId);
+        if (projectState.retiring || projectState.retired) {
+            await this.closeEntry(createdEntry, Date.now() + this.cleanupTimeoutMs);
+            throw new Error('The project stopped accepting terminal operations.');
+        }
+        this.options.onTerminalsChanged(inputArg.projectId);
+        return toTerminalDto(createdEntry.terminal);
+    }
+    async renameTerminal(projectIdArg, terminalIdArg, titleArg) {
+        const entry = this.requireEntry(projectIdArg, terminalIdArg);
+        return this.runProjectOperation(projectIdArg, () => (this.runEntryControl(entry, async () => {
+            this.assertEntryRunning(entry);
+            entry.terminal.title = titleArg;
+            this.options.onTerminalsChanged(projectIdArg);
+            return toTerminalDto(entry.terminal);
+        })));
+    }
+    async renameTerminalResource(projectIdArg, terminalIdArg, titleArg) {
+        const entry = this.entries.get(terminalIdArg);
+        if (!entry || entry.projectId !== projectIdArg || entry.finalState === 'exited')
+            return;
+        await this.runProjectOperation(projectIdArg, () => (this.runEntryControl(entry, async () => {
+            this.assertEntryRunning(entry);
+            entry.terminal.title = titleArg;
+            this.options.onTerminalsChanged(projectIdArg);
+        })));
+    }
+    async removeTerminal(projectIdArg, terminalIdArg) {
+        const entry = this.entries.get(terminalIdArg);
+        return this.runProjectOperation(projectIdArg, async () => {
+            if (!entry || entry.projectId !== projectIdArg)
+                return false;
+            await this.closeEntry(entry, Date.now() + this.cleanupTimeoutMs);
+            return true;
+        });
+    }
+    async attach(peerIdArg, projectIdArg, terminalIdArg, isPeerConnectedArg = () => true) {
+        const entry = this.requireEntry(projectIdArg, terminalIdArg);
+        return this.runProjectOperation(projectIdArg, () => (this.runEntryControl(entry, async () => {
+            this.assertEntryRunning(entry);
+            if (!isPeerConnectedArg())
+                throw new Error('The terminal peer disconnected before attach.');
+            const previous = entry.peers.get(peerIdArg);
+            if (previous) {
+                this.detachPeerState(entry, previous);
+                if (previous.deliveryPromise) {
+                    await waitUntil(previous.deliveryPromise.catch(() => undefined), Date.now() + this.cleanupTimeoutMs).catch(() => undefined);
+                }
+                await this.applyMinimumSizeUntilStable(entry);
+            }
+            if (entry.peers.size >= maxPeersPerTerminal) {
+                throw new Error(`At most ${maxPeersPerTerminal} peers may attach to one terminal.`);
+            }
+            const peer = {
+                peerId: peerIdArg,
+                generation: ++this.peerGeneration,
+                cursor: entry.output.start,
+                detaching: false,
+                finalizing: false,
+            };
+            entry.peers.set(peerIdArg, peer);
+            try {
+                await this.schedulePeerDelivery(entry, peer, true);
+                if (!isPeerConnectedArg() || entry.peers.get(peerIdArg) !== peer) {
+                    throw new Error('The terminal peer disconnected during attach.');
+                }
+            }
+            catch (errorArg) {
+                this.detachPeerState(entry, peer);
+                throw errorArg;
+            }
+        })));
+    }
+    async detach(peerIdArg, projectIdArg, terminalIdArg) {
+        const entry = this.entries.get(terminalIdArg);
+        return this.runProjectOperation(projectIdArg, () => {
+            if (!entry || entry.projectId !== projectIdArg)
+                return Promise.resolve();
+            return this.runEntryControl(entry, async () => {
+                const peer = entry.peers.get(peerIdArg);
+                if (!peer)
+                    return;
+                this.detachPeerState(entry, peer);
+                if (peer.deliveryPromise) {
+                    await waitUntil(peer.deliveryPromise.catch(() => undefined), Date.now() + this.cleanupTimeoutMs).catch(() => undefined);
+                }
+                await this.applyMinimumSizeUntilStable(entry);
+            });
+        });
+    }
+    async detachPeer(peerIdArg) {
+        const reconciliations = [];
+        for (const entry of this.entries.values()) {
+            const peer = entry.peers.get(peerIdArg);
+            if (!peer)
+                continue;
+            this.detachPeerState(entry, peer);
+            reconciliations.push(this.requestSizeReconciliation(entry));
+        }
+        await Promise.allSettled(reconciliations);
+    }
+    async input(peerIdArg, projectIdArg, terminalIdArg, dataArg) {
+        if (dataArg.byteLength > maxInputBytes) {
+            throw new Error('Terminal input exceeds the per-message limit.');
+        }
+        const entry = this.requireEntry(projectIdArg, terminalIdArg);
+        return this.runProjectOperation(projectIdArg, () => (this.runEntryControl(entry, async () => {
+            this.assertAttached(entry, peerIdArg);
+            await entry.execution.sendInput(dataArg.toString('utf8'));
+        })));
+    }
+    async resize(peerIdArg, projectIdArg, terminalIdArg, rowsArg, colsArg) {
+        const entry = this.requireEntry(projectIdArg, terminalIdArg);
+        return this.runProjectOperation(projectIdArg, () => (this.runEntryControl(entry, async () => {
+            this.assertAttached(entry, peerIdArg);
+            entry.sizesByPeer.set(peerIdArg, { rows: rowsArg, cols: colsArg });
+            entry.sizeRevision += 1;
+            await this.applyMinimumSizeUntilStable(entry);
+        })));
+    }
+    async retireProject(projectIdArg, retireArg) {
+        if (this.state !== 'open')
+            throw new Error('The terminal manager is not accepting operations.');
+        const projectState = this.projectState(projectIdArg);
+        if (projectState.retiring || projectState.retired) {
+            throw new Error('The project is already leaving terminal admission.');
+        }
+        projectState.retiring = true;
+        const deadlineAt = Date.now() + this.cleanupTimeoutMs;
+        const retirementPromise = (async () => {
+            await this.closeProjectEntries(projectIdArg, deadlineAt);
+            await waitUntil(this.waitForProjectDrain(projectState), deadlineAt);
+            await this.closeProjectEntries(projectIdArg, deadlineAt);
+            if ([...this.pendingRemovalCleanups.values()].includes(projectIdArg)) {
+                await waitUntil(this.waitForRemovalCleanups(projectIdArg), deadlineAt);
+            }
+            const retired = await retireArg();
+            projectState.retired = retired;
+            return retired;
+        })();
+        projectState.retirementPromise = retirementPromise;
+        this.activeRetirements.add(retirementPromise);
+        try {
+            return await retirementPromise;
+        }
+        finally {
+            this.activeRetirements.delete(retirementPromise);
+            if (projectState.retirementPromise === retirementPromise) {
+                projectState.retirementPromise = undefined;
+            }
+            projectState.retiring = false;
+            this.pruneProjectState(projectIdArg, projectState);
+        }
+    }
+    async closeAll() {
+        if (this.state === 'closed')
+            return;
+        if (this.closePromise)
+            return this.closePromise;
+        this.state = 'closing';
+        const deadlineAt = Date.now() + this.cleanupTimeoutMs;
+        const closePromise = (async () => {
+            const initialClosures = [...this.entries.values()]
+                .map((entry) => this.closeEntry(entry, deadlineAt));
+            const coordination = Promise.all([
+                Promise.allSettled(initialClosures).then(() => undefined),
+                this.waitForAllProjectDrains(),
+                Promise.allSettled([...this.activeRetirements]).then(() => undefined),
+            ]).then(() => this.waitForRemovalCleanups());
+            let coordinationError;
+            try {
+                await waitUntil(coordination, deadlineAt);
+            }
+            catch (errorArg) {
+                coordinationError = errorArg;
+            }
+            const finalOutcomes = await Promise.allSettled([...this.entries.values()].map((entry) => this.closeEntry(entry, deadlineAt)));
+            let cleanupError;
+            if (this.pendingRemovalCleanups.size > 0) {
+                try {
+                    await waitUntil(this.waitForRemovalCleanups(), deadlineAt);
+                }
+                catch (errorArg) {
+                    cleanupError = errorArg;
+                    if (this.entries.size === 0)
+                        this.pendingRemovalCleanups.clear();
+                }
+            }
+            const activeOperations = [...this.projectStates.values()]
+                .reduce((sum, projectState) => sum + projectState.activeOperations, 0);
+            const errors = [];
+            if (this.entries.size > 0) {
+                errors.push(new Error('One or more terminal roots remain unconfirmed.'));
+            }
+            if (activeOperations > 0) {
+                errors.push(new Error('One or more terminal operations remain active.'));
+            }
+            if (this.activeRetirements.size > 0) {
+                errors.push(new Error('One or more project retirements remain active.'));
+            }
+            if (this.pendingRemovalCleanups.size > 0) {
+                errors.push(new Error('One or more terminal layout cleanups remain active.'));
+            }
+            if (errors.length > 0 && coordinationError)
+                errors.push(coordinationError);
+            if (errors.length > 0 && cleanupError)
+                errors.push(cleanupError);
+            if (this.entries.size > 0) {
+                errors.push(...finalOutcomes.flatMap((outcome) => (outcome.status === 'rejected' ? [outcome.reason] : [])));
+            }
+            if (errors.length > 0) {
+                throw new AggregateError(errors, 'The terminal manager did not close every PTY.');
+            }
+            this.state = 'closed';
+        })();
+        this.closePromise = closePromise;
+        try {
+            await closePromise;
+        }
+        finally {
+            if (this.closePromise === closePromise)
+                this.closePromise = undefined;
+        }
+    }
+    projectState(projectIdArg) {
+        let state = this.projectStates.get(projectIdArg);
+        if (!state) {
+            const newState = {
+                activeOperations: 0,
+                retiring: false,
+                retired: false,
+            };
+            this.projectStates.set(projectIdArg, newState);
+            state = newState;
+        }
+        return state;
+    }
+    pruneProjectState(projectIdArg, projectStateArg) {
+        if (this.projectStates.get(projectIdArg) === projectStateArg
+            && projectStateArg.activeOperations === 0
+            && !projectStateArg.retiring
+            && !projectStateArg.retirementPromise) {
+            this.projectStates.delete(projectIdArg);
+        }
+    }
+    async runProjectOperation(projectIdArg, operationArg) {
+        if (this.state !== 'open')
+            throw new Error('The terminal manager is not accepting operations.');
+        const projectState = this.projectState(projectIdArg);
+        if (projectState.retiring || projectState.retired) {
+            throw new Error('The project is not accepting terminal operations.');
+        }
+        if (projectState.activeOperations === 0) {
+            let resolveDrain;
+            projectState.drainPromise = new Promise((resolve) => {
+                resolveDrain = resolve;
+            });
+            projectState.resolveDrain = resolveDrain;
+        }
+        projectState.activeOperations += 1;
+        try {
+            return await operationArg();
+        }
+        finally {
+            projectState.activeOperations -= 1;
+            if (projectState.activeOperations === 0) {
+                projectState.resolveDrain?.();
+                projectState.resolveDrain = undefined;
+                projectState.drainPromise = undefined;
+                this.pruneProjectState(projectIdArg, projectState);
+            }
+        }
+    }
+    waitForProjectDrain(projectStateArg) {
+        return projectStateArg.drainPromise ?? Promise.resolve();
+    }
+    async waitForAllProjectDrains() {
+        await Promise.all([...this.projectStates.values()].map((state) => this.waitForProjectDrain(state)));
+    }
+    async waitForRemovalCleanups(projectIdArg) {
+        while (true) {
+            const pending = [...this.pendingRemovalCleanups.entries()]
+                .filter(([, projectId]) => projectIdArg === undefined || projectId === projectIdArg)
+                .map(([cleanup]) => cleanup);
+            if (pending.length === 0)
+                return;
+            await Promise.all(pending);
+        }
+    }
+    reserveCreate(projectIdArg) {
+        const activeForProject = [...this.entries.values()]
+            .filter((entry) => entry.projectId === projectIdArg && entry.finalState !== 'exited').length;
+        const pendingForProject = this.pendingCreatesByProject.get(projectIdArg) ?? 0;
+        if (this.entries.size + this.pendingCreates >= maxTerminals) {
+            throw new Error(`At most ${maxTerminals} controller terminals may run concurrently.`);
+        }
+        if (activeForProject + pendingForProject >= maxTerminalsPerProject) {
+            throw new Error(`At most ${maxTerminalsPerProject} terminals may run in one project.`);
+        }
+        this.pendingCreates += 1;
+        this.pendingCreatesByProject.set(projectIdArg, pendingForProject + 1);
+    }
+    releaseCreate(projectIdArg) {
+        this.pendingCreates -= 1;
+        const remaining = (this.pendingCreatesByProject.get(projectIdArg) ?? 1) - 1;
+        if (remaining <= 0)
+            this.pendingCreatesByProject.delete(projectIdArg);
+        else
+            this.pendingCreatesByProject.set(projectIdArg, remaining);
+    }
+    createTerminalId() {
+        for (let attempt = 0; attempt < 8; attempt += 1) {
+            const id = `terminal_${plugins.crypto.randomBytes(16).toString('base64url')}`;
+            if (!this.entries.has(id))
+                return id;
+        }
+        throw new Error('Unable to allocate a unique terminal identifier.');
+    }
+    requireShell() {
+        if (!this.shell || this.state !== 'open')
+            throw new Error('The terminal manager is not initialized.');
+        return this.shell;
+    }
+    requireEntry(projectIdArg, terminalIdArg) {
+        const entry = this.entries.get(terminalIdArg);
+        if (!entry || entry.projectId !== projectIdArg || entry.finalState === 'exited') {
+            throw new Error('The requested terminal does not exist in this project.');
+        }
+        return entry;
+    }
+    assertEntryRunning(entryArg) {
+        if (entryArg.closing || entryArg.finalState !== 'running') {
+            throw new Error('The terminal is not accepting operations.');
+        }
+    }
+    assertAttached(entryArg, peerIdArg) {
+        this.assertEntryRunning(entryArg);
+        const peer = entryArg.peers.get(peerIdArg);
+        if (!peer || peer.detaching)
+            throw new Error('The terminal is not attached by this peer.');
+        return peer;
+    }
+    runEntryControl(entryArg, operationArg, internalArg = false) {
+        if (!internalArg && entryArg.pendingControlOperations >= maxPendingControlOperations) {
+            return Promise.reject(new Error('The terminal control queue is full.'));
+        }
+        if (!internalArg)
+            entryArg.pendingControlOperations += 1;
+        const operation = entryArg.controlQueue.then(async () => {
+            if (entryArg.closing || entryArg.finalState !== 'running') {
+                throw new Error('The terminal is not accepting operations.');
+            }
+            return operationArg();
+        });
+        entryArg.controlQueue = operation.then(() => undefined, () => undefined);
+        if (internalArg)
+            return operation;
+        return operation.finally(() => {
+            entryArg.pendingControlOperations -= 1;
+        });
+    }
+    appendOutput(entryArg, chunkArg) {
+        if (chunkArg.byteLength === 0 || entryArg.finalState === 'exited')
+            return;
+        appendOutput(entryArg.output, chunkArg);
+        if (entryArg.closing)
+            return;
+        for (const peer of entryArg.peers.values()) {
+            if (!peer.deliveryPromise)
+                void this.schedulePeerDelivery(entryArg, peer);
+        }
+    }
+    schedulePeerDelivery(entryArg, peerArg, forceResetArg = false) {
+        if (peerArg.detaching || peerArg.finalizing || entryArg.peers.get(peerArg.peerId) !== peerArg) {
+            return Promise.resolve();
+        }
+        if (peerArg.deliveryPromise)
+            return peerArg.deliveryPromise;
+        const targetEnd = entryArg.output.end;
+        const needsReset = forceResetArg || peerArg.cursor < entryArg.output.start;
+        const start = needsReset ? entryArg.output.start : Math.min(peerArg.cursor, targetEnd);
+        const delivery = this.deliverRange(entryArg, peerArg, start, targetEnd, needsReset);
+        peerArg.deliveryPromise = delivery;
+        void delivery.catch(() => {
+            if (entryArg.peers.get(peerArg.peerId) === peerArg) {
+                this.detachPeerState(entryArg, peerArg);
+                void this.requestSizeReconciliation(entryArg);
+            }
+        }).finally(() => {
+            if (peerArg.deliveryPromise === delivery)
+                peerArg.deliveryPromise = undefined;
+            if (!peerArg.detaching
+                && !peerArg.finalizing
+                && entryArg.peers.get(peerArg.peerId) === peerArg
+                && peerArg.cursor < entryArg.output.end) {
+                void this.schedulePeerDelivery(entryArg, peerArg);
+            }
+        });
+        return delivery;
+    }
+    async deliverRange(entryArg, peerArg, startArg, endArg, resetArg, deadlineAtArg) {
+        let cursor = startArg;
+        let resetPending = resetArg;
+        let sentFrame = false;
+        while (cursor < endArg) {
+            if (peerArg.detaching || entryArg.peers.get(peerArg.peerId) !== peerArg)
+                return;
+            if (cursor < entryArg.output.start) {
+                cursor = entryArg.output.start;
+                peerArg.cursor = cursor;
+                resetPending = true;
+            }
+            if (cursor >= endArg)
+                break;
+            const frame = this.readOutputFrame(entryArg, cursor, endArg);
+            if (!frame || frame.byteLength === 0)
+                break;
+            const send = this.sendPeerOutput(entryArg, peerArg, frame, resetPending);
+            if (deadlineAtArg === undefined)
+                await send;
+            else
+                await waitUntil(send, deadlineAtArg);
+            if (peerArg.detaching || entryArg.peers.get(peerArg.peerId) !== peerArg)
+                return;
+            cursor += frame.byteLength;
+            peerArg.cursor = cursor;
+            resetPending = false;
+            sentFrame = true;
+        }
+        if (resetPending && !sentFrame) {
+            const send = this.sendPeerOutput(entryArg, peerArg, Buffer.alloc(0), true);
+            if (deadlineAtArg === undefined)
+                await send;
+            else
+                await waitUntil(send, deadlineAtArg);
+            peerArg.cursor = Math.max(peerArg.cursor, entryArg.output.start);
+        }
+    }
+    readOutputFrame(entryArg, startArg, endArg) {
+        if (startArg >= endArg)
+            return undefined;
+        let slabStart = entryArg.output.start;
+        for (const slab of entryArg.output.slabs) {
+            const slabBytes = slab.end - slab.start;
+            const slabEnd = slabStart + slabBytes;
+            if (slabEnd <= startArg) {
+                slabStart = slabEnd;
+                continue;
+            }
+            if (slabStart >= endArg)
+                break;
+            const offset = Math.max(0, startArg - slabStart);
+            const frameBytes = Math.min(maxOutputFrameBytes, slabBytes - offset, endArg - startArg);
+            return slab.buffer.subarray(slab.start + offset, slab.start + offset + frameBytes);
+        }
+        return undefined;
+    }
+    async sendPeerOutput(entryArg, peerArg, dataArg, resetArg) {
+        if (peerArg.detaching || entryArg.peers.get(peerArg.peerId) !== peerArg)
+            return;
+        await this.options.sendOutput(peerArg.peerId, {
+            terminalId: { ...entryArg.terminal.id },
+            dataBase64: dataArg.toString('base64'),
+            ...(resetArg ? { reset: true } : {}),
+        });
+    }
+    detachPeerState(entryArg, peerArg) {
+        peerArg.detaching = true;
+        if (entryArg.peers.get(peerArg.peerId) === peerArg) {
+            entryArg.peers.delete(peerArg.peerId);
+            if (entryArg.sizesByPeer.delete(peerArg.peerId))
+                entryArg.sizeRevision += 1;
+        }
+    }
+    async applyMinimumSize(entryArg) {
+        if (entryArg.sizesByPeer.size === 0 || entryArg.closing)
+            return;
+        let rows = Number.POSITIVE_INFINITY;
+        let cols = Number.POSITIVE_INFINITY;
+        for (const size of entryArg.sizesByPeer.values()) {
+            rows = Math.min(rows, size.rows);
+            cols = Math.min(cols, size.cols);
+        }
+        if (Number.isFinite(rows) && Number.isFinite(cols)) {
+            await entryArg.execution.resize(cols, rows);
+        }
+    }
+    async applyMinimumSizeUntilStable(entryArg) {
+        if (entryArg.sizeReconciliationActive || entryArg.closing)
+            return;
+        entryArg.sizeReconciliationActive = true;
+        try {
+            let appliedRevision;
+            do {
+                appliedRevision = entryArg.sizeRevision;
+                await this.applyMinimumSize(entryArg);
+            } while (!entryArg.closing && appliedRevision !== entryArg.sizeRevision);
+        }
+        finally {
+            entryArg.sizeReconciliationActive = false;
+        }
+    }
+    requestSizeReconciliation(entryArg) {
+        if (entryArg.closing || entryArg.sizeReconciliationActive)
+            return Promise.resolve();
+        if (entryArg.sizeReconciliationPromise)
+            return entryArg.sizeReconciliationPromise;
+        const reconciliation = this.runEntryControl(entryArg, () => this.applyMinimumSizeUntilStable(entryArg), true);
+        entryArg.sizeReconciliationPromise = reconciliation;
+        void reconciliation.catch(() => undefined).finally(() => {
+            if (entryArg.sizeReconciliationPromise === reconciliation) {
+                entryArg.sizeReconciliationPromise = undefined;
+            }
+        });
+        return reconciliation;
+    }
+    confirmRootExit(entryArg, exitCodeArg) {
+        if (entryArg.finalState === 'exited')
+            return;
+        entryArg.finalState = 'exited';
+        if (exitCodeArg !== undefined)
+            entryArg.exitCode = exitCodeArg;
+        entryArg.exitSubscription?.dispose();
+        entryArg.resolveRootExit();
+        entryArg.finalizePromise = this.finalizeExitedEntry(entryArg, entryArg.finalizationDeadlineAt ?? Date.now() + this.cleanupTimeoutMs);
+    }
+    async finalizeExitedPeer(entryArg, peerArg, finalOutputEndArg, deadlineAtArg) {
+        if (peerArg.detaching || entryArg.peers.get(peerArg.peerId) !== peerArg)
+            return;
+        peerArg.finalizing = true;
+        try {
+            if (peerArg.deliveryPromise) {
+                await waitUntil(peerArg.deliveryPromise, deadlineAtArg);
+            }
+            if (peerArg.detaching || entryArg.peers.get(peerArg.peerId) !== peerArg)
+                return;
+            const needsReset = peerArg.cursor < entryArg.output.start;
+            await this.deliverRange(entryArg, peerArg, needsReset ? entryArg.output.start : peerArg.cursor, finalOutputEndArg, needsReset, deadlineAtArg);
+            if (peerArg.detaching
+                || entryArg.peers.get(peerArg.peerId) !== peerArg
+                || peerArg.cursor < finalOutputEndArg)
+                return;
+            await waitUntil(this.options.sendOutput(peerArg.peerId, {
+                terminalId: { ...entryArg.terminal.id },
+                dataBase64: '',
+                ended: true,
+            }), deadlineAtArg);
+        }
+        catch {
+            // A stalled peer is detached without an ended frame; output can never race ended.
+        }
+        finally {
+            this.detachPeerState(entryArg, peerArg);
+        }
+    }
+    async finalizeExitedEntry(entryArg, deadlineAtArg) {
+        if (this.entries.get(entryArg.terminal.id.nativeId) !== entryArg)
+            return;
+        const finalOutputEnd = entryArg.output.end;
+        await Promise.allSettled([...entryArg.peers.values()].map((peer) => (this.finalizeExitedPeer(entryArg, peer, finalOutputEnd, deadlineAtArg))));
+        this.entries.delete(entryArg.terminal.id.nativeId);
+        entryArg.peers.clear();
+        entryArg.sizesByPeer.clear();
+        const terminalId = { ...entryArg.terminal.id };
+        const removalCleanup = Promise.resolve()
+            .then(() => this.options.onTerminalStopped(entryArg.projectId, terminalId, entryArg.exitCode))
+            .catch(() => undefined);
+        this.pendingRemovalCleanups.set(removalCleanup, entryArg.projectId);
+        try {
+            await waitUntil(removalCleanup, deadlineAtArg);
+        }
+        catch {
+            // Resource ownership is already released; startup pruning recovers a timed-out cleanup.
+        }
+        finally {
+            this.pendingRemovalCleanups.delete(removalCleanup);
+        }
+        try {
+            this.options.onTerminalsChanged(entryArg.projectId);
+        }
+        catch {
+            // Root ownership is already released; a notification callback cannot restore it.
+        }
+    }
+    async closeEntry(entryArg, deadlineAtArg) {
+        if (this.entries.get(entryArg.terminal.id.nativeId) !== entryArg)
+            return;
+        if (entryArg.finalState === 'exited') {
+            await waitUntil(entryArg.finalizePromise ?? Promise.resolve(), deadlineAtArg);
+            return;
+        }
+        if (!entryArg.closeLifecyclePromise) {
+            entryArg.closing = true;
+            entryArg.finalizationDeadlineAt = deadlineAtArg;
+            const lifecycle = (async () => {
+                await entryArg.rootExitPromise;
+                await entryArg.finalizePromise;
+            })();
+            entryArg.closeLifecyclePromise = lifecycle;
+            try {
+                const signal = entryArg.execution.kill();
+                void signal.catch((errorArg) => {
+                    entryArg.signalError = normalizeError(errorArg);
+                });
+            }
+            catch (errorArg) {
+                entryArg.signalError = normalizeError(errorArg);
+            }
+        }
+        try {
+            await waitUntil(entryArg.closeLifecyclePromise, deadlineAtArg);
+        }
+        catch (errorArg) {
+            if (this.entries.get(entryArg.terminal.id.nativeId) !== entryArg)
+                return;
+            throw entryArg.signalError
+                ? new AggregateError([entryArg.signalError, errorArg], 'The terminal root could not be confirmed stopped.')
+                : errorArg;
+        }
+    }
+    async closeProjectEntries(projectIdArg, deadlineAtArg) {
+        const outcomes = await Promise.allSettled([...this.entries.values()]
+            .filter((entry) => entry.projectId === projectIdArg)
+            .map((entry) => this.closeEntry(entry, deadlineAtArg)));
+        const errors = outcomes.flatMap((outcome) => (outcome.status === 'rejected' ? [outcome.reason] : []));
+        const remaining = [...this.entries.values()]
+            .filter((entry) => entry.projectId === projectIdArg);
+        if (remaining.length > 0) {
+            errors.push(new Error('One or more project terminal roots remain unconfirmed.'));
+        }
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'The project terminal roots could not all be confirmed stopped.');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.terminalmanager.js","sourceRoot":"","sources":["../../ts/classes.terminalmanager.ts"],"names":[],"mappings":"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"}