@kin-tio/cli 0.6.2 → 0.7.0

package/dist/src/ilink/cli-accounts.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import { openIlinkOperatorControl, } from './cli-login.js';
+function choices(accounts, runtimeActive) {
+    return accounts.map((account, index) => `  ${index + 1}. ${JSON.stringify(account.providerAccountId)} ` +
+        `${account.accountKey} [` +
+        `${runtimeActive && account.runtimeEnabled ? 'running' : 'stopped'}]`).join('\n');
+}
+function selectAccount(accounts, selector, runtimeActive) {
+    if (accounts.length === 0) {
+        throw new Error('No iLink account is enrolled; run "kintio ilink login" first');
+    }
+    if (!selector) {
+        if (accounts.length === 1)
+            return accounts[0];
+        throw new Error(`Multiple iLink accounts are enrolled; use --account with one choice:\n` +
+            choices(accounts, runtimeActive));
+    }
+    const matches = accounts.filter((account) => account.accountKey === selector || account.providerAccountId === selector);
+    if (matches.length !== 1) {
+        throw new Error(`Unknown or ambiguous iLink account ${JSON.stringify(selector)}:\n` +
+            choices(accounts, runtimeActive));
+    }
+    return matches[0];
+}
+export async function runIlinkAccountCommand({ command, selector, confirmed = false, config, packageRoot, signal, stdout, openControl, }) {
+    if (!openControl && !fs.existsSync(config.state.databaseFile)) {
+        if (command === 'list') {
+            stdout('No iLink accounts enrolled.\n');
+            return { startForeground: false, runningCount: 0 };
+        }
+        throw new Error('No iLink account is enrolled; run "kintio ilink login" first');
+    }
+    const control = await (openControl?.() ||
+        openIlinkOperatorControl(config, packageRoot, signal));
+    try {
+        const accounts = await control.listAccounts();
+        const runtimeActive = control.mode === 'runtime';
+        if (command === 'list') {
+            stdout(accounts.length
+                ? `${choices(accounts, runtimeActive)}\n`
+                : 'No iLink accounts enrolled.\n');
+            return {
+                startForeground: false,
+                runningCount: accounts.filter((account) => account.runtimeEnabled).length,
+            };
+        }
+        const account = selectAccount(accounts, selector, runtimeActive);
+        if (command === 'delete' && !confirmed) {
+            throw new Error(`Deleting ${JSON.stringify(account.providerAccountId)} permanently removes the account, ` +
+                'credentials, conversations, messages, media, send records, and audit records; ' +
+                'repeat with --yes');
+        }
+        const result = command === 'delete'
+            ? await control.deleteAccount(account.accountKey)
+            : await control.setAccountRuntime(account.accountKey, command === 'start');
+        stdout(`${command === 'delete' ? 'Deleted' : command === 'start' ? 'Started' : 'Stopped'} ` +
+            `${JSON.stringify(account.providerAccountId)}.\n`);
+        return {
+            startForeground: command === 'start' && control.mode === 'standalone',
+            runningCount: result.runningCount,
+        };
+    }
+    finally {
+        await control.close();
+    }
+}

package/dist/src/ilink/cli-login.js

@@ -0,0 +1,563 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { assertTrustedDirectory } from '../lib/private-directory.js';
+import { findMcpDescriptorFile, operatorMcpInstanceKey, } from '../mcp/ipc-protocol.js';
+import { KINTIO_VERSION } from '../version.js';
+import { acquireSingleInstanceLock, SingleInstanceLockError, } from '../runtime/single-instance-lock.js';
+import { StatePersistence } from '../state/persistence.js';
+import { createIlinkEnrollmentService } from './enrollment.js';
+import { renderIlinkQrTerminal, renderIlinkRawQrPng, } from './qr.js';
+const STATUS_POLL_MS = 1_000;
+const OFFER_ID = /^qo_[A-Za-z0-9_-]{1,128}$/u;
+const ACCOUNT_KEY = /^ia_[0-9a-f]{40}$/u;
+const LOGIN_STATUSES = new Set([
+    'waiting',
+    'scanned',
+    'confirmed',
+    'expired',
+    'failed',
+    'cancelled',
+    'already_connected',
+    'verification_required',
+    'unknown',
+]);
+function prepareQrOutput(filePath) {
+    if (!path.isAbsolute(filePath)) {
+        throw new Error('iLink QR output path must be absolute');
+    }
+    const parentPath = path.dirname(filePath);
+    let parent;
+    try {
+        parent = fs.lstatSync(parentPath);
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            throw new Error(`iLink QR output parent does not exist: ${parentPath}`);
+        }
+        throw error;
+    }
+    if (!parent.isDirectory() || parent.isSymbolicLink()) {
+        throw new Error(`iLink QR output parent is not a regular directory: ${parentPath}`);
+    }
+    assertTrustedDirectory(parentPath, 'iLink QR output directory', true);
+    try {
+        fs.lstatSync(filePath);
+        throw new Error(`iLink QR output already exists: ${filePath}`);
+    }
+    catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
+            throw error;
+        }
+    }
+}
+function writeQrOutput(filePath, png) {
+    let descriptor;
+    let output;
+    let created = false;
+    try {
+        descriptor = fs.openSync(filePath, 'wx', 0o600);
+        created = true;
+        const stat = fs.fstatSync(descriptor);
+        output = Object.freeze({
+            filePath,
+            device: stat.dev,
+            inode: stat.ino,
+        });
+        fs.writeFileSync(descriptor, png);
+        fs.fsyncSync(descriptor);
+        fs.closeSync(descriptor);
+        descriptor = undefined;
+        return output;
+    }
+    catch (error) {
+        const cleanupErrors = [];
+        if (descriptor !== undefined) {
+            try {
+                fs.closeSync(descriptor);
+            }
+            catch (closeError) {
+                cleanupErrors.push(closeError);
+            }
+            descriptor = undefined;
+        }
+        if (created) {
+            try {
+                if (output)
+                    removeQrOutput(output);
+                else
+                    fs.unlinkSync(filePath);
+            }
+            catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
+            }
+        }
+        if (cleanupErrors.length) {
+            throw new AggregateError([error, ...cleanupErrors], 'Unable to remove incomplete iLink QR output');
+        }
+        throw error;
+    }
+}
+function removeQrOutput(output) {
+    let stat;
+    try {
+        stat = fs.lstatSync(output.filePath);
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink() ||
+        stat.dev !== output.device || stat.ino !== output.inode) {
+        throw new Error(`Temporary iLink QR output was replaced and was not removed: ${output.filePath}`);
+    }
+    fs.unlinkSync(output.filePath);
+}
+function record(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Invalid response from the Kintio runtime');
+    }
+    return value;
+}
+function resultError(result) {
+    const content = Array.isArray(result.content) ? result.content : [];
+    const first = content.find((item) => item && typeof item === 'object' && 'type' in item && item.type === 'text');
+    const message = first && typeof first === 'object' && 'text' in first
+        ? String(first.text || '')
+        : '';
+    throw new Error(message || 'The Kintio runtime rejected the iLink login operation');
+}
+function structured(result) {
+    const response = record(result);
+    if (response.isError)
+        resultError(response);
+    return record(response.structuredContent);
+}
+function operatorAccount(value) {
+    const account = record(value);
+    const accountKey = String(account.accountKey || '');
+    const providerAccountId = String(account.providerAccountId || '');
+    if (!ACCOUNT_KEY.test(accountKey) ||
+        !providerAccountId || Buffer.byteLength(providerAccountId, 'utf8') > 512 ||
+        typeof account.runtimeEnabled !== 'boolean') {
+        throw new Error('Invalid iLink account response from the Kintio runtime');
+    }
+    return Object.freeze({
+        accountKey: accountKey,
+        providerAccountId,
+        runtimeEnabled: account.runtimeEnabled,
+    });
+}
+function accountMutation(value) {
+    const runningCount = Number(value.runningCount);
+    if (!Number.isSafeInteger(runningCount) || runningCount < 0) {
+        throw new Error('Invalid iLink runtime count from the Kintio runtime');
+    }
+    return Object.freeze({
+        account: operatorAccount(value.account),
+        runningCount,
+    });
+}
+class McpIlinkOperatorControl {
+    mode = 'runtime';
+    #client;
+    #transport;
+    constructor(client, transport) {
+        this.#client = client;
+        this.#transport = transport;
+    }
+    static async connect(config, packageRoot) {
+        const descriptorFile = findMcpDescriptorFile(path.dirname(config.state.lockFile), operatorMcpInstanceKey(config.state.lockFile));
+        if (!fs.existsSync(descriptorFile)) {
+            throw new Error('Kintio runtime has no local iLink operator control');
+        }
+        const sourceRelay = path.join(packageRoot, 'mcp-relay.ts');
+        const relayFile = fs.existsSync(sourceRelay)
+            ? sourceRelay
+            : path.join(packageRoot, 'dist/mcp-relay.js');
+        const transport = new StdioClientTransport({
+            command: process.execPath,
+            args: [
+                relayFile,
+                '--descriptor',
+                descriptorFile,
+                '--route',
+                'operator',
+            ],
+            stderr: 'pipe',
+        });
+        const stderr = transport.stderr;
+        if (stderr && 'resume' in stderr && typeof stderr.resume === 'function')
+            stderr.resume();
+        const client = new Client({ name: 'kintio-cli', version: KINTIO_VERSION });
+        try {
+            await client.connect(transport);
+            return new McpIlinkOperatorControl(client, transport);
+        }
+        catch (error) {
+            try {
+                await transport.close();
+            }
+            catch { }
+            throw new Error('Kintio runtime is not available for iLink operator control', {
+                cause: error,
+            });
+        }
+    }
+    async begin(signal) {
+        const value = structured(await this.#client.callTool({ name: 'begin_login', arguments: {} }, undefined, { signal, timeout: 30_000 }));
+        const offerId = String(value.offerId || '');
+        const qrContent = String(value.qrContent || '');
+        const expiresAt = Number(value.expiresAt || 0);
+        if (!OFFER_ID.test(offerId) || !qrContent ||
+            Buffer.byteLength(qrContent, 'utf8') > 2_048 ||
+            !Number.isSafeInteger(expiresAt) || expiresAt <= 0)
+            throw new Error('Invalid iLink login offer from the Kintio runtime');
+        return { offerId, qrContent, expiresAt };
+    }
+    async status(offerId, signal) {
+        const value = structured(await this.#client.callTool({ name: 'login_status', arguments: { offerId } }, undefined, { signal, timeout: 5_000 }));
+        const status = String(value.status || '');
+        if (!LOGIN_STATUSES.has(status)) {
+            throw new Error('Invalid iLink login status from the Kintio runtime');
+        }
+        return { status };
+    }
+    async cancel(offerId) {
+        const value = structured(await this.#client.callTool({ name: 'cancel_login', arguments: { offerId } }, undefined, { timeout: 5_000 }));
+        if (typeof value.cancelled !== 'boolean') {
+            throw new Error('Invalid iLink cancellation response from the Kintio runtime');
+        }
+        return value.cancelled;
+    }
+    async listAccounts() {
+        const value = structured(await this.#client.callTool({ name: 'list_accounts', arguments: {} }, undefined, { timeout: 5_000 }));
+        if (!Array.isArray(value.accounts) || value.accounts.length > 1_000) {
+            throw new Error('Invalid iLink account list from the Kintio runtime');
+        }
+        return Object.freeze(value.accounts.map(operatorAccount));
+    }
+    async setAccountRuntime(accountKey, enabled) {
+        return accountMutation(structured(await this.#client.callTool({
+            name: enabled ? 'start_account' : 'stop_account',
+            arguments: { accountKey },
+        }, undefined, { timeout: 10_000 })));
+    }
+    async deleteAccount(accountKey) {
+        return accountMutation(structured(await this.#client.callTool({ name: 'delete_account', arguments: { accountKey } }, undefined, { timeout: 10_000 })));
+    }
+    async close() {
+        try {
+            await this.#client.close();
+        }
+        catch { }
+        try {
+            await this.#transport.close();
+        }
+        catch { }
+    }
+}
+class LocalIlinkOperatorControl {
+    mode = 'standalone';
+    #persistence;
+    #lock;
+    #config;
+    #accounts;
+    #enrollment;
+    #enrollmentStarted;
+    #closed = false;
+    constructor(persistence, lock, config) {
+        this.#persistence = persistence;
+        this.#lock = lock;
+        this.#config = config;
+        this.#accounts = persistence.createIlinkStore();
+    }
+    static async open(config) {
+        const lock = acquireSingleInstanceLock({
+            filePath: config.state.lockFile,
+            hasActiveDatabaseOwner: () => StatePersistence.hasActiveWriter(config.state.databaseFile),
+        });
+        let persistence;
+        try {
+            persistence = new StatePersistence({ filePath: config.state.databaseFile });
+            return new LocalIlinkOperatorControl(persistence, lock, config);
+        }
+        catch (error) {
+            const cleanupErrors = [];
+            try {
+                persistence?.close();
+            }
+            catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
+            }
+            if (!persistence || persistence.closed) {
+                try {
+                    if (!lock.release())
+                        cleanupErrors.push(new Error('iLink operator lock was not released'));
+                }
+                catch (cleanupError) {
+                    cleanupErrors.push(cleanupError);
+                }
+            }
+            else {
+                cleanupErrors.push(new Error('iLink state stayed open; its instance lock was retained'));
+            }
+            if (cleanupErrors.length) {
+                throw new AggregateError([error, ...cleanupErrors], 'Standalone iLink login initialization and cleanup both failed');
+            }
+            throw error;
+        }
+    }
+    async #startEnrollment() {
+        this.#enrollment ||= createIlinkEnrollmentService({
+            persistence: this.#persistence,
+            config: this.#config.ilink,
+        });
+        this.#enrollmentStarted ||= this.#enrollment.manager.start();
+        await this.#enrollmentStarted;
+        return this.#enrollment;
+    }
+    async begin(signal) {
+        const enrollment = await this.#startEnrollment();
+        return enrollment.manager.offer({ kind: 'terminal' }, signal ? { signal } : {});
+    }
+    status(offerId) {
+        if (!this.#enrollment)
+            throw new Error('No iLink login is active');
+        return Promise.resolve(this.#enrollment.manager.status(offerId));
+    }
+    cancel(offerId) {
+        return Promise.resolve(this.#enrollment?.manager.cancel(offerId) || false);
+    }
+    listAccounts() {
+        return Promise.resolve(Object.freeze(this.#accounts.listActiveAccounts().map((account) => ({
+            accountKey: account.accountKey,
+            providerAccountId: account.providerAccountId,
+            runtimeEnabled: account.runtimeEnabled,
+        }))));
+    }
+    setAccountRuntime(accountKey, enabled) {
+        const account = enabled
+            ? this.#accounts.selectRuntimeAccount(accountKey)
+            : this.#accounts.setRuntimeEnabled(accountKey, false);
+        return Promise.resolve({
+            account: {
+                accountKey: account.accountKey,
+                providerAccountId: account.providerAccountId,
+                runtimeEnabled: account.runtimeEnabled,
+            },
+            runningCount: this.#accounts.listRuntimeAccountsWithSecrets().length,
+        });
+    }
+    deleteAccount(accountKey) {
+        const account = this.#accounts.deleteAccountCompletely(accountKey);
+        return Promise.resolve({
+            account: {
+                accountKey: account.accountKey,
+                providerAccountId: account.providerAccountId,
+                runtimeEnabled: account.runtimeEnabled,
+            },
+            runningCount: this.#accounts.listRuntimeAccountsWithSecrets().length,
+        });
+    }
+    async close() {
+        if (this.#closed)
+            return;
+        const errors = [];
+        if (this.#enrollment) {
+            try {
+                await this.#enrollment.manager.close();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        try {
+            this.#persistence.core.checkpoint('TRUNCATE');
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        try {
+            this.#persistence.close();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        if (this.#persistence.closed) {
+            try {
+                if (!this.#lock.release())
+                    errors.push(new Error('iLink operator lock was not released'));
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        else {
+            errors.push(new Error('iLink state stayed open; its instance lock was retained'));
+        }
+        this.#closed = this.#persistence.closed;
+        if (errors.length) {
+            throw new AggregateError(errors, 'Standalone iLink login cleanup failed');
+        }
+    }
+}
+export async function openIlinkOperatorControl(config, packageRoot, signal) {
+    try {
+        return await McpIlinkOperatorControl.connect(config, packageRoot);
+    }
+    catch (ipcError) {
+        try {
+            return await LocalIlinkOperatorControl.open(config);
+        }
+        catch (localError) {
+            if (!(localError instanceof SingleInstanceLockError))
+                throw localError;
+            if (localError.owner?.pid !== process.pid) {
+                const deadline = Date.now() + 5_000;
+                while (!signal.aborted && Date.now() < deadline) {
+                    await delay(100, undefined, { signal });
+                    try {
+                        return await McpIlinkOperatorControl.connect(config, packageRoot);
+                    }
+                    catch { }
+                }
+            }
+            throw new Error('This Kintio instance is running, but its private iLink operator control is unavailable', { cause: ipcError });
+        }
+    }
+}
+function defaultSleep(milliseconds, signal) {
+    return delay(milliseconds, undefined, { signal });
+}
+function terminalMessage(status) {
+    switch (status) {
+        case 'confirmed': return 'iLink login succeeded.\n';
+        case 'expired': return 'iLink login QR code expired.\n';
+        case 'cancelled': return 'iLink login was cancelled.\n';
+        case 'already_connected':
+            return 'The iLink account is already connected; host authorization is confirmed.\n';
+        case 'verification_required':
+            return 'This iLink login requires verification that the CLI does not support.\n';
+        case 'failed': return 'iLink login failed.\n';
+        case 'unknown': return 'The iLink login session is no longer available.\n';
+    }
+}
+function aborted(error, signal) {
+    return signal.aborted || (error instanceof Error && error.name === 'AbortError');
+}
+async function cancelQuietly(control, offerId) {
+    try {
+        await control.cancel(offerId);
+    }
+    catch { }
+}
+async function cancelOrReadFinal(control, offerId) {
+    try {
+        if (await control.cancel(offerId))
+            return 'cancelled';
+    }
+    catch { }
+    try {
+        return (await control.status(offerId, new AbortController().signal)).status;
+    }
+    catch {
+        return undefined;
+    }
+}
+function loginSucceeded(status) {
+    return status === 'confirmed' || status === 'already_connected';
+}
+export async function runIlinkCliLogin(options) {
+    if (!options.stdoutIsTTY && !options.qrOutputPath) {
+        throw new Error('iLink login requires an interactive terminal, or use --qr-output <file>');
+    }
+    if (options.qrOutputPath)
+        prepareQrOutput(options.qrOutputPath);
+    const clock = options.clock || Date.now;
+    const sleep = options.sleep || defaultSleep;
+    const openControl = options.openControl || (() => openIlinkOperatorControl(options.config, options.packageRoot, options.signal));
+    let control;
+    let offerId = '';
+    let qrOutput;
+    try {
+        control = await openControl();
+        const offer = await control.begin(options.signal);
+        offerId = offer.offerId;
+        if (options.qrOutputPath) {
+            qrOutput = writeQrOutput(options.qrOutputPath, await renderIlinkRawQrPng(offer.qrContent));
+            options.stdout(`Temporary QR image: ${JSON.stringify(options.qrOutputPath)}\n` +
+                'Scan it with WeChat within 5 minutes. The file will be removed when login ends.\n' +
+                'Waiting for scan...\n');
+        }
+        else {
+            const qr = renderIlinkQrTerminal(offer.qrContent);
+            if (options.stdoutColumns < qr.columns) {
+                await cancelQuietly(control, offerId);
+                offerId = '';
+                throw new Error(`Terminal is too narrow for this QR code; ${qr.columns} columns are required`);
+            }
+            options.stdout(`Scan this QR code with WeChat within 5 minutes:\n\n${qr.text}\n` +
+                'Waiting for scan...\n');
+        }
+        let lastStatus = 'waiting';
+        while (true) {
+            const current = await control.status(offerId, options.signal);
+            if (current.status === 'scanned' && lastStatus !== 'scanned') {
+                options.stdout('QR scanned. Confirm the login in WeChat.\n');
+            }
+            if (current.status !== 'waiting' && current.status !== 'scanned') {
+                options.stdout(terminalMessage(current.status));
+                offerId = '';
+                return loginSucceeded(current.status) ? 0 : 1;
+            }
+            lastStatus = current.status;
+            if (clock() >= offer.expiresAt) {
+                const finalStatus = await cancelOrReadFinal(control, offerId);
+                offerId = '';
+                if (finalStatus && finalStatus !== 'cancelled') {
+                    options.stdout(terminalMessage(finalStatus === 'waiting' || finalStatus === 'scanned'
+                        ? 'expired'
+                        : finalStatus));
+                    return loginSucceeded(finalStatus) ? 0 : 1;
+                }
+                options.stdout(terminalMessage('expired'));
+                return 1;
+            }
+            await sleep(STATUS_POLL_MS, options.signal);
+        }
+    }
+    catch (error) {
+        if (!aborted(error, options.signal)) {
+            const finalStatus = offerId
+                ? await cancelOrReadFinal(control, offerId)
+                : undefined;
+            if (finalStatus && loginSucceeded(finalStatus)) {
+                options.stdout(terminalMessage(finalStatus));
+                return 0;
+            }
+            throw error;
+        }
+        const finalStatus = offerId
+            ? await cancelOrReadFinal(control, offerId)
+            : undefined;
+        if (finalStatus && loginSucceeded(finalStatus)) {
+            options.stdout(terminalMessage(finalStatus));
+            return 0;
+        }
+        options.stdout('iLink login was cancelled.\n');
+        return 130;
+    }
+    finally {
+        try {
+            if (qrOutput)
+                removeQrOutput(qrOutput);
+        }
+        finally {
+            await control?.close();
+        }
+    }
+}

package/dist/src/ilink/cli-start.js

@@ -0,0 +1,57 @@
+import { FORCE_ABORT_TIMEOUT_MS, } from '../config.js';
+import { createRuntime, } from '../runtime.js';
+function waitForAbort(signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        signal.addEventListener('abort', () => resolve(), { once: true });
+    });
+}
+async function closeRuntime(runtime, timeoutMs) {
+    runtime.stopAccepting();
+    let timeout;
+    const timedOut = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => reject(new Error('Graceful iLink shutdown timed out')), timeoutMs);
+    });
+    try {
+        await Promise.race([runtime.close(), timedOut]);
+    }
+    catch (error) {
+        let forceTimer;
+        await Promise.race([
+            runtime.abort().catch(() => undefined),
+            new Promise((resolve) => {
+                forceTimer = setTimeout(resolve, FORCE_ABORT_TIMEOUT_MS);
+            }),
+        ]);
+        clearTimeout(forceTimer);
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function startIlinkCliRuntime(options) {
+    if (options.signal.aborted)
+        return 130;
+    const create = options.create || createRuntime;
+    let requestStop;
+    const stopRequested = new Promise((resolve) => { requestStop = resolve; });
+    const runtime = await create({
+        config: options.config,
+        ...(options.logger ? { logger: options.logger } : {}),
+        onIlinkStopRequested: requestStop,
+    });
+    try {
+        await runtime.start();
+        options.stdout('Kintio iLink runtime is active. Press Ctrl-C to stop.\n');
+        const reason = await Promise.race([
+            waitForAbort(options.signal).then(() => 'signal'),
+            stopRequested.then(() => 'account-stop'),
+        ]);
+        return reason === 'signal' ? 130 : 0;
+    }
+    finally {
+        await closeRuntime(runtime, options.config.state.shutdownTimeoutMs);
+    }
+}