agl 1.0.17 → 21.0.2

package/dist_ts/classes.opencodesupervisor.js

@@ -0,0 +1,1003 @@
+import * as plugins from './plugins.js';
+import { openCodeExpectedVersion, openCodeUsername, } from './interfaces.opencode.js';
+import { createSanitizedRuntimeEnvironment } from './functions.runtimeenvironment.js';
+const defaultStartupTimeoutMs = 20_000;
+const defaultHealthRequestTimeoutMs = 1_500;
+const defaultHealthPollIntervalMs = 150;
+const defaultStopTimeoutMs = 5_000;
+const defaultFinalStopTimeoutMs = 2_000;
+const defaultLogEntryLimit = 200;
+const defaultLogLineByteLimit = 8 * 1024;
+const maxHealthResponseBytes = 32 * 1024;
+const logTruncationSuffix = '… [truncated]';
+const macOsLsofPath = '/usr/sbin/lsof';
+class OpenCodeVersionMismatchError extends Error {
+}
+class OpenCodeListenerOwnershipError extends Error {
+}
+const validateIntegerOption = (value, fallback, name, minimum, maximum) => {
+    const selected = value ?? fallback;
+    if (!Number.isInteger(selected) || selected < minimum || selected > maximum) {
+        throw new Error(`${name} must be an integer between ${minimum} and ${maximum}.`);
+    }
+    return selected;
+};
+const waitForPauseOrLifecycle = async (milliseconds, lifecycle, signal) => {
+    let timeout;
+    let abortListener;
+    try {
+        const outcomes = [
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(undefined), milliseconds);
+            }),
+            lifecycle,
+        ];
+        if (signal) {
+            outcomes.push(new Promise((resolve) => {
+                if (signal.aborted) {
+                    resolve({ type: 'abort', reason: signal.reason });
+                    return;
+                }
+                abortListener = () => resolve({ type: 'abort', reason: signal.reason });
+                signal.addEventListener('abort', abortListener, { once: true });
+            }));
+        }
+        return await Promise.race(outcomes);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        if (signal && abortListener) {
+            signal.removeEventListener('abort', abortListener);
+        }
+    }
+};
+const waitForStartupOperation = async (operation, lifecycle, signal) => {
+    let abortListener;
+    try {
+        const outcomes = [
+            operation.then((value) => ({ type: 'value', value }), (error) => ({ type: 'operationError', error })),
+            lifecycle.then((outcome) => ({ type: 'lifecycle', outcome })),
+        ];
+        if (signal) {
+            outcomes.push(new Promise((resolve) => {
+                if (signal.aborted) {
+                    resolve({ type: 'abort', reason: signal.reason });
+                    return;
+                }
+                abortListener = () => resolve({ type: 'abort', reason: signal.reason });
+                signal.addEventListener('abort', abortListener, { once: true });
+            }));
+        }
+        return await Promise.race(outcomes);
+    }
+    finally {
+        if (signal && abortListener) {
+            signal.removeEventListener('abort', abortListener);
+        }
+    }
+};
+const startupAbortError = (reason) => reason instanceof Error
+    ? reason
+    : new Error('OpenCode startup was aborted.', { cause: reason });
+const waitBounded = async (promise, timeoutMs) => {
+    let timeout;
+    try {
+        return await Promise.race([
+            promise.then(() => true),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(false), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+};
+const isMissingProcessError = (errorArg) => typeof errorArg === 'object'
+    && errorArg !== null
+    && 'code' in errorArg
+    && errorArg.code === 'ESRCH';
+const defaultProcessGroupController = {
+    isAlive: (processGroupIdArg) => {
+        try {
+            process.kill(-processGroupIdArg, 0);
+            return true;
+        }
+        catch (errorArg) {
+            if (isMissingProcessError(errorArg))
+                return false;
+            throw errorArg;
+        }
+    },
+    signal: (processGroupIdArg, signalArg) => {
+        try {
+            process.kill(-processGroupIdArg, signalArg);
+        }
+        catch (errorArg) {
+            if (!isMissingProcessError(errorArg))
+                throw errorArg;
+        }
+    },
+};
+const waitForProcessGroupExit = async (processGroupControllerArg, processGroupIdArg, timeoutMsArg) => {
+    const deadline = Date.now() + timeoutMsArg;
+    while (await processGroupControllerArg.isAlive(processGroupIdArg)) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+            return false;
+        await new Promise((resolve) => {
+            setTimeout(resolve, Math.min(20, remainingMs));
+        });
+    }
+    return true;
+};
+const truncateLogLine = (value, byteLimit) => {
+    if (Buffer.byteLength(value, 'utf8') <= byteLimit) {
+        return { line: value, truncated: false };
+    }
+    const suffixBytes = Buffer.byteLength(logTruncationSuffix, 'utf8');
+    const contentBytes = Math.max(0, byteLimit - suffixBytes);
+    let line = Buffer.from(value, 'utf8').subarray(0, contentBytes).toString('utf8');
+    line = line.replace(/\uFFFD$/u, '');
+    return {
+        line: `${line}${logTruncationSuffix}`,
+        truncated: true,
+    };
+};
+const readBoundedResponseText = async (response) => {
+    if (!response.body) {
+        return '';
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let byteLength = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            byteLength += value.byteLength;
+            if (byteLength > maxHealthResponseBytes) {
+                await reader.cancel('OpenCode health response exceeded its size limit.');
+                throw new Error('OpenCode health response exceeded its size limit.');
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const body = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(body);
+};
+const createOpenCodeEnvironment = (password) => {
+    const environment = createSanitizedRuntimeEnvironment();
+    environment.OPENCODE_SERVER_USERNAME = openCodeUsername;
+    environment.OPENCODE_SERVER_PASSWORD = password;
+    return environment;
+};
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const detectLinuxLibc = () => {
+    const report = process.report?.getReport();
+    if (isRecord(report)) {
+        const header = isRecord(report.header) ? report.header : undefined;
+        if (typeof header?.glibcVersionRuntime === 'string' &&
+            header.glibcVersionRuntime.length > 0) {
+            return 'glibc';
+        }
+        if (Array.isArray(report.sharedObjects) &&
+            report.sharedObjects.some((entry) => typeof entry === 'string' &&
+                (entry.includes('/ld-musl-') || entry.includes('/libc.musl-')))) {
+            return 'musl';
+        }
+    }
+    if (plugins.fs.existsSync('/etc/alpine-release')) {
+        return 'musl';
+    }
+    throw new Error('Unable to determine whether this Linux runtime uses glibc or musl.');
+};
+const resolvePlatformPackage = () => {
+    if (process.platform === 'linux') {
+        const libcSuffix = detectLinuxLibc() === 'musl' ? '-musl' : '';
+        if (process.arch === 'x64') {
+            return {
+                packageName: `opencode-linux-x64-baseline${libcSuffix}`,
+                binaryName: 'opencode',
+            };
+        }
+        if (process.arch === 'arm64') {
+            return {
+                packageName: `opencode-linux-arm64${libcSuffix}`,
+                binaryName: 'opencode',
+            };
+        }
+    }
+    else if (process.platform === 'darwin') {
+        if (process.arch === 'x64') {
+            return {
+                packageName: 'opencode-darwin-x64-baseline',
+                binaryName: 'opencode',
+            };
+        }
+        if (process.arch === 'arm64') {
+            return {
+                packageName: 'opencode-darwin-arm64',
+                binaryName: 'opencode',
+            };
+        }
+    }
+    else if (process.platform === 'win32') {
+        if (process.arch === 'x64') {
+            return {
+                packageName: 'opencode-windows-x64-baseline',
+                binaryName: 'opencode.exe',
+            };
+        }
+        if (process.arch === 'arm64') {
+            return {
+                packageName: 'opencode-windows-arm64',
+                binaryName: 'opencode.exe',
+            };
+        }
+    }
+    throw new Error(`OpenCode does not provide a supported package for ${process.platform}/${process.arch}.`);
+};
+const collectLinuxLoopbackListenerInodes = (port) => {
+    const portHex = port.toString(16).toUpperCase().padStart(4, '0');
+    const expectedAddress = `0100007F:${portHex}`;
+    const inodes = new Set();
+    const table = plugins.fs.readFileSync('/proc/net/tcp', 'utf8');
+    for (const line of table.split('\n').slice(1)) {
+        const fields = line.trim().split(/\s+/u);
+        if (fields.length >= 10 && fields[1] === expectedAddress && fields[3] === '0A') {
+            inodes.add(fields[9]);
+        }
+    }
+    return inodes;
+};
+const verifyLinuxListenerOwnership = (processId, port) => {
+    const listenerInodes = collectLinuxLoopbackListenerInodes(port);
+    if (listenerInodes.size === 0) {
+        return false;
+    }
+    const descriptorDirectory = `/proc/${processId}/fd`;
+    let descriptorNames;
+    try {
+        descriptorNames = plugins.fs.readdirSync(descriptorDirectory);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw new Error(`Unable to inspect OpenCode process ${processId} file descriptors.`, {
+            cause: error,
+        });
+    }
+    for (const descriptorName of descriptorNames) {
+        let target;
+        try {
+            target = plugins.fs.readlinkSync(plugins.path.join(descriptorDirectory, descriptorName));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                continue;
+            }
+            throw new Error(`Unable to inspect OpenCode process ${processId} socket ownership.`, {
+                cause: error,
+            });
+        }
+        const match = /^socket:\[(\d+)\]$/u.exec(target);
+        if (match?.[1] && listenerInodes.has(match[1])) {
+            return true;
+        }
+    }
+    return false;
+};
+const verifyMacOsListenerOwnership = (processId, port) => {
+    const result = plugins.childProcess.spawnSync(macOsLsofPath, [
+        '-nP',
+        '-a',
+        '-p',
+        String(processId),
+        `-iTCP@127.0.0.1:${port}`,
+        '-sTCP:LISTEN',
+        '-Fpn',
+    ], {
+        encoding: 'utf8',
+        maxBuffer: 64 * 1024,
+        timeout: 1_500,
+        windowsHide: true,
+    });
+    if (result.error) {
+        throw new Error('Unable to inspect OpenCode listener ownership with lsof.', {
+            cause: result.error,
+        });
+    }
+    if (result.status === 1) {
+        return false;
+    }
+    if (result.status !== 0) {
+        throw new Error(`lsof failed while inspecting OpenCode with status ${result.status}.`);
+    }
+    const lines = result.stdout.split(/\r?\n/u);
+    return (lines.includes(`p${processId}`) &&
+        lines.some((line) => line === `n127.0.0.1:${port}`));
+};
+const verifyWindowsListenerOwnership = (processId, port) => {
+    const systemRoot = process.env.SystemRoot;
+    if (!systemRoot || !plugins.path.isAbsolute(systemRoot)) {
+        throw new Error('SystemRoot is unavailable for Windows listener ownership verification.');
+    }
+    const resolvedSystemRoot = plugins.fs.realpathSync.native(systemRoot);
+    const netstatPath = plugins.fs.realpathSync.native(plugins.path.join(resolvedSystemRoot, 'System32', 'netstat.exe'));
+    const relativeNetstatPath = plugins.path.relative(resolvedSystemRoot, netstatPath);
+    if (relativeNetstatPath.startsWith(`..${plugins.path.sep}`) ||
+        relativeNetstatPath === '..' ||
+        plugins.path.isAbsolute(relativeNetstatPath)) {
+        throw new Error('The Windows netstat executable escaped SystemRoot.');
+    }
+    const result = plugins.childProcess.spawnSync(netstatPath, ['-ano', '-p', 'tcp'], {
+        encoding: 'utf8',
+        maxBuffer: 2 * 1024 * 1024,
+        timeout: 1_500,
+        windowsHide: true,
+    });
+    if (result.error) {
+        throw new Error('Unable to inspect OpenCode listener ownership with netstat.', {
+            cause: result.error,
+        });
+    }
+    if (result.status !== 0) {
+        throw new Error(`netstat failed while inspecting OpenCode with status ${result.status}.`);
+    }
+    const expectedEndpoint = `127.0.0.1:${port}`;
+    return result.stdout.split(/\r?\n/u).some((line) => {
+        const fields = line.trim().split(/\s+/u);
+        return (fields.length >= 5 &&
+            fields[0]?.toUpperCase() === 'TCP' &&
+            fields[1] === expectedEndpoint &&
+            fields[3]?.toUpperCase() === 'LISTENING' &&
+            fields[4] === String(processId));
+    });
+};
+export const verifyOpenCodeListenerOwnership = (processId, port) => {
+    if (!Number.isSafeInteger(processId) || processId <= 0) {
+        return false;
+    }
+    if (process.platform === 'linux') {
+        return verifyLinuxListenerOwnership(processId, port);
+    }
+    if (process.platform === 'darwin') {
+        return verifyMacOsListenerOwnership(processId, port);
+    }
+    if (process.platform === 'win32') {
+        return verifyWindowsListenerOwnership(processId, port);
+    }
+    throw new Error(`Listener ownership verification is unsupported on ${process.platform}.`);
+};
+export class OpenCodeSupervisor {
+    directory;
+    port;
+    baseUrl;
+    executablePath;
+    password;
+    startupTimeoutMs;
+    healthRequestTimeoutMs;
+    healthPollIntervalMs;
+    stopTimeoutMs;
+    finalStopTimeoutMs;
+    logEntryLimit;
+    logLineByteLimit;
+    spawnFactory;
+    fetchImplementation;
+    listenerOwnershipVerifier;
+    processGroupController;
+    onChildExit;
+    state = 'stopped';
+    healthy = false;
+    version;
+    startedAt;
+    child;
+    childLifecycle;
+    ownedProcessGroupId;
+    orphanedProcessGroupId;
+    orphanReapTask;
+    childExitCleanupPending = false;
+    startPromise;
+    stopPromise;
+    logs = [];
+    stdoutAccumulator = {
+        decoder: new TextDecoder(),
+        partial: '',
+        droppingUntilNewline: false,
+    };
+    stderrAccumulator = {
+        decoder: new TextDecoder(),
+        partial: '',
+        droppingUntilNewline: false,
+    };
+    constructor(options) {
+        this.directory = plugins.fs.realpathSync.native(options.directory);
+        const directoryStat = plugins.fs.statSync(this.directory);
+        if (!directoryStat.isDirectory()) {
+            throw new Error('The configured OpenCode working directory is not a directory.');
+        }
+        this.port = validateIntegerOption(options.port, options.port, 'OpenCode port', 1, 65_535);
+        this.baseUrl = `http://127.0.0.1:${this.port}`;
+        this.startupTimeoutMs = validateIntegerOption(options.startupTimeoutMs, defaultStartupTimeoutMs, 'OpenCode startup timeout', 1, 300_000);
+        this.healthRequestTimeoutMs = validateIntegerOption(options.healthRequestTimeoutMs, defaultHealthRequestTimeoutMs, 'OpenCode health request timeout', 1, 60_000);
+        this.healthPollIntervalMs = validateIntegerOption(options.healthPollIntervalMs, defaultHealthPollIntervalMs, 'OpenCode health poll interval', 1, 60_000);
+        this.stopTimeoutMs = validateIntegerOption(options.stopTimeoutMs, defaultStopTimeoutMs, 'OpenCode stop timeout', 1, 300_000);
+        this.finalStopTimeoutMs = validateIntegerOption(options.finalStopTimeoutMs, defaultFinalStopTimeoutMs, 'OpenCode final stop timeout', 1, 60_000);
+        this.logEntryLimit = validateIntegerOption(options.logEntryLimit, defaultLogEntryLimit, 'OpenCode log entry limit', 1, 10_000);
+        this.logLineByteLimit = validateIntegerOption(options.logLineByteLimit, defaultLogLineByteLimit, 'OpenCode log line byte limit', 16, 1024 * 1024);
+        this.spawnFactory = options.spawnFactory ?? plugins.childProcess.spawn;
+        this.fetchImplementation = options.fetchImplementation ?? globalThis.fetch;
+        this.listenerOwnershipVerifier =
+            options.listenerOwnershipVerifier ?? verifyOpenCodeListenerOwnership;
+        this.processGroupController = process.platform !== 'win32'
+            && (options.spawnFactory === undefined || options.processGroupController !== undefined)
+            ? (options.processGroupController ?? defaultProcessGroupController)
+            : undefined;
+        this.onChildExit = options.onChildExit;
+        this.password = plugins.crypto.randomBytes(32).toString('base64url');
+        this.executablePath = this.resolveExecutablePath();
+    }
+    getStatus() {
+        return {
+            state: this.state,
+            healthy: this.healthy,
+            ...(this.child?.pid ? { pid: this.child.pid } : {}),
+            ...(this.version ? { version: this.version } : {}),
+            ...(this.startedAt ? { startedAt: this.startedAt } : {}),
+        };
+    }
+    getConnectionConfig() {
+        return {
+            baseUrl: this.baseUrl,
+            directory: this.directory,
+            username: openCodeUsername,
+            password: this.password,
+        };
+    }
+    getLogSnapshot() {
+        return this.logs.map((entry) => ({ ...entry }));
+    }
+    async start(signal) {
+        if (this.state === 'ready' && this.child) {
+            return this.getStatus();
+        }
+        if (this.startPromise) {
+            return this.startPromise;
+        }
+        if (this.state === 'stopping') {
+            throw new Error('OpenCode cannot start while it is stopping.');
+        }
+        const startPromise = this.performStart(signal);
+        this.startPromise = startPromise;
+        try {
+            return await startPromise;
+        }
+        finally {
+            if (this.startPromise === startPromise) {
+                this.startPromise = undefined;
+            }
+        }
+    }
+    async checkHealth() {
+        try {
+            const health = await this.fetchHealth();
+            this.healthy = true;
+            this.version = health.version;
+            return health;
+        }
+        catch (error) {
+            this.healthy = false;
+            throw error;
+        }
+    }
+    async stop() {
+        if (this.stopPromise) {
+            return this.stopPromise;
+        }
+        const child = this.child;
+        const lifecycle = this.childLifecycle;
+        if (!child || !lifecycle) {
+            if (this.ownedProcessGroupId !== undefined) {
+                throw new Error('OpenCode process-group ownership outlived child lifecycle tracking.');
+            }
+            await this.drainOrphanedProcessGroup();
+            this.child = undefined;
+            this.childLifecycle = undefined;
+            this.healthy = false;
+            this.state = 'stopped';
+            this.startedAt = undefined;
+            return;
+        }
+        const stopPromise = this.performStop(child, lifecycle);
+        this.stopPromise = stopPromise;
+        try {
+            await stopPromise;
+        }
+        finally {
+            if (this.stopPromise === stopPromise) {
+                this.stopPromise = undefined;
+            }
+        }
+    }
+    resolveExecutablePath() {
+        const require = plugins.createRequire(import.meta.url);
+        const platformPackage = resolvePlatformPackage();
+        const platformPackageJsonPath = plugins.fs.realpathSync.native(require.resolve(`${platformPackage.packageName}/package.json`));
+        const installedPackageJson = JSON.parse(plugins.fs.readFileSync(platformPackageJsonPath, 'utf8'));
+        if (!isRecord(installedPackageJson) ||
+            installedPackageJson.name !== platformPackage.packageName ||
+            installedPackageJson.version !== openCodeExpectedVersion) {
+            throw new Error(`Expected ${platformPackage.packageName} ${openCodeExpectedVersion}.`);
+        }
+        const packageDirectory = plugins.fs.realpathSync.native(plugins.path.dirname(platformPackageJsonPath));
+        const executablePath = plugins.fs.realpathSync.native(plugins.path.join(packageDirectory, 'bin', platformPackage.binaryName));
+        const relativeExecutablePath = plugins.path.relative(packageDirectory, executablePath);
+        if (relativeExecutablePath.startsWith(`..${plugins.path.sep}`) ||
+            relativeExecutablePath === '..' ||
+            plugins.path.isAbsolute(relativeExecutablePath)) {
+            throw new Error('The package-owned OpenCode executable escaped its package directory.');
+        }
+        const executableStat = plugins.fs.statSync(executablePath);
+        if (!executableStat.isFile() ||
+            (process.platform !== 'win32' && (executableStat.mode & 0o111) === 0)) {
+            throw new Error('The package-owned OpenCode executable is not a file.');
+        }
+        return executablePath;
+    }
+    async performStart(signal) {
+        this.state = 'starting';
+        this.healthy = false;
+        this.version = undefined;
+        this.startedAt = undefined;
+        try {
+            signal?.throwIfAborted();
+            const child = this.spawnFactory(this.executablePath, [
+                'serve',
+                '--hostname',
+                '127.0.0.1',
+                '--port',
+                String(this.port),
+                '--mdns=false',
+                '--print-logs',
+            ], {
+                cwd: this.directory,
+                detached: this.processGroupController !== undefined,
+                shell: false,
+                windowsHide: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: createOpenCodeEnvironment(this.password),
+            });
+            this.child = child;
+            this.childLifecycle = this.observeChild(child);
+            if (!child.pid) {
+                throw new Error('OpenCode did not provide a process ID after spawn.');
+            }
+            if (this.processGroupController) {
+                this.ownedProcessGroupId = child.pid;
+            }
+            const deadline = Date.now() + this.startupTimeoutMs;
+            let lastHealthError;
+            while (Date.now() < deadline) {
+                const lifecycle = this.childLifecycle;
+                if (!lifecycle) {
+                    throw new Error('OpenCode child lifecycle tracking was lost.');
+                }
+                const ownershipOutcome = await waitForStartupOperation(Promise.resolve().then(() => this.listenerOwnershipVerifier(child.pid, this.port)), lifecycle, signal);
+                if (ownershipOutcome.type === 'abort') {
+                    throw startupAbortError(ownershipOutcome.reason);
+                }
+                if (ownershipOutcome.type === 'lifecycle') {
+                    throw this.lifecycleError(ownershipOutcome.outcome, 'OpenCode exited during startup.');
+                }
+                if (ownershipOutcome.type === 'operationError') {
+                    throw new OpenCodeListenerOwnershipError('OpenCode listener ownership could not be verified.', { cause: ownershipOutcome.error });
+                }
+                const listenerOwned = ownershipOutcome.value;
+                if (!listenerOwned) {
+                    lastHealthError = new OpenCodeListenerOwnershipError('The loopback listener is not owned by the spawned OpenCode process.');
+                    const remainingMs = deadline - Date.now();
+                    if (remainingMs <= 0) {
+                        break;
+                    }
+                    const pauseOutcome = await waitForPauseOrLifecycle(Math.min(this.healthPollIntervalMs, remainingMs), lifecycle, signal);
+                    if (pauseOutcome) {
+                        if (pauseOutcome.type === 'abort') {
+                            throw startupAbortError(pauseOutcome.reason);
+                        }
+                        throw this.lifecycleError(pauseOutcome, 'OpenCode exited during startup.');
+                    }
+                    continue;
+                }
+                const healthOutcome = await waitForStartupOperation(this.fetchHealth(signal), lifecycle, signal);
+                if (healthOutcome.type === 'abort') {
+                    throw startupAbortError(healthOutcome.reason);
+                }
+                if (healthOutcome.type === 'lifecycle') {
+                    throw this.lifecycleError(healthOutcome.outcome, 'OpenCode exited during startup.');
+                }
+                if (healthOutcome.type === 'value') {
+                    const secondOwnershipOutcome = await waitForStartupOperation(Promise.resolve().then(() => this.listenerOwnershipVerifier(child.pid, this.port)), lifecycle, signal);
+                    if (secondOwnershipOutcome.type === 'abort') {
+                        throw startupAbortError(secondOwnershipOutcome.reason);
+                    }
+                    if (secondOwnershipOutcome.type === 'lifecycle') {
+                        throw this.lifecycleError(secondOwnershipOutcome.outcome, 'OpenCode exited during startup.');
+                    }
+                    if (secondOwnershipOutcome.type === 'operationError') {
+                        throw new OpenCodeListenerOwnershipError('OpenCode listener ownership could not be reverified.', { cause: secondOwnershipOutcome.error });
+                    }
+                    const stillOwned = secondOwnershipOutcome.value;
+                    if (!stillOwned) {
+                        throw new OpenCodeListenerOwnershipError('OpenCode lost ownership of its loopback listener during startup.');
+                    }
+                    if (child.exitCode !== null || child.signalCode !== null || this.child !== child) {
+                        throw new Error('OpenCode exited while completing its health check.');
+                    }
+                    this.healthy = true;
+                    this.version = healthOutcome.value.version;
+                    this.startedAt = Date.now();
+                    this.state = 'ready';
+                    return this.getStatus();
+                }
+                lastHealthError = healthOutcome.error;
+                if (lastHealthError instanceof OpenCodeVersionMismatchError) {
+                    throw lastHealthError;
+                }
+                const remainingMs = deadline - Date.now();
+                if (remainingMs <= 0) {
+                    break;
+                }
+                const pauseOutcome = await waitForPauseOrLifecycle(Math.min(this.healthPollIntervalMs, remainingMs), lifecycle, signal);
+                if (pauseOutcome) {
+                    if (pauseOutcome.type === 'abort') {
+                        throw startupAbortError(pauseOutcome.reason);
+                    }
+                    throw this.lifecycleError(pauseOutcome, 'OpenCode exited during startup.');
+                }
+            }
+            throw new Error(`OpenCode did not become healthy within ${this.startupTimeoutMs}ms.`, {
+                cause: lastHealthError,
+            });
+        }
+        catch (error) {
+            let cleanupError;
+            try {
+                await this.stop();
+            }
+            catch (caughtCleanupError) {
+                cleanupError = caughtCleanupError;
+            }
+            this.state = 'failed';
+            this.healthy = false;
+            this.startedAt = undefined;
+            if (cleanupError) {
+                throw new AggregateError([error, cleanupError], 'OpenCode startup failed and its child process could not be cleaned up.');
+            }
+            throw new Error('OpenCode startup failed.', { cause: error });
+        }
+    }
+    /**
+     * best-effort reaping of group members that survived their leader's exit.
+     * Runs at exit time because that is when the pgid is still provably ours:
+     * living members keep it reserved, and an already-empty group answers ESRCH.
+     */
+    async reapOrphanedGroup(processGroupIdArg) {
+        if (!this.processGroupController)
+            return;
+        if (!(await this.processGroupController.isAlive(processGroupIdArg)))
+            return;
+        await this.processGroupController.signal(processGroupIdArg, 'SIGTERM');
+        let exited = await waitForProcessGroupExit(this.processGroupController, processGroupIdArg, this.stopTimeoutMs);
+        if (!exited) {
+            await this.processGroupController.signal(processGroupIdArg, 'SIGKILL');
+            exited = await waitForProcessGroupExit(this.processGroupController, processGroupIdArg, this.finalStopTimeoutMs);
+        }
+        if (!exited)
+            throw new Error('An owned OpenCode process-group member survived SIGKILL.');
+    }
+    notifyChildExitCleanup() {
+        if (!this.childExitCleanupPending)
+            return;
+        this.childExitCleanupPending = false;
+        try {
+            this.onChildExit?.();
+        }
+        catch {
+            // Child lifecycle cleanup must not prevent lifecycle settlement.
+        }
+    }
+    async drainOrphanedProcessGroup() {
+        const orphanReapTask = this.orphanReapTask;
+        if (orphanReapTask)
+            await orphanReapTask;
+        const processGroupId = this.orphanedProcessGroupId;
+        if (processGroupId !== undefined) {
+            await this.reapOrphanedGroup(processGroupId);
+            if (this.orphanedProcessGroupId === processGroupId) {
+                this.orphanedProcessGroupId = undefined;
+            }
+        }
+        this.notifyChildExitCleanup();
+    }
+    observeChild(child) {
+        child.stdout?.on('data', (chunk) => {
+            this.consumeLogChunk('stdout', chunk, this.stdoutAccumulator);
+        });
+        child.stderr?.on('data', (chunk) => {
+            this.consumeLogChunk('stderr', chunk, this.stderrAccumulator);
+        });
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = (outcome) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                this.flushLogAccumulator('stdout', this.stdoutAccumulator);
+                this.flushLogAccumulator('stderr', this.stderrAccumulator);
+                this.healthy = false;
+                // once the group leader is gone the kernel may recycle its pid, so a
+                // LATER stop() must never signal this group — but surviving group
+                // descendants must still be reaped NOW, while living members keep the
+                // pgid reserved and therefore safely targetable
+                const orphanedGroupId = this.ownedProcessGroupId;
+                this.ownedProcessGroupId = undefined;
+                this.childExitCleanupPending = true;
+                if (orphanedGroupId !== undefined && this.processGroupController) {
+                    this.orphanedProcessGroupId = orphanedGroupId;
+                    let reap;
+                    reap = this.reapOrphanedGroup(orphanedGroupId).then(() => {
+                        if (this.orphanedProcessGroupId === orphanedGroupId) {
+                            this.orphanedProcessGroupId = undefined;
+                        }
+                        this.notifyChildExitCleanup();
+                    }).finally(() => {
+                        if (this.orphanReapTask === reap)
+                            this.orphanReapTask = undefined;
+                    });
+                    this.orphanReapTask = reap;
+                    void reap.catch(() => undefined);
+                }
+                else {
+                    this.notifyChildExitCleanup();
+                }
+                if (this.state === 'stopping') {
+                    this.state = 'stopped';
+                }
+                else if (this.state === 'starting' || this.state === 'ready') {
+                    this.state = 'failed';
+                }
+                resolve(outcome);
+            };
+            child.once('exit', (code, signal) => {
+                finish({ type: 'exit', code, signal });
+            });
+            child.once('error', (error) => {
+                this.addLogEntry('stderr', `OpenCode process error: ${error.message}`, false);
+                if (!child.pid) {
+                    finish({ type: 'error', error });
+                }
+            });
+        });
+    }
+    async fetchHealth(callerSignal) {
+        callerSignal?.throwIfAborted();
+        const requestAbortController = new AbortController();
+        const abortFromCaller = () => {
+            requestAbortController.abort(callerSignal?.reason);
+        };
+        callerSignal?.addEventListener('abort', abortFromCaller, { once: true });
+        if (callerSignal?.aborted) {
+            abortFromCaller();
+        }
+        const timeout = setTimeout(() => {
+            requestAbortController.abort(new Error(`OpenCode health request exceeded ${this.healthRequestTimeoutMs}ms.`));
+        }, this.healthRequestTimeoutMs);
+        timeout.unref();
+        const authorization = Buffer.from(`${openCodeUsername}:${this.password}`, 'utf8').toString('base64');
+        try {
+            const response = await this.fetchImplementation(`${this.baseUrl}/global/health`, {
+                method: 'GET',
+                headers: {
+                    Accept: 'application/json',
+                    Authorization: `Basic ${authorization}`,
+                },
+                redirect: 'error',
+                signal: requestAbortController.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`OpenCode health check returned HTTP ${response.status}.`);
+            }
+            const body = await readBoundedResponseText(response);
+            let parsed;
+            try {
+                parsed = JSON.parse(body);
+            }
+            catch (error) {
+                throw new Error('OpenCode health check returned invalid JSON.', { cause: error });
+            }
+            if (typeof parsed !== 'object' ||
+                parsed === null ||
+                !('healthy' in parsed) ||
+                !('version' in parsed) ||
+                parsed.healthy !== true ||
+                typeof parsed.version !== 'string') {
+                throw new Error('OpenCode health check returned an invalid payload.');
+            }
+            if (parsed.version !== openCodeExpectedVersion) {
+                throw new OpenCodeVersionMismatchError(`OpenCode reported version ${parsed.version}; expected ${openCodeExpectedVersion}.`);
+            }
+            return {
+                healthy: true,
+                version: openCodeExpectedVersion,
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+            callerSignal?.removeEventListener('abort', abortFromCaller);
+        }
+    }
+    async performStop(child, lifecycle) {
+        this.state = 'stopping';
+        this.healthy = false;
+        // a leader that already exited cleared ownedProcessGroupId in observeChild
+        // and handed surviving members to reapOrphanedGroup, so this branch only
+        // ever signals a group whose leader is still ours
+        const ownedProcessGroupId = this.ownedProcessGroupId;
+        if (this.processGroupController && ownedProcessGroupId !== undefined) {
+            let exited = !(await this.processGroupController.isAlive(ownedProcessGroupId));
+            if (!exited) {
+                await this.processGroupController.signal(ownedProcessGroupId, 'SIGTERM');
+                exited = await waitForProcessGroupExit(this.processGroupController, ownedProcessGroupId, this.stopTimeoutMs);
+            }
+            if (!exited) {
+                await this.processGroupController.signal(ownedProcessGroupId, 'SIGKILL');
+                exited = await waitForProcessGroupExit(this.processGroupController, ownedProcessGroupId, this.finalStopTimeoutMs);
+            }
+            if (!exited) {
+                this.state = 'failed';
+                throw new Error('The owned OpenCode process group did not exit after SIGKILL.');
+            }
+            const lifecycleSettled = await waitBounded(lifecycle, this.finalStopTimeoutMs);
+            if (!lifecycleSettled) {
+                this.state = 'failed';
+                throw new Error('OpenCode process-group exit was not confirmed by the child lifecycle.');
+            }
+            this.ownedProcessGroupId = undefined;
+        }
+        else {
+            if (child.exitCode === null && child.signalCode === null) {
+                try {
+                    child.kill('SIGTERM');
+                }
+                catch (error) {
+                    if (child.exitCode === null && child.signalCode === null) {
+                        throw new Error('Failed to send SIGTERM to OpenCode.', { cause: error });
+                    }
+                }
+            }
+            let exited = await waitBounded(lifecycle, this.stopTimeoutMs);
+            if (!exited && child.exitCode === null && child.signalCode === null) {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch (error) {
+                    if (child.exitCode === null && child.signalCode === null) {
+                        throw new Error('Failed to send SIGKILL to OpenCode.', { cause: error });
+                    }
+                }
+                exited = await waitBounded(lifecycle, this.finalStopTimeoutMs);
+            }
+            if (!exited && child.exitCode === null && child.signalCode === null) {
+                this.state = 'failed';
+                throw new Error('OpenCode did not exit after SIGKILL.');
+            }
+        }
+        // a leader that exited on its own may have left a reap task running; stop()
+        // must not return while owned group members are still being signalled
+        await this.drainOrphanedProcessGroup();
+        if (this.child === child) {
+            this.child = undefined;
+        }
+        if (this.childLifecycle === lifecycle) {
+            this.childLifecycle = undefined;
+        }
+        this.state = 'stopped';
+        this.healthy = false;
+        this.startedAt = undefined;
+    }
+    lifecycleError(outcome, message) {
+        if (outcome.type === 'error') {
+            return new Error(message, { cause: outcome.error });
+        }
+        const detail = outcome.signal
+            ? `signal ${outcome.signal}`
+            : `exit code ${String(outcome.code)}`;
+        return new Error(`${message} (${detail})`);
+    }
+    consumeLogChunk(stream, chunk, accumulator) {
+        let bytes;
+        if (typeof chunk === 'string') {
+            bytes = Buffer.from(chunk, 'utf8');
+        }
+        else if (chunk instanceof Uint8Array) {
+            bytes = chunk;
+        }
+        else {
+            return;
+        }
+        let text = accumulator.decoder.decode(bytes, { stream: true });
+        while (text.length > 0) {
+            if (accumulator.droppingUntilNewline) {
+                const newlineIndex = text.indexOf('\n');
+                if (newlineIndex === -1) {
+                    return;
+                }
+                accumulator.droppingUntilNewline = false;
+                text = text.slice(newlineIndex + 1);
+                continue;
+            }
+            const newlineIndex = text.indexOf('\n');
+            if (newlineIndex !== -1) {
+                const completeLine = `${accumulator.partial}${text.slice(0, newlineIndex)}`.replace(/\r$/u, '');
+                accumulator.partial = '';
+                const bounded = truncateLogLine(completeLine, this.logLineByteLimit);
+                this.addLogEntry(stream, bounded.line, bounded.truncated);
+                text = text.slice(newlineIndex + 1);
+                continue;
+            }
+            const combined = `${accumulator.partial}${text}`;
+            if (Buffer.byteLength(combined, 'utf8') > this.logLineByteLimit) {
+                const bounded = truncateLogLine(combined, this.logLineByteLimit);
+                this.addLogEntry(stream, bounded.line, true);
+                accumulator.partial = '';
+                accumulator.droppingUntilNewline = true;
+            }
+            else {
+                accumulator.partial = combined;
+            }
+            return;
+        }
+    }
+    flushLogAccumulator(stream, accumulator) {
+        const finalText = accumulator.decoder.decode();
+        if (finalText) {
+            this.consumeLogChunk(stream, finalText, accumulator);
+        }
+        if (accumulator.partial && !accumulator.droppingUntilNewline) {
+            const bounded = truncateLogLine(accumulator.partial, this.logLineByteLimit);
+            this.addLogEntry(stream, bounded.line, bounded.truncated);
+        }
+        accumulator.partial = '';
+        accumulator.droppingUntilNewline = false;
+    }
+    addLogEntry(stream, line, truncated) {
+        this.logs.push({
+            timestamp: Date.now(),
+            stream,
+            line,
+            truncated,
+        });
+        const excessEntries = this.logs.length - this.logEntryLimit;
+        if (excessEntries > 0) {
+            this.logs.splice(0, excessEntries);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.opencodesupervisor.js","sourceRoot":"","sources":["../../ts/classes.opencodesupervisor.ts"],"names":[],"mappings":"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"}