agl 1.0.17 → 21.0.2

package/dist_ts/classes.flexsupervisor.js

@@ -0,0 +1,1191 @@
+import * as plugins from './plugins.js';
+import { commitinfo } from './00_commitinfo_data.js';
+import { FlexFramedTransport } from './classes.flexframedtransport.js';
+import { GitReversionConflictError, GitReversionDirtyWorktreeError, GitReversionFencedError, } from './classes.gitreversion.js';
+import { createSanitizedRuntimeEnvironment } from './functions.runtimeenvironment.js';
+import { FlexServiceError, flexIpcCancellationGraceTimeoutMs, flexIpcControlTimeoutMs, flexIpcDisposeTimeoutMs, flexIpcMaximumBrowserChannels, flexIpcMaximumPendingBrowserFrameBytes, flexIpcMaximumPendingBrowserFrames, flexIpcMaximumPendingRequests, flexIpcProtocolVersion, flexIpcSlashTimeoutMs, flexIpcStartupTimeoutMs, hasFlexExactKeys, isFlexPlainObject, isFlexHostResponseResult, isFlexResponseResult, parseFlexChildMessage, parseFlexParentMessage, } from './interfaces.flexipc.js';
+const supervisorLogEntries = 200;
+const supervisorLogLineBytes = 8 * 1024;
+const supervisorTermTimeoutMs = 5_000;
+const supervisorKillTimeoutMs = 2_000;
+const logSuffix = '... [truncated]';
+const supervisorExitMessageBytes = 1024;
+const readOnlyFlexRequestMethods = new Set([
+    'service.status',
+    'intelligence.get',
+    'session.list',
+    'session.get',
+    'session.reversion.info',
+    'slash.list',
+    'message.page',
+    'message.get',
+    'prompt.get',
+    'prompt.list',
+    'permission.list',
+    'provider.list',
+    'provider.login.status',
+    'provider.connection.list',
+    'provider.connection.opencode-auth.get',
+    'provider.connection.ratelimits.get',
+    'model.choice.get',
+    'model.choice.validate',
+]);
+const outcomeMayBeUnknown = (methodArg) => methodArg !== undefined
+    && !readOnlyFlexRequestMethods.has(methodArg);
+const isReadyOnlyHostRequest = (methodArg) => (methodArg === 'crossharness.chats.list'
+    || methodArg === 'crossharness.chat.read'
+    || methodArg === 'browser.resources.resolve'
+    || methodArg === 'browser.channel.open'
+    || methodArg === 'browser.channel.close');
+const sanitizeExitMessage = (messageArg) => {
+    const sanitized = messageArg.replace(/[\u0000-\u001f\u007f]/gu, ' ').trim();
+    if (Buffer.byteLength(sanitized, 'utf8') <= supervisorExitMessageBytes)
+        return sanitized;
+    return Buffer.from(sanitized, 'utf8')
+        .subarray(0, supervisorExitMessageBytes)
+        .toString('utf8')
+        .replace(/\uFFFD$/u, '');
+};
+const isMissingProcess = (errorArg) => typeof errorArg === 'object'
+    && errorArg !== null
+    && 'code' in errorArg
+    && errorArg.code === 'ESRCH';
+const isProcessGroupAlive = (processGroupIdArg) => {
+    try {
+        process.kill(-processGroupIdArg, 0);
+        return true;
+    }
+    catch (errorArg) {
+        if (isMissingProcess(errorArg))
+            return false;
+        throw errorArg;
+    }
+};
+const signalProcessGroup = (processGroupIdArg, signalArg) => {
+    try {
+        process.kill(-processGroupIdArg, signalArg);
+    }
+    catch (errorArg) {
+        if (!isMissingProcess(errorArg))
+            throw errorArg;
+    }
+};
+const waitFor = async (predicateArg, timeoutMsArg) => {
+    const deadline = Date.now() + timeoutMsArg;
+    while (predicateArg()) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            return false;
+        await new Promise((resolve) => setTimeout(resolve, Math.min(20, remaining)));
+    }
+    return true;
+};
+const waitBounded = async (promiseArg, timeoutMsArg) => {
+    let timer;
+    try {
+        return await Promise.race([
+            promiseArg,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(undefined), timeoutMsArg);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+};
+const truncateLog = (lineArg) => {
+    if (Buffer.byteLength(lineArg, 'utf8') <= supervisorLogLineBytes) {
+        return { line: lineArg, truncated: false };
+    }
+    const contentBytes = supervisorLogLineBytes - Buffer.byteLength(logSuffix, 'utf8');
+    const content = Buffer.from(lineArg, 'utf8')
+        .subarray(0, contentBytes)
+        .toString('utf8')
+        .replace(/\uFFFD$/u, '');
+    return { line: `${content}${logSuffix}`, truncated: true };
+};
+export const resolveFlexChildEntryPath = () => {
+    const modulePath = plugins.url.fileURLToPath(import.meta.url);
+    const sourceDirectory = plugins.path.dirname(modulePath);
+    const packageDirectory = plugins.fs.realpathSync.native(plugins.path.dirname(sourceDirectory));
+    const packageJsonPath = plugins.fs.realpathSync.native(plugins.path.join(packageDirectory, 'package.json'));
+    const packageJson = JSON.parse(plugins.fs.readFileSync(packageJsonPath, 'utf8'));
+    if (!packageJson
+        || typeof packageJson !== 'object'
+        || !('name' in packageJson)
+        || packageJson.name !== commitinfo.name)
+        throw new Error('The Flex child package identity is invalid.');
+    const childPath = plugins.fs.realpathSync.native(plugins.path.join(packageDirectory, 'dist_ts', 'flexharness.child.js'));
+    const relative = plugins.path.relative(packageDirectory, childPath);
+    if (relative === '..'
+        || relative.startsWith(`..${plugins.path.sep}`)
+        || plugins.path.isAbsolute(relative)
+        || relative !== plugins.path.join('dist_ts', 'flexharness.child.js'))
+        throw new Error('The Flex child entry escaped its package.');
+    if (!plugins.fs.statSync(childPath).isFile()) {
+        throw new Error('The package-owned Flex child entry is not a file.');
+    }
+    return childPath;
+};
+export class FlexSupervisor {
+    options;
+    status = { state: 'stopped', ready: false };
+    child;
+    lifecycle;
+    transport;
+    ownedProcessGroupId;
+    orphanReapTask;
+    childTaskDrainTask;
+    childExitCleanupPending = false;
+    pendingChildExit;
+    lastExit;
+    browserPeerId = '';
+    startPromise;
+    stopPromise;
+    startupResolve;
+    startupReject;
+    pendingRequests = new Map();
+    activeHostRequests = new Map();
+    hostRequestTasks = new Set();
+    pendingHostSuccessAcknowledgements = new Map();
+    activeReadyHostRequests = new Set();
+    browserFrameTasks = new Set();
+    browserFrameTaskBytes = 0;
+    settledHostRequestIds = new Set();
+    eventListeners = new Set();
+    logs = [];
+    stdoutAccumulator = {
+        decoder: new TextDecoder(), partial: '', dropping: false,
+    };
+    stderrAccumulator = {
+        decoder: new TextDecoder(), partial: '', dropping: false,
+    };
+    cancellationGraceTimeoutMs;
+    childTaskDrainTimeoutMs;
+    constructor(options = {}) {
+        this.options = options;
+        this.cancellationGraceTimeoutMs = this.normalizeDeadline(options.cancellationGraceTimeoutMs, flexIpcCancellationGraceTimeoutMs, 'cancellationGraceTimeoutMs');
+        this.childTaskDrainTimeoutMs = this.normalizeDeadline(options.childTaskDrainTimeoutMs, flexIpcControlTimeoutMs, 'childTaskDrainTimeoutMs');
+    }
+    getStatus() {
+        return {
+            ...this.status,
+            ...(this.child?.pid ? { pid: this.child.pid } : {}),
+            ...(this.lastExit ? { lastExit: { ...this.lastExit } } : {}),
+        };
+    }
+    getLogSnapshot() {
+        return this.logs.map((entry) => ({ ...entry }));
+    }
+    ownsChildPeer(peerIdArg) {
+        return this.browserPeerId !== ''
+            && this.browserPeerId === peerIdArg
+            && this.child?.exitCode === null
+            && this.child.signalCode === null;
+    }
+    ownsBrowserPeer(peerIdArg) {
+        return this.status.ready && this.ownsChildPeer(peerIdArg);
+    }
+    ownsHostPeer(peerIdArg) {
+        return this.ownsChildPeer(peerIdArg)
+            && (this.status.state === 'starting' || this.status.state === 'ready');
+    }
+    subscribe(listenerArg) {
+        this.eventListeners.add(listenerArg);
+        return () => this.eventListeners.delete(listenerArg);
+    }
+    async settleReadyHostRequests() {
+        while (this.activeReadyHostRequests.size > 0) {
+            const settled = await waitBounded(Promise.allSettled([...this.activeReadyHostRequests]).then(() => true), flexIpcDisposeTimeoutMs);
+            if (settled !== true) {
+                throw new Error('Prior ready-only Flex host requests did not settle after cleanup.');
+            }
+        }
+    }
+    async start(initArg, signalArg) {
+        if (this.startPromise)
+            return this.startPromise;
+        if (this.hostRequestTasks.size > 0) {
+            throw new Error('Prior Flex child host requests must settle before another child can start.');
+        }
+        if (this.child || this.stopPromise || this.status.state === 'stopping') {
+            throw new Error('A prior Flex child must stop before another can start.');
+        }
+        const startPromise = this.performStart(initArg, signalArg);
+        this.startPromise = startPromise;
+        try {
+            return await startPromise;
+        }
+        finally {
+            if (this.startPromise === startPromise)
+                this.startPromise = undefined;
+        }
+    }
+    async request(methodArg, payloadArg, signalArg) {
+        if (methodArg !== 'service.status' && !this.status.ready) {
+            throw new FlexServiceError(this.status.state === 'unsupported' ? 'UNSUPPORTED_RUNTIME' : 'NOT_READY');
+        }
+        try {
+            return await this.sendRequest(methodArg, payloadArg, methodArg === 'slash.execute' ? flexIpcSlashTimeoutMs : flexIpcControlTimeoutMs, signalArg);
+        }
+        catch (errorArg) {
+            if (errorArg instanceof FlexServiceError
+                && errorArg.code === 'OUTCOME_UNKNOWN') {
+                try {
+                    await this.stop();
+                }
+                catch (stopErrorArg) {
+                    throw new AggregateError([errorArg, stopErrorArg], 'The timed-out Flex request could not stop its child.');
+                }
+            }
+            throw errorArg;
+        }
+    }
+    async requestToCompletion(methodArg, payloadArg) {
+        if (methodArg !== 'service.status' && !this.status.ready) {
+            throw new FlexServiceError(this.status.state === 'unsupported' ? 'UNSUPPORTED_RUNTIME' : 'NOT_READY');
+        }
+        return await this.sendRequest(methodArg, payloadArg, undefined);
+    }
+    async stop() {
+        if (this.stopPromise)
+            return this.stopPromise;
+        const stopPromise = this.performStop();
+        this.stopPromise = stopPromise;
+        try {
+            await stopPromise;
+        }
+        finally {
+            if (this.stopPromise === stopPromise)
+                this.stopPromise = undefined;
+        }
+    }
+    async performStart(initArg, signalArg) {
+        this.status = { state: 'starting', ready: false };
+        this.settledHostRequestIds.clear();
+        signalArg?.throwIfAborted();
+        const childEntry = resolveFlexChildEntryPath();
+        const child = plugins.childProcess.spawn(process.execPath, [childEntry], {
+            cwd: plugins.path.dirname(plugins.path.dirname(childEntry)),
+            detached: process.platform !== 'win32',
+            shell: false,
+            windowsHide: true,
+            env: createSanitizedRuntimeEnvironment(),
+            stdio: ['ignore', 'pipe', 'pipe', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        this.lifecycle = this.observeChild(child);
+        if (!child.pid) {
+            await this.stop().catch(() => undefined);
+            throw new Error('The Flex child did not provide a process ID.');
+        }
+        this.browserPeerId = `flex-child:${child.pid}:${plugins.crypto.randomBytes(12).toString('base64url')}`;
+        if (process.platform !== 'win32')
+            this.ownedProcessGroupId = child.pid;
+        const parentWriter = child.stdio[3];
+        const parentReader = child.stdio[4];
+        if (!(parentWriter instanceof plugins.stream.Writable)
+            || !(parentReader instanceof plugins.stream.Readable)) {
+            await this.stop().catch(() => undefined);
+            throw new Error('The Flex child control pipes were not created.');
+        }
+        const transport = new FlexFramedTransport({
+            readable: parentReader,
+            writable: parentWriter,
+            parseIncoming: parseFlexChildMessage,
+            validateOutgoing: parseFlexParentMessage,
+        });
+        this.transport = transport;
+        const browserPeerId = this.browserPeerId;
+        transport.onMessage((message) => this.handleChildMessage(message, browserPeerId));
+        transport.onError(() => {
+            if (this.transport === transport && this.ownsChildPeer(browserPeerId)) {
+                this.handleProtocolFailure();
+            }
+        });
+        transport.onClose(() => {
+            if (this.transport === transport
+                && this.status.state !== 'stopping'
+                && this.status.state !== 'stopped')
+                this.handleProtocolFailure();
+        });
+        const startup = new Promise((resolve, reject) => {
+            this.startupResolve = resolve;
+            this.startupReject = reject;
+        });
+        try {
+            await transport.send({
+                version: flexIpcProtocolVersion,
+                type: 'init',
+                init: initArg,
+            });
+            const result = await this.waitForStartup(startup, this.lifecycle, signalArg);
+            if (result.state === 'failed')
+                throw new Error('The Flex child failed during initialization.');
+            if (result.state === 'unsupported') {
+                await this.stop();
+                this.status = { ...result };
+                return this.getStatus();
+            }
+            this.status = { ...result, pid: child.pid };
+            return this.getStatus();
+        }
+        catch (errorArg) {
+            await this.stop().catch(() => undefined);
+            this.status = { state: 'failed', ready: false };
+            throw new Error('Flex child startup failed.', { cause: errorArg });
+        }
+        finally {
+            this.startupResolve = undefined;
+            this.startupReject = undefined;
+        }
+    }
+    async waitForStartup(startupArg, lifecycleArg, signalArg) {
+        let timeout;
+        let abortListener;
+        try {
+            const outcomes = [
+                startupArg,
+                lifecycleArg.then(() => {
+                    throw new Error('The Flex child exited during startup.');
+                }),
+                new Promise((_, reject) => {
+                    timeout = setTimeout(() => reject(new Error('The Flex child exceeded its startup deadline.')), flexIpcStartupTimeoutMs);
+                }),
+            ];
+            if (signalArg) {
+                outcomes.push(new Promise((_, reject) => {
+                    if (signalArg.aborted) {
+                        reject(signalArg.reason);
+                        return;
+                    }
+                    abortListener = () => reject(signalArg.reason);
+                    signalArg.addEventListener('abort', abortListener, { once: true });
+                }));
+            }
+            return await Promise.race(outcomes);
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+            if (abortListener)
+                signalArg?.removeEventListener('abort', abortListener);
+        }
+    }
+    handleChildMessage(messageArg, peerIdArg) {
+        if (!this.ownsChildPeer(peerIdArg))
+            return;
+        if (messageArg.type === 'status') {
+            this.status = {
+                ...messageArg.status,
+                ...(this.child?.pid ? { pid: this.child.pid } : {}),
+            };
+            if (messageArg.status.state === 'ready'
+                || messageArg.status.state === 'unsupported'
+                || messageArg.status.state === 'failed')
+                this.startupResolve?.(messageArg.status);
+            return;
+        }
+        if (messageArg.type === 'event') {
+            for (const listener of [...this.eventListeners]) {
+                try {
+                    listener(messageArg.event);
+                }
+                catch {
+                    // Event listeners are isolated from the child transport.
+                }
+            }
+            return;
+        }
+        if (messageArg.type === 'host.request') {
+            if (!this.ownsHostPeer(peerIdArg)
+                || this.activeHostRequests.has(messageArg.requestId)
+                || this.settledHostRequestIds.has(messageArg.requestId)
+                || this.hostRequestTasks.size >= flexIpcMaximumBrowserChannels) {
+                this.handleProtocolFailure();
+                return;
+            }
+            const operation = this.handleHostRequest(messageArg, peerIdArg);
+            this.hostRequestTasks.add(operation);
+            if (isReadyOnlyHostRequest(messageArg.method)) {
+                this.activeReadyHostRequests.add(operation);
+            }
+            void operation.finally(() => {
+                this.hostRequestTasks.delete(operation);
+                this.activeReadyHostRequests.delete(operation);
+                this.notifyChildExitCleanup();
+            }).catch(() => undefined);
+            return;
+        }
+        if (messageArg.type === 'host.response.acknowledge') {
+            const pending = this.pendingHostSuccessAcknowledgements.get(messageArg.requestId);
+            if (!pending || pending.peerId !== peerIdArg) {
+                this.handleProtocolFailure();
+                return;
+            }
+            this.pendingHostSuccessAcknowledgements.delete(messageArg.requestId);
+            if (!pending.acknowledge())
+                this.handleProtocolFailure();
+            return;
+        }
+        if (messageArg.type === 'host.cancel') {
+            const active = this.activeHostRequests.get(messageArg.requestId);
+            if (active) {
+                active.abort(new FlexServiceError('ABORTED'));
+                return;
+            }
+            if (!this.settledHostRequestIds.has(messageArg.requestId)) {
+                this.handleProtocolFailure();
+            }
+            return;
+        }
+        if (messageArg.type === 'browser.channel.frame') {
+            const handleBrowserFrame = this.options.handleBrowserFrame;
+            if (!this.ownsBrowserPeer(peerIdArg) || !handleBrowserFrame) {
+                this.handleProtocolFailure();
+                return;
+            }
+            const transport = this.transport;
+            if (!transport) {
+                this.handleProtocolFailure();
+                return;
+            }
+            const bytes = Buffer.from(messageArg.dataBase64, 'base64');
+            if (this.browserFrameTasks.size >= flexIpcMaximumPendingBrowserFrames
+                || this.browserFrameTaskBytes + bytes.byteLength > flexIpcMaximumPendingBrowserFrameBytes) {
+                this.handleProtocolFailure();
+                return;
+            }
+            this.browserFrameTaskBytes += bytes.byteLength;
+            let operation;
+            operation = Promise.resolve()
+                .then(() => handleBrowserFrame(messageArg.channelId, bytes, peerIdArg))
+                .finally(() => {
+                this.browserFrameTaskBytes -= bytes.byteLength;
+                this.browserFrameTasks.delete(operation);
+                this.notifyChildExitCleanup();
+            });
+            this.browserFrameTasks.add(operation);
+            void operation.catch(() => {
+                if (this.transport === transport && this.ownsBrowserPeer(peerIdArg)) {
+                    this.handleProtocolFailure();
+                }
+            });
+            return;
+        }
+        const pending = this.pendingRequests.get(messageArg.requestId);
+        if (!pending) {
+            this.handleProtocolFailure();
+            return;
+        }
+        this.clearPendingRequest(messageArg.requestId, pending);
+        if (pending.cancelled)
+            return;
+        if (!messageArg.ok) {
+            pending.reject(new FlexServiceError(messageArg.error.code));
+            return;
+        }
+        if (pending.kind === 'request'
+            && pending.method
+            && !isFlexResponseResult(pending.method, messageArg.result)) {
+            pending.reject(new Error('The Flex child returned an invalid method result.'));
+            this.handleProtocolFailure();
+            return;
+        }
+        if (pending.kind === 'dispose'
+            && (!isFlexPlainObject(messageArg.result)
+                || !hasFlexExactKeys(messageArg.result, ['disposed'])
+                || messageArg.result.disposed !== true)) {
+            pending.reject(new Error('The Flex child returned an invalid dispose result.'));
+            this.handleProtocolFailure();
+            return;
+        }
+        pending.resolve(messageArg.result);
+    }
+    async sendBrowserFrame(channelIdArg, bytesArg, peerIdArg) {
+        if (!this.ownsBrowserPeer(peerIdArg))
+            throw new Error('The Flex child generation is unavailable.');
+        const transport = this.transport;
+        if (!transport)
+            throw new Error('The Flex child transport is unavailable.');
+        await transport.send({
+            version: flexIpcProtocolVersion,
+            type: 'browser.channel.frame',
+            channelId: channelIdArg,
+            dataBase64: bytesArg.toString('base64'),
+        });
+    }
+    async notifyBrowserChannelClosed(channelIdArg, peerIdArg) {
+        if (!this.ownsBrowserPeer(peerIdArg))
+            throw new Error('The Flex child generation is unavailable.');
+        const transport = this.transport;
+        if (!transport)
+            throw new Error('The Flex child transport is unavailable.');
+        await transport.send({
+            version: flexIpcProtocolVersion,
+            type: 'browser.channel.closed',
+            channelId: channelIdArg,
+        });
+    }
+    async handleHostRequest(messageArg, peerIdArg) {
+        const transport = this.transport;
+        const child = this.child;
+        if (!transport || !this.options.handleHostRequest || !this.ownsHostPeer(peerIdArg)) {
+            this.handleProtocolFailure();
+            return;
+        }
+        if (messageArg.method === 'git.worktree.create' && !this.options.handleUndeliveredHostSuccess) {
+            this.handleProtocolFailure();
+            return;
+        }
+        const controller = new AbortController();
+        this.activeHostRequests.set(messageArg.requestId, controller);
+        const timeout = setTimeout(() => controller.abort(new FlexServiceError('TIMEOUT')), messageArg.timeoutMs);
+        timeout.unref();
+        let completedResult;
+        let deliveryState;
+        let compensationTask;
+        let responseSendAttempted = false;
+        let compensationFailed = false;
+        let acknowledgementTimeout;
+        let acknowledgementAbortListener;
+        let acknowledgementResolve;
+        let acknowledgementReject;
+        let pendingAcknowledgement;
+        let acknowledgementPromise;
+        const compensateUndeliveredSuccess = () => {
+            if (deliveryState === 'acknowledged')
+                return Promise.resolve();
+            if (compensationTask)
+                return compensationTask;
+            const result = completedResult;
+            if (!result)
+                return Promise.resolve();
+            deliveryState = 'compensating';
+            if (pendingAcknowledgement
+                && this.pendingHostSuccessAcknowledgements.get(messageArg.requestId)
+                    === pendingAcknowledgement) {
+                this.pendingHostSuccessAcknowledgements.delete(messageArg.requestId);
+            }
+            compensationTask = (async () => {
+                try {
+                    await this.options.handleUndeliveredHostSuccess?.(messageArg.method, messageArg.payload, result, peerIdArg);
+                    deliveryState = 'compensated';
+                    completedResult = undefined;
+                }
+                catch (errorArg) {
+                    compensationFailed = true;
+                    deliveryState = 'compensated';
+                    completedResult = undefined;
+                    throw new GitReversionFencedError('Undelivered Flex host success compensation failed.', { cause: errorArg });
+                }
+            })();
+            return compensationTask;
+        };
+        const rejectAcknowledgementAfterCompensation = (errorArg) => {
+            if (!acknowledgementReject || deliveryState !== 'retained')
+                return;
+            const task = compensateUndeliveredSuccess();
+            void task.then(() => acknowledgementReject?.(errorArg), (compensationError) => acknowledgementReject?.(compensationError));
+        };
+        try {
+            const result = await this.options.handleHostRequest(messageArg.method, messageArg.payload, peerIdArg, controller.signal);
+            if (!isFlexHostResponseResult(messageArg.method, result)) {
+                throw new Error('The Flex host returned an invalid resource result.');
+            }
+            completedResult = result;
+            deliveryState = 'retained';
+            if (controller.signal.aborted) {
+                await compensateUndeliveredSuccess();
+                controller.signal.throwIfAborted();
+            }
+            if (!this.ownsChildPeer(peerIdArg) || this.transport !== transport) {
+                await compensateUndeliveredSuccess();
+                return;
+            }
+            if (messageArg.method === 'git.worktree.create') {
+                acknowledgementPromise = new Promise((resolve, reject) => {
+                    acknowledgementResolve = resolve;
+                    acknowledgementReject = reject;
+                });
+                void acknowledgementPromise.catch(() => undefined);
+                pendingAcknowledgement = {
+                    peerId: peerIdArg,
+                    acknowledge: () => {
+                        if (deliveryState !== 'retained')
+                            return false;
+                        deliveryState = 'acknowledged';
+                        completedResult = undefined;
+                        acknowledgementResolve?.();
+                        return true;
+                    },
+                };
+                this.pendingHostSuccessAcknowledgements.set(messageArg.requestId, pendingAcknowledgement);
+                acknowledgementAbortListener = () => {
+                    rejectAcknowledgementAfterCompensation(controller.signal.reason ?? new FlexServiceError('ABORTED'));
+                };
+                controller.signal.addEventListener('abort', acknowledgementAbortListener, { once: true });
+                if (controller.signal.aborted)
+                    acknowledgementAbortListener();
+                if (!this.ownsChildPeer(peerIdArg) || this.transport !== transport) {
+                    await compensateUndeliveredSuccess();
+                    return;
+                }
+            }
+            responseSendAttempted = true;
+            try {
+                await transport.send({
+                    version: flexIpcProtocolVersion,
+                    type: 'host.response',
+                    requestId: messageArg.requestId,
+                    ok: true,
+                    result,
+                });
+            }
+            catch (errorArg) {
+                await compensateUndeliveredSuccess();
+                throw errorArg;
+            }
+            clearTimeout(timeout);
+            if (acknowledgementPromise) {
+                if (deliveryState === 'retained') {
+                    acknowledgementTimeout = setTimeout(() => {
+                        rejectAcknowledgementAfterCompensation(new FlexServiceError('TIMEOUT'));
+                    }, this.cancellationGraceTimeoutMs);
+                    acknowledgementTimeout.unref();
+                }
+                await acknowledgementPromise;
+            }
+            else {
+                deliveryState = 'acknowledged';
+                completedResult = undefined;
+            }
+            this.rememberSettledHostRequest(messageArg.requestId);
+        }
+        catch (caughtError) {
+            let errorArg = caughtError;
+            if (completedResult) {
+                try {
+                    await compensateUndeliveredSuccess();
+                }
+                catch (compensationError) {
+                    errorArg = compensationError;
+                }
+            }
+            if (responseSendAttempted) {
+                if (deliveryState === 'acknowledged') {
+                    this.rememberSettledHostRequest(messageArg.requestId);
+                }
+                else {
+                    this.failClosedChildGeneration(errorArg instanceof Error
+                        ? errorArg
+                        : new Error('Flex host success delivery failed.'), transport, child);
+                }
+                return;
+            }
+            if (!this.ownsChildPeer(peerIdArg) || this.transport !== transport)
+                return;
+            const authoritativeError = errorArg instanceof GitReversionFencedError
+                ? errorArg
+                : controller.signal.aborted
+                    ? controller.signal.reason
+                    : errorArg;
+            const code = authoritativeError instanceof FlexServiceError
+                ? authoritativeError.code
+                : authoritativeError instanceof GitReversionFencedError
+                    ? 'OUTCOME_UNKNOWN'
+                    : authoritativeError instanceof GitReversionConflictError
+                        || authoritativeError instanceof GitReversionDirtyWorktreeError
+                        ? 'CONFLICT'
+                        : 'INTERNAL';
+            await transport.send({
+                version: flexIpcProtocolVersion,
+                type: 'host.response',
+                requestId: messageArg.requestId,
+                ok: false,
+                error: {
+                    name: 'FlexServiceError',
+                    code,
+                    message: code === 'OUTCOME_UNKNOWN'
+                        ? 'The Flex operation outcome is unknown.'
+                        : code === 'CONFLICT'
+                            ? 'The Flex operation conflicted with a concurrent change.'
+                            : authoritativeError instanceof FlexServiceError
+                                ? authoritativeError.message
+                                : 'The Flex operation failed.',
+                },
+            }).then(() => {
+                this.rememberSettledHostRequest(messageArg.requestId);
+                if (compensationFailed)
+                    this.handleProtocolFailure();
+            }, () => {
+                if (this.ownsChildPeer(peerIdArg) && this.transport === transport) {
+                    this.handleProtocolFailure();
+                }
+            });
+        }
+        finally {
+            clearTimeout(timeout);
+            if (acknowledgementTimeout)
+                clearTimeout(acknowledgementTimeout);
+            if (acknowledgementAbortListener) {
+                controller.signal.removeEventListener('abort', acknowledgementAbortListener);
+            }
+            if (pendingAcknowledgement
+                && this.pendingHostSuccessAcknowledgements.get(messageArg.requestId)
+                    === pendingAcknowledgement) {
+                this.pendingHostSuccessAcknowledgements.delete(messageArg.requestId);
+            }
+            if (this.activeHostRequests.get(messageArg.requestId) === controller) {
+                this.activeHostRequests.delete(messageArg.requestId);
+            }
+        }
+    }
+    sendRequest(methodArg, payloadArg, timeoutMsArg, signalArg) {
+        return this.sendPending('request', timeoutMsArg, (requestId) => ({
+            version: flexIpcProtocolVersion,
+            type: 'request',
+            requestId,
+            method: methodArg,
+            payload: payloadArg,
+        }), methodArg, signalArg);
+    }
+    sendDispose(timeoutMsArg) {
+        return this.sendPending('dispose', timeoutMsArg, (requestId) => ({
+            version: flexIpcProtocolVersion,
+            type: 'dispose',
+            requestId,
+        }));
+    }
+    sendPending(kindArg, timeoutMsArg, createMessageArg, methodArg, signalArg) {
+        const transport = this.transport;
+        if (!transport)
+            return Promise.reject(new Error('The Flex child transport is unavailable.'));
+        if (this.pendingRequests.size >= flexIpcMaximumPendingRequests) {
+            return Promise.reject(new FlexServiceError('LIMIT_EXCEEDED'));
+        }
+        const child = this.child;
+        const requestId = plugins.crypto.randomBytes(16).toString('base64url');
+        return new Promise((resolve, reject) => {
+            if (signalArg?.aborted) {
+                reject(signalArg.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+                return;
+            }
+            const timeout = timeoutMsArg === undefined
+                ? undefined
+                : setTimeout(() => {
+                    const pending = this.pendingRequests.get(requestId);
+                    if (!pending || pending.cancelled)
+                        return;
+                    this.cancelPendingRequest(requestId, pending, new FlexServiceError(pending.dispatched && outcomeMayBeUnknown(pending.method)
+                        ? 'OUTCOME_UNKNOWN'
+                        : 'TIMEOUT'), transport, child);
+                }, timeoutMsArg);
+            timeout?.unref();
+            const pending = {
+                kind: kindArg,
+                ...(methodArg ? { method: methodArg } : {}),
+                resolve,
+                reject,
+                ...(timeout ? { timeout } : {}),
+                ...(signalArg === undefined ? {} : { signal: signalArg }),
+            };
+            this.pendingRequests.set(requestId, pending);
+            if (signalArg) {
+                const abortListener = () => {
+                    if (this.pendingRequests.get(requestId) !== pending)
+                        return;
+                    this.cancelPendingRequest(requestId, pending, pending.dispatched && outcomeMayBeUnknown(pending.method)
+                        ? new FlexServiceError('OUTCOME_UNKNOWN')
+                        : signalArg.reason ?? new DOMException('The operation was aborted.', 'AbortError'), transport, child);
+                };
+                pending.abortListener = abortListener;
+                signalArg.addEventListener('abort', abortListener, { once: true });
+                if (signalArg.aborted)
+                    abortListener();
+            }
+            if (this.pendingRequests.get(requestId) !== pending || pending.cancelled)
+                return;
+            pending.dispatched = true;
+            void transport.send(createMessageArg(requestId)).catch(() => {
+                const pending = this.pendingRequests.get(requestId);
+                if (!pending)
+                    return;
+                this.clearPendingRequest(requestId, pending);
+                if (!pending.cancelled) {
+                    pending.reject(new Error('The Flex child request could not be sent.'));
+                }
+                this.failClosedChildGeneration(new Error('The Flex child request could not be sent.'), transport, child);
+            });
+        });
+    }
+    cancelPendingRequest(requestIdArg, pendingArg, rejectionArg, transportArg, childArg) {
+        if (this.pendingRequests.get(requestIdArg) !== pendingArg || pendingArg.cancelled)
+            return;
+        if (pendingArg.timeout)
+            clearTimeout(pendingArg.timeout);
+        if (pendingArg.signal && pendingArg.abortListener) {
+            pendingArg.signal.removeEventListener('abort', pendingArg.abortListener);
+            pendingArg.signal = undefined;
+            pendingArg.abortListener = undefined;
+        }
+        pendingArg.cancelled = true;
+        pendingArg.reject(rejectionArg);
+        if (!pendingArg.dispatched) {
+            this.clearPendingRequest(requestIdArg, pendingArg);
+            return;
+        }
+        pendingArg.cancellationGraceTimeout = setTimeout(() => {
+            if (this.pendingRequests.get(requestIdArg) !== pendingArg)
+                return;
+            this.clearPendingRequest(requestIdArg, pendingArg);
+            this.failClosedChildGeneration(new Error('The Flex child did not settle a cancelled request.'), transportArg, childArg);
+        }, this.cancellationGraceTimeoutMs);
+        pendingArg.cancellationGraceTimeout.unref();
+        void transportArg.send({
+            version: flexIpcProtocolVersion,
+            type: 'request.cancel',
+            requestId: requestIdArg,
+        }).catch(() => {
+            if (this.pendingRequests.get(requestIdArg) !== pendingArg)
+                return;
+            this.clearPendingRequest(requestIdArg, pendingArg);
+            this.failClosedChildGeneration(new Error('The Flex request cancellation could not be sent.'), transportArg, childArg);
+        });
+    }
+    clearPendingRequest(requestIdArg, pendingArg) {
+        if (this.pendingRequests.get(requestIdArg) === pendingArg) {
+            this.pendingRequests.delete(requestIdArg);
+        }
+        if (pendingArg.timeout)
+            clearTimeout(pendingArg.timeout);
+        if (pendingArg.cancellationGraceTimeout) {
+            clearTimeout(pendingArg.cancellationGraceTimeout);
+            pendingArg.cancellationGraceTimeout = undefined;
+        }
+        if (pendingArg.signal && pendingArg.abortListener) {
+            pendingArg.signal.removeEventListener('abort', pendingArg.abortListener);
+            pendingArg.signal = undefined;
+            pendingArg.abortListener = undefined;
+        }
+    }
+    async performStop() {
+        const child = this.child;
+        const lifecycle = this.lifecycle;
+        if (!child || !lifecycle) {
+            this.rejectPending(new Error('The Flex child stopped.'));
+            await this.awaitChildTaskDrain();
+            await this.reapRetainedProcessGroup();
+            this.notifyChildExitCleanup();
+            this.status = { state: 'stopped', ready: false };
+            return;
+        }
+        this.status = { state: 'stopping', ready: false, pid: child.pid };
+        this.clearCancellationGraceTimeouts();
+        const deadline = Date.now() + flexIpcDisposeTimeoutMs;
+        if (this.transport && child.exitCode === null && child.signalCode === null) {
+            await this.sendDispose(flexIpcDisposeTimeoutMs).catch(() => undefined);
+            const remaining = Math.max(1, deadline - Date.now());
+            await waitBounded(lifecycle, remaining);
+        }
+        if (child.exitCode === null && child.signalCode === null) {
+            await this.terminateOwnedChild(child, lifecycle);
+        }
+        const orphanTask = this.orphanReapTask;
+        if (orphanTask)
+            await orphanTask;
+        await this.reapRetainedProcessGroup();
+        const confirmed = await waitBounded(lifecycle, supervisorKillTimeoutMs);
+        if (!confirmed && child.exitCode === null && child.signalCode === null) {
+            this.status = { state: 'failed', ready: false };
+            throw new Error('The Flex child exit was not confirmed.');
+        }
+        await this.transport?.close().catch(() => undefined);
+        this.transport = undefined;
+        this.rejectPending(new Error('The Flex child stopped.'));
+        await this.awaitChildTaskDrain();
+        this.notifyChildExitCleanup();
+        if (this.child === child)
+            this.child = undefined;
+        if (this.lifecycle === lifecycle)
+            this.lifecycle = undefined;
+        this.browserPeerId = '';
+        this.status = { state: 'stopped', ready: false };
+    }
+    async terminateOwnedChild(childArg, lifecycleArg) {
+        const processGroupId = this.ownedProcessGroupId;
+        if (processGroupId !== undefined && process.platform !== 'win32') {
+            if (isProcessGroupAlive(processGroupId))
+                signalProcessGroup(processGroupId, 'SIGTERM');
+            let exited = await waitFor(() => isProcessGroupAlive(processGroupId), supervisorTermTimeoutMs);
+            if (!exited) {
+                signalProcessGroup(processGroupId, 'SIGKILL');
+                exited = await waitFor(() => isProcessGroupAlive(processGroupId), supervisorKillTimeoutMs);
+            }
+            if (!exited)
+                throw new Error('The owned Flex process group survived SIGKILL.');
+            this.ownedProcessGroupId = undefined;
+        }
+        else {
+            childArg.kill('SIGTERM');
+            let exited = await waitBounded(lifecycleArg, supervisorTermTimeoutMs);
+            if (!exited && childArg.exitCode === null && childArg.signalCode === null) {
+                childArg.kill('SIGKILL');
+                exited = await waitBounded(lifecycleArg, supervisorKillTimeoutMs);
+            }
+            if (!exited && childArg.exitCode === null && childArg.signalCode === null) {
+                throw new Error('The owned Flex child survived SIGKILL.');
+            }
+        }
+    }
+    observeChild(childArg) {
+        childArg.stdout?.on('data', (chunk) => this.consumeLog('stdout', chunk, this.stdoutAccumulator));
+        childArg.stderr?.on('data', (chunk) => this.consumeLog('stderr', chunk, this.stderrAccumulator));
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = (outcomeArg) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.flushLog('stdout', this.stdoutAccumulator);
+                this.flushLog('stderr', this.stderrAccumulator);
+                this.status = { state: this.status.state === 'stopping' ? 'stopped' : 'failed', ready: false };
+                this.browserPeerId = '';
+                this.startupReject?.(new Error('The Flex child exited during startup.'));
+                this.rejectPending(new Error('The Flex child exited.'));
+                const processGroupId = this.ownedProcessGroupId;
+                const terminal = {
+                    type: outcomeArg.type,
+                    timestamp: Date.now(),
+                    ...(outcomeArg.code === undefined ? {} : { code: outcomeArg.code }),
+                    ...(outcomeArg.signal === undefined ? {} : { signal: outcomeArg.signal }),
+                    ...(outcomeArg.error?.message
+                        ? { errorMessage: sanitizeExitMessage(outcomeArg.error.message) }
+                        : {}),
+                };
+                this.lastExit = terminal;
+                try {
+                    this.options.onChildExitObserved?.({ ...terminal });
+                }
+                catch {
+                    // Immediate authority fencing must not prevent lifecycle settlement.
+                }
+                this.pendingChildExit = terminal;
+                this.childExitCleanupPending = true;
+                this.startChildTaskDrain();
+                if (processGroupId !== undefined && process.platform !== 'win32') {
+                    const reap = this.reapOrphanedGroup(processGroupId).then(() => {
+                        if (this.ownedProcessGroupId === processGroupId) {
+                            this.ownedProcessGroupId = undefined;
+                        }
+                    }).finally(() => {
+                        if (this.orphanReapTask === reap)
+                            this.orphanReapTask = undefined;
+                        this.notifyChildExitCleanup();
+                    });
+                    this.orphanReapTask = reap;
+                    void reap.catch(() => undefined);
+                }
+                else {
+                    this.notifyChildExitCleanup();
+                }
+                resolve(outcomeArg);
+            };
+            childArg.once('exit', (code, signal) => finish({ type: 'exit', code, signal }));
+            childArg.once('error', (error) => {
+                if (!childArg.pid)
+                    finish({ type: 'error', error });
+            });
+        });
+    }
+    async reapOrphanedGroup(processGroupIdArg) {
+        if (!isProcessGroupAlive(processGroupIdArg))
+            return;
+        signalProcessGroup(processGroupIdArg, 'SIGTERM');
+        let exited = await waitFor(() => isProcessGroupAlive(processGroupIdArg), supervisorTermTimeoutMs);
+        if (!exited) {
+            signalProcessGroup(processGroupIdArg, 'SIGKILL');
+            exited = await waitFor(() => isProcessGroupAlive(processGroupIdArg), supervisorKillTimeoutMs);
+        }
+        if (!exited)
+            throw new Error('An owned Flex process-group member survived SIGKILL.');
+    }
+    async reapRetainedProcessGroup() {
+        const processGroupId = this.ownedProcessGroupId;
+        if (processGroupId === undefined || process.platform === 'win32')
+            return;
+        await this.reapOrphanedGroup(processGroupId);
+        if (this.ownedProcessGroupId === processGroupId)
+            this.ownedProcessGroupId = undefined;
+    }
+    notifyChildExitCleanup() {
+        if (!this.childExitCleanupPending)
+            return;
+        if (this.orphanReapTask)
+            return;
+        if (this.childTaskDrainTask)
+            return;
+        if (this.hostRequestTasks.size > 0
+            || this.browserFrameTasks.size > 0
+            || this.activeHostRequests.size > 0)
+            return;
+        this.childExitCleanupPending = false;
+        const terminal = this.pendingChildExit;
+        this.pendingChildExit = undefined;
+        if (!terminal)
+            return;
+        try {
+            this.options.onChildExit?.({ ...terminal });
+        }
+        catch {
+            // Child lifecycle cleanup must not prevent lifecycle settlement.
+        }
+    }
+    handleProtocolFailure() {
+        this.rejectPending(new Error('The Flex child protocol failed.'));
+        this.startupReject?.(new Error('The Flex child protocol failed.'));
+        void this.stop().catch(() => undefined);
+    }
+    rejectPending(errorArg) {
+        for (const [requestId, pending] of this.pendingRequests) {
+            this.clearPendingRequest(requestId, pending);
+            pending.reject(pending.dispatched && outcomeMayBeUnknown(pending.method)
+                ? new FlexServiceError('OUTCOME_UNKNOWN')
+                : errorArg);
+        }
+        for (const controller of this.activeHostRequests.values())
+            controller.abort(errorArg);
+        this.settledHostRequestIds.clear();
+    }
+    clearCancellationGraceTimeouts() {
+        for (const pending of this.pendingRequests.values()) {
+            if (!pending.cancellationGraceTimeout)
+                continue;
+            clearTimeout(pending.cancellationGraceTimeout);
+            pending.cancellationGraceTimeout = undefined;
+        }
+    }
+    failClosedChildGeneration(errorArg, transportArg, childArg) {
+        if (!childArg
+            || this.child !== childArg
+            || this.transport !== transportArg
+            || childArg.exitCode !== null
+            || childArg.signalCode !== null)
+            return;
+        this.status = { state: 'failed', ready: false };
+        this.browserPeerId = '';
+        this.transport = undefined;
+        this.startupReject?.(errorArg);
+        this.rejectPending(errorArg);
+        void transportArg.close().catch(() => undefined);
+        void this.stop().catch(() => undefined);
+    }
+    startChildTaskDrain() {
+        if (this.childTaskDrainTask)
+            return;
+        let task;
+        task = this.drainChildTasks().finally(() => {
+            if (this.childTaskDrainTask === task)
+                this.childTaskDrainTask = undefined;
+            this.notifyChildExitCleanup();
+        });
+        this.childTaskDrainTask = task;
+        void task.catch(() => undefined);
+    }
+    async awaitChildTaskDrain() {
+        const task = this.childTaskDrainTask ?? this.drainChildTasks();
+        await task;
+    }
+    async drainChildTasks() {
+        if (this.hostRequestTasks.size === 0 && this.browserFrameTasks.size === 0)
+            return;
+        const settled = await waitBounded(Promise.allSettled([...this.hostRequestTasks, ...this.browserFrameTasks]), this.childTaskDrainTimeoutMs);
+        if (!settled
+            || this.hostRequestTasks.size > 0
+            || this.browserFrameTasks.size > 0
+            || this.activeHostRequests.size > 0) {
+            this.status = { state: 'failed', ready: false };
+            throw new Error('Flex child tasks did not settle after child shutdown.');
+        }
+    }
+    rememberSettledHostRequest(requestIdArg) {
+        this.settledHostRequestIds.delete(requestIdArg);
+        this.settledHostRequestIds.add(requestIdArg);
+        while (this.settledHostRequestIds.size > flexIpcMaximumPendingRequests * 4) {
+            const oldest = this.settledHostRequestIds.values().next().value;
+            if (oldest === undefined)
+                break;
+            this.settledHostRequestIds.delete(oldest);
+        }
+    }
+    normalizeDeadline(selectedArg, defaultArg, nameArg) {
+        const selected = selectedArg ?? defaultArg;
+        if (!Number.isSafeInteger(selected) || selected < 1 || selected > defaultArg) {
+            throw new Error(`${nameArg} must be a safe integer between 1 and ${defaultArg}.`);
+        }
+        return selected;
+    }
+    consumeLog(streamArg, chunkArg, accumulatorArg) {
+        const bytes = typeof chunkArg === 'string'
+            ? Buffer.from(chunkArg, 'utf8')
+            : chunkArg instanceof Uint8Array
+                ? chunkArg
+                : undefined;
+        if (!bytes)
+            return;
+        let text = accumulatorArg.decoder.decode(bytes, { stream: true });
+        while (text.length > 0) {
+            if (accumulatorArg.dropping) {
+                const newline = text.indexOf('\n');
+                if (newline < 0)
+                    return;
+                accumulatorArg.dropping = false;
+                text = text.slice(newline + 1);
+                continue;
+            }
+            const newline = text.indexOf('\n');
+            if (newline >= 0) {
+                const complete = `${accumulatorArg.partial}${text.slice(0, newline)}`.replace(/\r$/u, '');
+                accumulatorArg.partial = '';
+                this.addLog(streamArg, complete);
+                text = text.slice(newline + 1);
+                continue;
+            }
+            const complete = `${accumulatorArg.partial}${text}`;
+            if (Buffer.byteLength(complete, 'utf8') > supervisorLogLineBytes) {
+                this.addLog(streamArg, complete);
+                accumulatorArg.partial = '';
+                accumulatorArg.dropping = true;
+            }
+            else {
+                accumulatorArg.partial = complete;
+            }
+            return;
+        }
+    }
+    flushLog(streamArg, accumulatorArg) {
+        const final = accumulatorArg.decoder.decode();
+        if (final)
+            this.consumeLog(streamArg, final, accumulatorArg);
+        if (accumulatorArg.partial && !accumulatorArg.dropping) {
+            this.addLog(streamArg, accumulatorArg.partial);
+        }
+        accumulatorArg.partial = '';
+        accumulatorArg.dropping = false;
+    }
+    addLog(streamArg, lineArg) {
+        const bounded = truncateLog(lineArg);
+        this.logs.push({
+            timestamp: Date.now(),
+            stream: streamArg,
+            line: bounded.line,
+            truncated: bounded.truncated,
+        });
+        if (this.logs.length > supervisorLogEntries) {
+            this.logs.splice(0, this.logs.length - supervisorLogEntries);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexsupervisor.js","sourceRoot":"","sources":["../../ts/classes.flexsupervisor.ts"],"names":[],"mappings":"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"}