@minionry/minion 0.7.36

package/dist/server/engines/codex/CodexEngine.js

@@ -0,0 +1,469 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn as nodeSpawn } from 'node:child_process';
+import { hlog } from '../../cli/headless/headless-logger.js';
+import { BROWSER_MCP_SERVER_NAME, BROWSER_SYSTEM_PROMPT, buildBrowserMcpEntry, isCompetingBrowserServer, } from '../../cli/headless/mcp-config.js';
+import { killProcessGroup } from '../../cli/headless/runner.js';
+import { isDirectory } from '../../services/pathUtils.js';
+import { resolveModelProfile, } from '../credentials/model-profiles.js';
+import { CODEX_PROVIDER_ID, getApiKey } from '../credentials/provider-credentials.js';
+import { EngineEventStream } from '../engine-event-stream.js';
+import { sessionIsReadOnly } from '../read-only.js';
+import { AppRunUnsupportedError, } from '../types.js';
+import { probeCodexChatGptConnected } from './codex-auth.js';
+import { CodexEventMapper } from './codex-invoker.js';
+const CODEX_MCP_LIST_ARGS = ['mcp', 'list', '--json'];
+function defaultListMcpServerNames(command, env) {
+    return new Promise((resolve) => {
+        const child = nodeSpawn(command, [...CODEX_MCP_LIST_ARGS], {
+            env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let out = '';
+        const CAP = 200_000;
+        child.stdout?.on('data', (chunk) => {
+            out = (out + chunk.toString('utf8')).slice(0, CAP);
+        });
+        child.stderr?.on('data', () => { });
+        child.on('error', () => resolve([]));
+        child.on('close', (code) => resolve(code === 0 ? parseCodexMcpServerNames(out) : []));
+    });
+}
+export function resolveCodexReasoningEffort(effortLevel) {
+    if (!effortLevel || effortLevel === 'auto')
+        return undefined;
+    return effortLevel === 'ultracode' ? 'ultra' : effortLevel;
+}
+const TOML_ESCAPES = {
+    '"': '\\"',
+    '\\': '\\\\',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+};
+export function tomlBasicString(text) {
+    let out = '"';
+    for (const ch of text) {
+        const mapped = TOML_ESCAPES[ch];
+        if (mapped !== undefined) {
+            out += mapped;
+            continue;
+        }
+        const code = ch.codePointAt(0) ?? 0;
+        out += code < 0x20 || code === 0x7f ? `\\u${code.toString(16).padStart(4, '0')}` : ch;
+    }
+    return `${out}"`;
+}
+function tomlKey(name) {
+    return /^[A-Za-z0-9_-]+$/.test(name) ? name : tomlBasicString(name);
+}
+function tomlInlineTable(entries) {
+    return `{${entries.map(([k, v]) => `${tomlKey(k)}=${v}`).join(',')}}`;
+}
+export function parseCodexMcpServerNames(stdout) {
+    try {
+        const parsed = JSON.parse(stdout);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .map((row) => row?.name)
+            .filter((name) => typeof name === 'string' && name.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+export function buildCodexBrowserMcpArgs(browserMcp, userServerNames = []) {
+    const entry = buildBrowserMcpEntry(browserMcp);
+    const servers = [
+        [
+            BROWSER_MCP_SERVER_NAME,
+            tomlInlineTable([
+                ['command', tomlBasicString(entry.command)],
+                ['args', `[${entry.args.map(tomlBasicString).join(',')}]`],
+                [
+                    'env',
+                    tomlInlineTable(Object.entries(entry.env).map(([k, v]) => [k, tomlBasicString(v)])),
+                ],
+            ]),
+        ],
+    ];
+    for (const name of userServerNames) {
+        if (!isCompetingBrowserServer(name))
+            continue;
+        servers.push([name, '{enabled=false}']);
+    }
+    return ['-c', `mcp_servers=${tomlInlineTable(servers)}`];
+}
+export const CODEX_PROFILE_KEY_ENV = 'MINIONRY_CODEX_PROFILE_KEY';
+export function buildCodexProfileInvocation(resolved) {
+    const { profile, apiKey } = resolved;
+    if (!profile.baseUrl) {
+        return {
+            model: profile.model,
+            args: [],
+            env: apiKey ? { CODEX_API_KEY: apiKey } : {},
+        };
+    }
+    const providerId = `minionry_${profile.id.replace(/[^A-Za-z0-9_-]/g, '_')}`;
+    const table = `model_providers.${providerId}`;
+    const args = [
+        '-c',
+        `model_provider=${tomlBasicString(providerId)}`,
+        '-c',
+        `${table}.name=${tomlBasicString(profile.label)}`,
+        '-c',
+        `${table}.base_url=${tomlBasicString(profile.baseUrl)}`,
+        '-c',
+        `${table}.env_key=${tomlBasicString(CODEX_PROFILE_KEY_ENV)}`,
+    ];
+    if (profile.wireApi) {
+        args.push('-c', `${table}.wire_api=${tomlBasicString(profile.wireApi)}`);
+    }
+    return {
+        model: profile.model,
+        args,
+        env: apiKey ? { [CODEX_PROFILE_KEY_ENV]: apiKey } : {},
+    };
+}
+export function buildCodexDeveloperInstructions(systemPrompt, browserMcpActive) {
+    const parts = [browserMcpActive ? BROWSER_SYSTEM_PROMPT : '', systemPrompt ?? ''].filter(Boolean);
+    return parts.length > 0 ? parts.join('\n\n') : undefined;
+}
+export class CodexEngine extends EngineEventStream {
+    engineId = 'codex';
+    resolveCommand;
+    spawn;
+    sandboxPreset;
+    getStoredApiKey;
+    probeChatGptSession;
+    listMcpServerNames;
+    userMcpServerNames = null;
+    sessionOptions = null;
+    mapper = new CodexEventMapper();
+    turnEndedByStream = false;
+    lastStreamEventWasError = false;
+    resumeAttemptId;
+    currentChild = null;
+    currentRunSettled = null;
+    cancelling = false;
+    disposed = false;
+    constructor(options = {}) {
+        super();
+        this.resolveCommand =
+            options.resolveCommand ?? (() => process.env.CODEX_COMMAND || 'codex');
+        this.spawn = options.spawn ?? nodeSpawn;
+        this.sandboxPreset = options.sandboxPreset ?? 'workspace-write';
+        this.getStoredApiKey = options.getStoredApiKey ?? (() => getApiKey(CODEX_PROVIDER_ID));
+        this.probeChatGptSession =
+            options.probeChatGptSession ?? ((command) => probeCodexChatGptConnected(command));
+        this.listMcpServerNames = options.listMcpServerNames ?? defaultListMcpServerNames;
+    }
+    resolveApiKey() {
+        const stored = this.getStoredApiKey()?.trim();
+        if (stored)
+            return stored;
+        const fromEnv = process.env.CODEX_API_KEY?.trim();
+        return fromEnv || undefined;
+    }
+    get codexThreadId() {
+        return this.mapper.threadId;
+    }
+    async startSession(options) {
+        if (this.sessionOptions) {
+            throw new Error('CodexEngine: startSession called more than once');
+        }
+        if (this.disposed) {
+            throw new Error('CodexEngine: cannot start a disposed engine');
+        }
+        if (options.appRun) {
+            throw new AppRunUnsupportedError('codex', 'Codex has no confined app-run profile');
+        }
+        this.sessionOptions = options;
+        this.mapper = new CodexEventMapper({ resumeThreadId: options.resumeSessionId });
+    }
+    async sendPrompt(prompt, attachments) {
+        if (!this.sessionOptions) {
+            throw new Error('CodexEngine: sendPrompt called before startSession');
+        }
+        if (this.disposed) {
+            throw new Error('CodexEngine: sendPrompt called after dispose');
+        }
+        if (this.currentChild) {
+            throw new Error('CodexEngine: another prompt is already in flight');
+        }
+        const opts = this.sessionOptions;
+        this.cancelling = false;
+        this.turnEndedByStream = false;
+        this.lastStreamEventWasError = false;
+        const resumeId = this.codexThreadId;
+        this.resumeAttemptId = resumeId;
+        let command;
+        try {
+            command = await this.resolveCommand();
+        }
+        catch (err) {
+            this.emit({
+                kind: 'engine.error',
+                sessionId: this.sessionIdForEvent(),
+                timestamp: Date.now(),
+                code: 'CODEX_NOT_PROVISIONED',
+                message: err instanceof Error ? err.message : String(err),
+                fatal: true,
+            });
+            return;
+        }
+        if (this.disposed || this.currentChild)
+            return;
+        const { apiKey, invocation, credentialed } = this.resolveCredentials(opts);
+        if (!credentialed && !(await this.hasChatGptSession(command))) {
+            this.emit({
+                kind: 'engine.error',
+                sessionId: this.sessionIdForEvent(),
+                timestamp: Date.now(),
+                code: 'CODEX_NO_CREDENTIAL',
+                message: 'No Codex credential found. Connect Codex in Settings to run Codex sessions.',
+                fatal: true,
+            });
+            return;
+        }
+        await this.ensureUserMcpServerNames(command, opts);
+        if (this.disposed || this.currentChild)
+            return;
+        let child;
+        try {
+            child = this.spawn(command, this.buildArgs(prompt, opts, resumeId, attachments, invocation), {
+                cwd: opts.workingDir,
+                env: {
+                    ...process.env,
+                    ...opts.extraEnv,
+                    ...(apiKey ? { CODEX_API_KEY: apiKey } : {}),
+                    ...(invocation?.env ?? {}),
+                },
+                detached: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch (err) {
+            this.emitSpawnFailure(err);
+            return;
+        }
+        this.currentChild = child;
+        this.wireChild(child);
+    }
+    emitSpawnFailure(err) {
+        this.currentChild = null;
+        const cwd = this.sessionOptions?.workingDir ?? '';
+        const errno = err?.code;
+        const cwdGone = (errno === 'ENOENT' || errno === 'ENOTDIR') && !isDirectory(cwd);
+        this.emit({
+            kind: 'engine.error',
+            sessionId: this.sessionIdForEvent(),
+            timestamp: Date.now(),
+            code: cwdGone ? 'WORKING_DIRECTORY_NOT_FOUND' : 'CODEX_SPAWN_ERROR',
+            message: cwdGone
+                ? `Could not start Codex: its working directory ${cwd} is not a directory — it may have been moved, renamed, or deleted.`
+                : err instanceof Error ? err.message : String(err),
+            fatal: true,
+        });
+    }
+    async cancel() {
+        if (!this.currentChild)
+            return;
+        this.cancelling = true;
+        this.killCurrentChild();
+        if (this.currentRunSettled) {
+            await this.currentRunSettled;
+        }
+    }
+    getUsage() {
+        return this.mapper.getUsage();
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.killCurrentChild();
+        if (this.currentRunSettled) {
+            await this.currentRunSettled;
+        }
+        this.closeIterator();
+    }
+    resolveCredentials(opts) {
+        const profile = resolveModelProfile(opts.model);
+        const invocation = profile ? buildCodexProfileInvocation(profile) : undefined;
+        const apiKey = invocation ? undefined : this.resolveApiKey();
+        return {
+            apiKey,
+            invocation,
+            credentialed: apiKey !== undefined || Object.keys(invocation?.env ?? {}).length > 0,
+        };
+    }
+    buildArgs(prompt, opts, resumeId, attachments, 
+    profileInvocation) {
+        const args = [
+            'exec',
+            '--json',
+            '--skip-git-repo-check',
+            '--sandbox',
+            sessionIsReadOnly(opts) ? 'read-only' : this.sandboxPreset,
+        ];
+        const model = profileInvocation?.model ?? opts.model;
+        if (model) {
+            args.push('-m', model);
+        }
+        if (profileInvocation?.args.length) {
+            args.push(...profileInvocation.args);
+        }
+        const effort = resolveCodexReasoningEffort(opts.effortLevel);
+        if (effort) {
+            args.push('-c', `model_reasoning_effort=${effort}`);
+        }
+        if (opts.browserMcp) {
+            args.push(...buildCodexBrowserMcpArgs(opts.browserMcp, this.userMcpServerNames ?? []));
+        }
+        const developerInstructions = buildCodexDeveloperInstructions(opts.systemPrompt, !!opts.browserMcp);
+        if (developerInstructions) {
+            args.push('-c', `developer_instructions=${tomlBasicString(developerInstructions)}`);
+        }
+        for (const attachment of attachments ?? []) {
+            if (attachment.isImage && attachment.filePath) {
+                args.push('-i', attachment.filePath);
+            }
+        }
+        if (resumeId) {
+            args.push('resume', resumeId);
+        }
+        args.push(prompt);
+        return args;
+    }
+    async hasChatGptSession(command) {
+        try {
+            return await this.probeChatGptSession(command);
+        }
+        catch {
+            return false;
+        }
+    }
+    async ensureUserMcpServerNames(command, opts) {
+        if (!opts.browserMcp || this.userMcpServerNames)
+            return;
+        try {
+            this.userMcpServerNames = await this.listMcpServerNames(command, {
+                ...process.env,
+                ...opts.extraEnv,
+            });
+        }
+        catch (err) {
+            this.userMcpServerNames = [];
+            hlog(`[codex] could not list configured MCP servers (${err instanceof Error ? err.message : String(err)}); competing browser servers will not be disabled for this session`);
+        }
+    }
+    sessionIdForEvent() {
+        return this.mapper.threadId ?? 'pending';
+    }
+    ingestLine(line) {
+        for (const event of this.mapper.ingest(line)) {
+            if (event.kind === 'session.idle')
+                this.turnEndedByStream = true;
+            this.lastStreamEventWasError = event.kind === 'engine.error';
+            this.emit(event);
+        }
+    }
+    wireChild(child) {
+        let settleRun = () => { };
+        this.currentRunSettled = new Promise((resolve) => {
+            settleRun = resolve;
+        });
+        let settled = false;
+        const settle = () => {
+            if (settled)
+                return;
+            settled = true;
+            settleRun();
+        };
+        let stdoutBuffer = '';
+        let stderrBuffer = '';
+        child.stdout?.on('data', (chunk) => {
+            stdoutBuffer += chunk.toString();
+            let newlineIdx = stdoutBuffer.indexOf('\n');
+            while (newlineIdx >= 0) {
+                const line = stdoutBuffer.slice(0, newlineIdx).trim();
+                stdoutBuffer = stdoutBuffer.slice(newlineIdx + 1);
+                if (line)
+                    this.ingestLine(line);
+                newlineIdx = stdoutBuffer.indexOf('\n');
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderrBuffer += chunk.toString();
+        });
+        child.on('error', (err) => {
+            this.emitSpawnFailure(err);
+            settle();
+        });
+        child.on('close', (code, signal) => {
+            const trailing = stdoutBuffer.trim();
+            if (trailing)
+                this.ingestLine(trailing);
+            stdoutBuffer = '';
+            this.currentChild = null;
+            this.onChildClose(code, signal, stderrBuffer.trim());
+            settle();
+        });
+    }
+    onChildClose(code, signal, stderr) {
+        if (this.disposed)
+            return;
+        if (!this.cancelling && code !== null && code !== 0) {
+            this.emitRunFailure(code, stderr);
+            this.degradeFailedResume(code);
+        }
+        if (!this.turnEndedByStream) {
+            const stopReason = this.cancelling
+                ? 'cancelled'
+                : code === 0
+                    ? 'end_turn'
+                    : signal
+                        ? signal
+                        : 'error';
+            this.emit({
+                kind: 'session.idle',
+                sessionId: this.sessionIdForEvent(),
+                timestamp: Date.now(),
+                stopReason,
+            });
+        }
+    }
+    emitRunFailure(code, stderr) {
+        if (this.lastStreamEventWasError)
+            return;
+        this.emit({
+            kind: 'engine.error',
+            sessionId: this.sessionIdForEvent(),
+            timestamp: Date.now(),
+            code: 'CODEX_RUN_ERROR',
+            message: stderr || `Codex exited with code ${code}`,
+            fatal: false,
+        });
+    }
+    degradeFailedResume(code) {
+        if (!this.resumeAttemptId)
+            return;
+        hlog(`[codex] resume of thread ${this.resumeAttemptId} failed (exit ${code}); next prompt will start cold`);
+        this.mapper.forgetThread();
+    }
+    killCurrentChild() {
+        const child = this.currentChild;
+        if (!child || child.pid === undefined)
+            return;
+        const pid = child.pid;
+        killProcessGroup(pid, 'SIGTERM');
+        setTimeout(() => {
+            if (!child.killed) {
+                killProcessGroup(pid, 'SIGKILL');
+            }
+        }, 5000).unref?.();
+    }
+}

package/dist/server/engines/codex/codex-auth.js

@@ -0,0 +1,203 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn as nodeSpawn } from 'node:child_process';
+import { CODEX_PROVIDER_ID } from '../credentials/provider-credentials.js';
+import { CodexRuntimeProvisioner, resolveCodexCommand } from './codex-provision.js';
+export const CODEX_LOGIN_DEVICE_AUTH_ARGS = ['login', '--device-auth'];
+export const CODEX_LOGIN_STATUS_ARGS = ['login', 'status'];
+export const DEFAULT_CODEX_LOGIN_TIMEOUT_MS = 15 * 60_000;
+const defaultProbeSpawn = (cmd, args) => new Promise((resolve) => {
+    const child = nodeSpawn(cmd, [...args], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    let out = '';
+    const CAP = 8_000;
+    const append = (chunk) => {
+        out = (out + chunk.toString('utf8')).slice(-CAP);
+    };
+    child.stdout?.on('data', append);
+    child.stderr?.on('data', append);
+    child.on('error', () => resolve({ ok: false, output: out }));
+    child.on('exit', (code) => resolve({ ok: code === 0, output: out }));
+});
+function resolveExistingCodexBinary() {
+    const override = process.env.CODEX_COMMAND?.trim();
+    if (override)
+        return override;
+    return new CodexRuntimeProvisioner().status().binaryPath;
+}
+export async function probeCodexChatGptConnected(command, deps = {}) {
+    const spawnFn = deps.spawn ?? defaultProbeSpawn;
+    const result = await spawnFn(command, CODEX_LOGIN_STATUS_ARGS);
+    if (!result.ok)
+        return false;
+    const out = result.output.toLowerCase();
+    if (/not\s+logged\s+in|logged\s+out|no\s+credentials|not\s+authenticated/.test(out))
+        return false;
+    return /chatgpt/.test(out) && !/api\s*key/.test(out);
+}
+export async function getCodexConnectionStatus(store, deps = {}) {
+    const env = deps.env ?? process.env;
+    const storedKey = store.getApiKey(CODEX_PROVIDER_ID);
+    const envKey = env.CODEX_API_KEY?.trim();
+    const hasApiKey = Boolean(storedKey) || Boolean(envKey);
+    const resolver = deps.resolveCommand ?? resolveExistingCodexBinary;
+    const command = await resolver();
+    const probe = deps.probeChatGpt ?? ((cmd) => probeCodexChatGptConnected(cmd, deps));
+    const chatgptConnected = command ? await probe(command) : false;
+    const method = chatgptConnected ? 'chatgpt' : hasApiKey ? 'api-key' : 'none';
+    return { method, connected: chatgptConnected || hasApiKey, hasApiKey, chatgptConnected };
+}
+const defaultLoginSpawn = (cmd, args, onLine) => {
+    const child = nodeSpawn(cmd, [...args], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    let output = '';
+    const CAP = 16_000;
+    const onData = (chunk) => {
+        const text = chunk.toString('utf8');
+        output = (output + text).slice(-CAP);
+        for (const line of text.split(/\r?\n/)) {
+            if (line.trim().length > 0)
+                onLine(line);
+        }
+    };
+    child.stdout?.on('data', onData);
+    child.stderr?.on('data', onData);
+    const done = new Promise((resolve) => {
+        child.on('error', (err) => resolve({ code: null, output: `${output}\n${err.message}` }));
+        child.on('exit', (code) => resolve({ code, output }));
+    });
+    return {
+        done,
+        kill: () => {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+            }
+        },
+    };
+};
+function matchVerificationUrl(line) {
+    const m = line.match(/(https?:\/\/[^\s"'<>]+)/);
+    return m ? m[1] : undefined;
+}
+function matchUserCode(line) {
+    const hyphenated = line.match(/\b([A-Z0-9]{4}-[A-Z0-9]{4})\b/);
+    if (hyphenated)
+        return hyphenated[1];
+    const labeled = line.match(/code[:\s]+([A-Z0-9]{6,10})\b/i);
+    if (labeled)
+        return labeled[1].toUpperCase();
+    return undefined;
+}
+function buildAwaitMessage(url, code) {
+    return code
+        ? `Open ${url} in your browser, sign in to ChatGPT, then enter the code ${code}.`
+        : `Open ${url} in your browser and sign in to ChatGPT to finish connecting.`;
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function classifyLoginResult(result, ctx) {
+    const base = { verificationUrl: ctx.url, userCode: ctx.code };
+    if (ctx.cancelled) {
+        return { ...base, status: 'cancelled', connected: false, message: 'ChatGPT sign-in was cancelled.' };
+    }
+    if (result.code === 0) {
+        return { ...base, status: 'connected', connected: true, message: 'Connected to your ChatGPT account.' };
+    }
+    if (ctx.timedOut) {
+        return {
+            ...base,
+            status: 'timeout',
+            connected: false,
+            message: 'The sign-in timed out before it completed. Start again to get a fresh code.',
+        };
+    }
+    const out = result.output.toLowerCase();
+    if (/expire|timed?\s*out/.test(out)) {
+        return {
+            ...base,
+            status: 'expired',
+            connected: false,
+            message: 'The one-time code expired before you finished. Start again to get a new code.',
+        };
+    }
+    if (/deni|declined|access_denied|rejected|forbidden/.test(out)) {
+        return {
+            ...base,
+            status: 'denied',
+            connected: false,
+            message: 'The sign-in request was denied. Start again if that was a mistake.',
+        };
+    }
+    return {
+        ...base,
+        status: 'error',
+        connected: false,
+        message: 'ChatGPT sign-in did not complete. Start again, or add an API key instead.',
+    };
+}
+export async function runCodexDeviceLogin(options = {}) {
+    const onProgress = options.onProgress ?? (() => { });
+    const timeoutMs = options.timeoutMs ?? DEFAULT_CODEX_LOGIN_TIMEOUT_MS;
+    onProgress({ status: 'pending', message: 'Starting ChatGPT sign-in…' });
+    let command;
+    try {
+        command = await (options.resolveCommand ?? (() => resolveCodexCommand()))();
+    }
+    catch (err) {
+        return { status: 'error', connected: false, message: errorMessage(err) };
+    }
+    const spawnFn = options.spawnLogin ?? defaultLoginSpawn;
+    let url;
+    let code;
+    const proc = spawnFn(command, CODEX_LOGIN_DEVICE_AUTH_ARGS, (line) => {
+        const foundUrl = matchVerificationUrl(line);
+        const foundCode = matchUserCode(line);
+        let changed = false;
+        if (foundUrl && !url) {
+            url = foundUrl;
+            changed = true;
+        }
+        if (foundCode && !code) {
+            code = foundCode;
+            changed = true;
+        }
+        if (changed && url) {
+            onProgress({
+                status: 'awaiting_user',
+                verificationUrl: url,
+                userCode: code,
+                message: buildAwaitMessage(url, code),
+            });
+        }
+    });
+    let timedOut = false;
+    let cancelled = false;
+    const timer = setTimeout(() => {
+        timedOut = true;
+        proc.kill();
+    }, timeoutMs);
+    const onAbort = () => {
+        cancelled = true;
+        proc.kill();
+    };
+    const signal = options.signal;
+    if (signal) {
+        if (signal.aborted) {
+            cancelled = true;
+            proc.kill();
+        }
+        else {
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
+    }
+    let result;
+    try {
+        result = await proc.done;
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', onAbort);
+    }
+    return classifyLoginResult(result, { timedOut, cancelled, url, code });
+}