@kin-tio/cli 0.6.2 → 0.7.1

package/dist/src/cli.js

@@ -5,9 +5,12 @@ import path from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { parseArgs } from 'node:util';
 import crossSpawn from 'cross-spawn';
-import { DAEMON_STOP_TIMEOUT_MS, loadConfig, parseStartTimeout, resolveProjectRoot, WORKER_GRACEFUL_TIMEOUT_MS, } from './config.js';
+import { DAEMON_STOP_TIMEOUT_MS, loadConfig, loadIlinkEnrollmentConfig, loadIlinkRuntimeConfig, parseStartTimeout, resolveProjectRoot, WORKER_GRACEFUL_TIMEOUT_MS, } from './config.js';
 import { isPathInside, samePath } from './lib/path-identity.js';
 import { assertTrustedDirectory, ensureContainedDirectory, ensurePrivateDirectory, } from './lib/private-directory.js';
+import { runIlinkCliLogin } from './ilink/cli-login.js';
+import { runIlinkAccountCommand } from './ilink/cli-accounts.js';
+import { startIlinkCliRuntime } from './ilink/cli-start.js';
 import { daemonRecordPath, readDaemonRecord, requestControl, } from './runtime/daemon-protocol.js';
 import { acquireSingleInstanceLock, processIsAlive, SingleInstanceLockError, } from './runtime/single-instance-lock.js';
 import { installManagedSkill } from './runtime/managed-skill.js';
@@ -22,6 +25,11 @@ Commands:
   restart               Restart Kintio with the current installation and config
   status                Show the background process status
   logs                  Follow Kintio logs
+  ilink login [options] Connect an iLink account with a QR code
+  ilink list            List enrolled iLink accounts
+  ilink start [options] Start one iLink account without Hono
+  ilink stop [options]  Stop one iLink account
+  ilink delete [options] Permanently delete one iLink account and its data
 
 Options:
   --home <directory>     Instance directory (default: ~/.kintio)
@@ -30,7 +38,132 @@ Options:
   --no-follow            Print logs without following
   -h, --help             Show this help
   -v, --version          Show the Kintio version
+
+Run "kintio ilink --help" for iLink account commands.
+`;
+const ILINK_LOGIN_HELP = `Usage: kintio ilink login [options]
+
+Connect one iLink account, save its encrypted credentials, and exit. This
+command does not require setup, an environment file, Hono, or a running Kintio
+instance. By default, the QR code is rendered directly in an interactive
+terminal and expires after five minutes.
+
+The PNG option is required when stdout is not an interactive terminal. Whoever
+scans this locally issued QR receives the capabilities allowed by the host Agent
+configuration; show it only to an authorized operator.
+
+Options:
+  --qr-output <file>     Write a temporary raw QR PNG instead of terminal blocks
+                         The file must be directly inside the instance directory
+                         The file is removed when the login attempt ends
+  --home <directory>     Instance directory (default: ~/.kintio)
+  --config <file>        Optional environment overrides
+  -h, --help             Show this help
+`;
+const ILINK_START_HELP = `Usage: kintio ilink start [options]
+
+Run iLink long polling and the host Agent in the background without starting
+Hono or opening a TCP listener. This command does not require setup or an
+environment file. One account is selected automatically; multiple accounts
+require --account. Additional start commands add accounts to the same process.
+
+Options:
+  --account <id>        Provider account ID or Kintio account key
+  --foreground          Keep the iLink-only Runtime attached to this terminal
+  --home <directory>     Instance directory (default: ~/.kintio)
+  --config <file>        Optional environment overrides
+  -h, --help             Show this help
+`;
+const ILINK_STOP_HELP = `Usage: kintio ilink stop [options]
+
+Stop one iLink account. Stopping the last account also stops the background
+iLink-only Runtime. One account is selected automatically; multiple
+accounts require --account.
+
+Options:
+  --account <id>        Provider account ID or Kintio account key
+  --home <directory>    Instance directory (default: ~/.kintio)
+  --config <file>       Optional environment overrides
+  -h, --help            Show this help
+`;
+const ILINK_LIST_HELP = `Usage: kintio ilink list [options]
+
+List enrolled iLink accounts and whether each account is currently running.
+
+Options:
+  --home <directory>    Instance directory (default: ~/.kintio)
+  --config <file>       Optional environment overrides
+  -h, --help            Show this help
 `;
+const ILINK_DELETE_HELP = `Usage: kintio ilink delete [options]
+
+Permanently delete one iLink account and all Kintio data scoped to it,
+including credentials, conversations, messages, media, send records, and
+enrollment audit records. This operation cannot be undone.
+
+Options:
+  --account <id>        Provider account ID or Kintio account key
+  --yes                 Confirm permanent deletion
+  --home <directory>    Instance directory (default: ~/.kintio)
+  --config <file>       Optional environment overrides
+  -h, --help            Show this help
+`;
+const ILINK_HELP = `Usage: kintio ilink <command>
+
+Commands:
+  login [options]        Connect an iLink account with a QR code
+  list                   List enrolled accounts
+  start [options]        Start one account without Hono
+  stop [options]         Stop one account
+  delete [options]       Permanently delete one account and its data
+
+Run "kintio ilink <command> --help" for command options.
+`;
+const ILINK_COMMANDS = new Set(['login', 'list', 'start', 'stop', 'delete']);
+const COMMANDS = new Set([
+    'setup',
+    'start',
+    'run',
+    'stop',
+    'restart',
+    'status',
+    'logs',
+    'ilink',
+]);
+const ILINK_SIGNALS = process.platform === 'win32'
+    ? ['SIGINT', 'SIGTERM']
+    : ['SIGINT', 'SIGTERM', 'SIGHUP'];
+function signalExitCode(signal) {
+    if (signal === 'SIGHUP')
+        return 129;
+    if (signal === 'SIGTERM')
+        return 143;
+    return 130;
+}
+async function runWithIlinkSignals(operation) {
+    const controller = new AbortController();
+    let interruptedBy;
+    const interrupt = (signal) => {
+        interruptedBy ||= signal;
+        controller.abort();
+    };
+    const listeners = ILINK_SIGNALS.map((signal) => ({
+        signal,
+        listener: () => interrupt(signal),
+    }));
+    for (const { signal, listener } of listeners)
+        process.once(signal, listener);
+    try {
+        const result = await operation(controller.signal);
+        return result === 130 && interruptedBy
+            ? signalExitCode(interruptedBy)
+            : result;
+    }
+    finally {
+        for (const { signal, listener } of listeners)
+            process.off(signal, listener);
+    }
+}
 function defaultExecute(request) {
     return new Promise((resolve, reject) => {
         const child = crossSpawn(request.file, [...request.args], {
@@ -108,6 +241,11 @@ function runtimeDefaults() {
         launchDaemon: defaultLaunchDaemon,
         stdout: (text) => process.stdout.write(text),
         stderr: (text) => process.stderr.write(text),
+        stdoutIsTTY: Boolean(process.stdout.isTTY),
+        stdoutColumns: process.stdout.columns || 80,
+        ilinkLogin: runIlinkCliLogin,
+        ilinkAccount: runIlinkAccountCommand,
+        ilinkStart: startIlinkCliRuntime,
     };
 }
 function resolveInputPath(value, cwd) {
@@ -273,7 +411,7 @@ async function probeDaemon(location) {
         return undefined;
     }
 }
-function assertDaemonInstance(location, packageRoot) {
+function assertDaemonInstance(location, packageRoot, mode) {
     const daemon = readDaemonRecord(location.home);
     if (!daemon)
         throw new Error('Kintio daemon record is missing');
@@ -281,6 +419,9 @@ function assertDaemonInstance(location, packageRoot) {
         !samePath(daemon.packageRoot, packageRoot)) {
         throw new Error('Kintio is running with another config or installation; use "kintio restart" to switch deliberately');
     }
+    if (mode && daemon.mode !== mode) {
+        throw new Error(`Kintio is already running in ${daemon.mode} mode; stop it before starting ${mode} mode`);
+    }
 }
 async function withLifecycleLock(location, task) {
     const dataDirectory = ensureContainedDirectory(location.home, path.join(location.home, 'data'));
@@ -336,18 +477,19 @@ async function rollbackLaunch(location, daemon) {
     }
     removeLaunchMetadata(location, daemon.pid);
 }
-async function start(location, runtime, restart) {
-    const environment = processEnvironment(location, runtime);
+async function startBackgroundDaemon(location, runtime, environment, mode, restart) {
     const timeout = parseStartTimeout(environment.KINTIO_START_TIMEOUT_MS);
     return withLifecycleLock(location, async () => {
         const existing = await probeDaemon(location);
         if (existing && !restart) {
-            assertDaemonInstance(location, runtime.packageRoot);
+            assertDaemonInstance(location, runtime.packageRoot, mode);
             if (existing.phase !== 'running') {
                 await waitUntilRunning(location, Date.now() + timeout);
             }
-            runtime.stdout(`Kintio is already running (PID ${existing.workerPid || existing.daemonPid}).\n`);
-            return 0;
+            return {
+                alreadyRunning: true,
+                pid: existing.workerPid || existing.daemonPid,
+            };
         }
         if (existing) {
             await stopDaemon(location, DAEMON_STOP_TIMEOUT_MS);
@@ -357,7 +499,7 @@ async function start(location, runtime, restart) {
             file: process.execPath,
             args: [path.join(runtime.packageRoot, 'dist/daemon.js')],
             cwd: location.home,
-            env: environment,
+            env: { ...environment, KINTIO_DAEMON_MODE: mode },
         });
         try {
             await waitUntilRunning(location, deadline);
@@ -366,9 +508,40 @@ async function start(location, runtime, restart) {
             await rollbackLaunch(location, daemon);
             throw error;
         }
-        return 0;
+        const running = await requestControl(location.home, 'ping');
+        return {
+            alreadyRunning: false,
+            pid: running.workerPid || running.daemonPid,
+        };
     });
 }
+async function start(location, runtime, restart) {
+    const result = await startBackgroundDaemon(location, runtime, processEnvironment(location, runtime), 'service', restart);
+    if (result.alreadyRunning) {
+        runtime.stdout(`Kintio is already running (PID ${result.pid}).\n`);
+    }
+    return 0;
+}
+function ilinkDaemonEnvironment(location, runtime) {
+    const config = loadIlinkRuntimeConfig({
+        environment: { ...runtime.env },
+        envFile: location.configFile,
+        root: location.home,
+    });
+    refreshManagedSkill(config.codex.workingDirectory, runtime);
+    return {
+        ...runtime.env,
+        KINTIO_HOME: location.home,
+        KINTIO_CONFIG_FILE: location.configFile,
+        NODE_ENV: 'production',
+    };
+}
+async function startIlinkDaemon(location, runtime) {
+    const result = await startBackgroundDaemon(location, runtime, ilinkDaemonEnvironment(location, runtime), 'ilink', false);
+    if (!result.alreadyRunning) {
+        runtime.stdout(`Kintio iLink runtime is running in background (PID ${result.pid}).\n`);
+    }
+}
 async function waitUntilRunning(location, deadline) {
     let lastError = 'daemon did not publish control state';
     while (Date.now() < deadline) {
@@ -508,6 +681,10 @@ export async function runCli(args, overrides = {}) {
                 config: { type: 'string' },
                 lines: { type: 'string' },
                 'no-follow': { type: 'boolean' },
+                'qr-output': { type: 'string' },
+                account: { type: 'string' },
+                foreground: { type: 'boolean' },
+                yes: { type: 'boolean' },
                 help: { type: 'boolean', short: 'h' },
                 version: { type: 'boolean', short: 'v' },
             },
@@ -517,18 +694,158 @@ export async function runCli(args, overrides = {}) {
             return 0;
         }
         const command = parsed.positionals[0];
-        if (parsed.values.help || !command || command === 'help') {
+        const subcommand = parsed.positionals[1];
+        if (!command) {
+            if (parsed.values['qr-output'] !== undefined) {
+                throw new Error('--qr-output is valid only for "kintio ilink login"');
+            }
             runtime.stdout(HELP);
             return 0;
         }
-        if (parsed.positionals.length !== 1) {
-            throw new Error(`Unexpected argument: ${parsed.positionals[1]}`);
+        if (command === 'help') {
+            if (parsed.positionals.length !== 1) {
+                throw new Error(`Unexpected argument: ${subcommand}`);
+            }
+            runtime.stdout(HELP);
+            return 0;
+        }
+        if (!COMMANDS.has(command))
+            throw new Error(`Unknown command: ${command}`);
+        if (command === 'ilink') {
+            if (parsed.values.help && parsed.positionals.length === 1) {
+                runtime.stdout(ILINK_HELP);
+                return 0;
+            }
+            if (!subcommand || !ILINK_COMMANDS.has(subcommand) ||
+                parsed.positionals.length !== 2) {
+                throw new Error('Usage: kintio ilink <login|list|start|stop|delete>');
+            }
+        }
+        else if (parsed.positionals.length !== 1) {
+            throw new Error(`Unexpected argument: ${subcommand}`);
+        }
+        if (parsed.values.help) {
+            runtime.stdout(command !== 'ilink'
+                ? HELP
+                : subcommand === 'login' ? ILINK_LOGIN_HELP
+                    : subcommand === 'list' ? ILINK_LIST_HELP
+                        : subcommand === 'start' ? ILINK_START_HELP
+                            : subcommand === 'stop' ? ILINK_STOP_HELP
+                                : ILINK_DELETE_HELP);
+            return 0;
         }
         if (command !== 'logs' &&
             (parsed.values.lines !== undefined || parsed.values['no-follow'])) {
             throw new Error('--lines and --no-follow are valid only for "kintio logs"');
         }
+        if ((command !== 'ilink' || subcommand !== 'login') &&
+            parsed.values['qr-output'] !== undefined) {
+            throw new Error('--qr-output is valid only for "kintio ilink login"');
+        }
+        if (parsed.values['qr-output'] === '') {
+            throw new Error('--qr-output requires a non-empty file path');
+        }
+        if (parsed.values.account !== undefined &&
+            (command !== 'ilink' || !['start', 'stop', 'delete'].includes(subcommand || ''))) {
+            throw new Error('--account is valid only for "kintio ilink start|stop|delete"');
+        }
+        if (parsed.values.account === '') {
+            throw new Error('--account requires a non-empty account ID or key');
+        }
+        if (parsed.values.yes && (command !== 'ilink' || subcommand !== 'delete')) {
+            throw new Error('--yes is valid only for "kintio ilink delete"');
+        }
+        if (parsed.values.foreground && (command !== 'ilink' || subcommand !== 'start')) {
+            throw new Error('--foreground is valid only for "kintio ilink start"');
+        }
         const location = instanceLocation(parsed.values, runtime);
+        const qrOutputPath = parsed.values['qr-output'] === undefined
+            ? undefined
+            : resolveInputPath(parsed.values['qr-output'], runtime.cwd);
+        if (qrOutputPath && !samePath(path.dirname(qrOutputPath), location.home)) {
+            throw new Error('iLink QR output must be directly inside the instance directory');
+        }
+        if (command === 'ilink') {
+            if (privateFile(location.configFile, 'Kintio config')) {
+                assertTrustedDirectory(path.dirname(location.configFile), 'Kintio config directory', false);
+            }
+            prepareDirectories(location.home);
+            return await runWithIlinkSignals(async (signal) => {
+                const enrollmentConfig = loadIlinkEnrollmentConfig({
+                    environment: { ...runtime.env },
+                    envFile: location.configFile,
+                    root: location.home,
+                });
+                if (subcommand === 'login') {
+                    return await runtime.ilinkLogin({
+                        config: enrollmentConfig,
+                        packageRoot: runtime.packageRoot,
+                        stdout: runtime.stdout,
+                        stdoutIsTTY: runtime.stdoutIsTTY,
+                        stdoutColumns: runtime.stdoutColumns,
+                        ...(qrOutputPath ? { qrOutputPath } : {}),
+                        signal,
+                    });
+                }
+                const foreground = Boolean(parsed.values.foreground);
+                const commandResult = await runtime.ilinkAccount({
+                    command: subcommand,
+                    ...(parsed.values.account ? { selector: parsed.values.account } : {}),
+                    confirmed: Boolean(parsed.values.yes),
+                    config: enrollmentConfig,
+                    packageRoot: runtime.packageRoot,
+                    signal,
+                    stdout: runtime.stdout,
+                    ...(subcommand === 'start'
+                        ? { deferStandaloneStart: !foreground }
+                        : {}),
+                });
+                if (subcommand === 'start' && commandResult.runtimeRequired) {
+                    const runtimeConfig = loadIlinkRuntimeConfig({
+                        environment: { ...runtime.env },
+                        envFile: location.configFile,
+                        root: location.home,
+                    });
+                    if (foreground) {
+                        refreshManagedSkill(runtimeConfig.codex.workingDirectory, runtime);
+                        return await runtime.ilinkStart({
+                            config: runtimeConfig,
+                            signal,
+                            stdout: runtime.stdout,
+                        });
+                    }
+                    if (!commandResult.selectedAccountKey) {
+                        throw new Error('iLink start did not resolve an account identity');
+                    }
+                    await startIlinkDaemon(location, runtime);
+                    await runtime.ilinkAccount({
+                        command: 'start',
+                        selector: commandResult.selectedAccountKey,
+                        config: enrollmentConfig,
+                        packageRoot: runtime.packageRoot,
+                        signal,
+                        stdout: runtime.stdout,
+                    });
+                    return 0;
+                }
+                if ((subcommand === 'stop' || subcommand === 'delete') &&
+                    commandResult.runningCount === 0 &&
+                    readDaemonRecord(location.home)?.mode === 'ilink') {
+                    await withLifecycleLock(location, async () => {
+                        if (readDaemonRecord(location.home)?.mode === 'ilink') {
+                            try {
+                                await stopDaemon(location, DAEMON_STOP_TIMEOUT_MS);
+                            }
+                            catch (error) {
+                                if (readDaemonRecord(location.home))
+                                    throw error;
+                            }
+                        }
+                    });
+                }
+                return 0;
+            });
+        }
         if (command === 'setup')
             return setup(location, runtime);
         if (command === 'start')
@@ -552,7 +869,7 @@ export async function runCli(args, overrides = {}) {
                 return 0;
             }
             assertDaemonInstance(location, runtime.packageRoot);
-            runtime.stdout(`Kintio is ${existing.phase} ` +
+            runtime.stdout(`Kintio is ${existing.phase} in ${readDaemonRecord(location.home)?.mode || 'service'} mode ` +
                 `(daemon PID ${existing.daemonPid}` +
                 `${existing.workerPid ? `, worker PID ${existing.workerPid}` : ''}).` +
                 `${existing.message ? ` ${existing.message}` : ''}\n`);

package/dist/src/config.js

@@ -124,6 +124,40 @@ function parseBoundedText(value, fallback, name, maxBytes) {
     }
     return parsed;
 }
+function createIlinkEnrollmentConfig(environment = process.env, root, platform = process.platform) {
+    environment = copyEnvironment(environment);
+    const home = path.resolve(root || resolveInstanceRoot(environment));
+    const storageKey = String(environment.ILINK_STORAGE_KEY || '').trim();
+    if (storageKey && !/^[A-Za-z0-9_-]{43}$/u.test(storageKey)) {
+        throw new Error('ILINK_STORAGE_KEY must be a canonical 32-byte base64url value');
+    }
+    const state = resolveStateFiles(environment, home);
+    const storageKeyFile = path.resolve(home, environment.ILINK_STORAGE_KEY_FILE ||
+        path.join(path.dirname(state.databaseFile), 'ilink-storage.key'));
+    if (platform === 'win32') {
+        for (const [name, filePath] of [
+            ['KINTIO_DB_FILE', state.databaseFile],
+            ['Kintio state lock', state.lockFile],
+            ['ILINK_STORAGE_KEY_FILE', storageKeyFile],
+        ]) {
+            if (!isPathInside(home, filePath)) {
+                throw new Error(`${name} must stay inside KINTIO_HOME on Windows`);
+            }
+        }
+    }
+    return Object.freeze({
+        home,
+        state,
+        ilink: Object.freeze({
+            storageKey,
+            storageKeyFile,
+            baseUrl: environment.ILINK_BASE_URL || 'https://ilinkai.weixin.qq.com/',
+            apiTimeoutMs: parsePositiveInteger(environment.ILINK_API_TIMEOUT_MS, 15_000, 'ILINK_API_TIMEOUT_MS', 120_000),
+            longPollTimeoutMs: parsePositiveInteger(environment.ILINK_LONG_POLL_TIMEOUT_MS, 35_000, 'ILINK_LONG_POLL_TIMEOUT_MS', 120_000),
+            maxAccounts: parsePositiveInteger(environment.ILINK_MAX_ACCOUNTS, 20, 'ILINK_MAX_ACCOUNTS', 1_000),
+        }),
+    });
+}
 export function createConfig(environment = process.env, root, platform = process.platform) {
     environment = copyEnvironment(environment);
     const instanceRoot = path.resolve(root || resolveInstanceRoot(environment));
@@ -150,22 +184,14 @@ export function createConfig(environment = process.env, root, platform = process
     }
     const ilinkEnabled = parseBoolean(environment.ILINK_ENABLED, false);
     const codexEnabled = parseBoolean(environment.CODEX_ENABLED, apiEnabled || ilinkEnabled);
-    const ilinkStorageKey = String(environment.ILINK_STORAGE_KEY || '').trim();
-    if (ilinkStorageKey && !/^[A-Za-z0-9_-]{43}$/u.test(ilinkStorageKey)) {
-        throw new Error('ILINK_STORAGE_KEY must be a canonical 32-byte base64url value');
-    }
-    const { databaseFile, lockFile } = resolveStateFiles(environment, instanceRoot);
+    const enrollment = createIlinkEnrollmentConfig(environment, instanceRoot, platform);
+    const { databaseFile, lockFile } = enrollment.state;
     const codexWorkingDirectory = path.resolve(instanceRoot, environment.CODEX_WORKING_DIRECTORY ||
         'codex-workspace');
-    const ilinkStorageKeyFile = path.resolve(instanceRoot, environment.ILINK_STORAGE_KEY_FILE ||
-        path.join(path.dirname(databaseFile), 'ilink-storage.key'));
     const codexImageTempDirectory = path.resolve(instanceRoot, environment.CODEX_IMAGE_TMP_DIR ||
         'data/codex-input');
     if (platform === 'win32') {
         for (const [name, filePath] of [
-            ['KINTIO_DB_FILE', databaseFile],
-            ['Kintio state lock', lockFile],
-            ['ILINK_STORAGE_KEY_FILE', ilinkStorageKeyFile],
             ['CODEX_IMAGE_TMP_DIR', codexImageTempDirectory],
         ]) {
             if (!isPathInside(instanceRoot, filePath)) {
@@ -201,12 +227,7 @@ export function createConfig(environment = process.env, root, platform = process
         }),
         ilink: Object.freeze({
             enabled: ilinkEnabled,
-            storageKey: ilinkStorageKey,
-            storageKeyFile: ilinkStorageKeyFile,
-            baseUrl: environment.ILINK_BASE_URL || 'https://ilinkai.weixin.qq.com/',
-            apiTimeoutMs: parsePositiveInteger(environment.ILINK_API_TIMEOUT_MS, 15_000, 'ILINK_API_TIMEOUT_MS', 120_000),
-            longPollTimeoutMs: parsePositiveInteger(environment.ILINK_LONG_POLL_TIMEOUT_MS, 35_000, 'ILINK_LONG_POLL_TIMEOUT_MS', 120_000),
-            maxAccounts: parsePositiveInteger(environment.ILINK_MAX_ACCOUNTS, 20, 'ILINK_MAX_ACCOUNTS', 1_000),
+            ...enrollment.ilink,
         }),
         state: Object.freeze({
             databaseFile,
@@ -222,6 +243,10 @@ export function createConfig(environment = process.env, root, platform = process
     });
 }
 export function loadConfig(options = {}) {
+    const loaded = loadConfigurationEnvironment(options);
+    return createConfig(loaded.environment, loaded.root);
+}
+function loadConfigurationEnvironment(options) {
     const environment = copyEnvironment(options.environment || process.env);
     const configuredEnvFile = options.envFile || environment.KINTIO_CONFIG_FILE;
     const defaultRoot = path.join(path.resolve(options.homeDirectory || os.homedir()), '.kintio');
@@ -233,5 +258,35 @@ export function loadConfig(options = {}) {
     const envFile = path.resolve(configuredEnvFile || path.join(initialRoot, '.env'));
     loadEnvironmentFile(envFile, environment);
     const root = path.resolve(options.root || environment.KINTIO_HOME || initialRoot);
-    return createConfig(environment, root);
+    return { environment, root };
+}
+export function loadIlinkEnrollmentConfig(options = {}) {
+    const loaded = loadConfigurationEnvironment(options);
+    return createIlinkEnrollmentConfig(loaded.environment, loaded.root);
+}
+export function loadIlinkRuntimeConfig(options = {}) {
+    const { environment, root } = loadConfigurationEnvironment(options);
+    const enrollment = createIlinkEnrollmentConfig(environment, root);
+    const workingDirectory = path.resolve(root, environment.CODEX_WORKING_DIRECTORY || 'codex-workspace');
+    const imageTempDirectory = path.resolve(root, environment.CODEX_IMAGE_TMP_DIR || 'data/codex-input');
+    if (process.platform === 'win32' && !isPathInside(root, imageTempDirectory)) {
+        throw new Error('CODEX_IMAGE_TMP_DIR must stay inside KINTIO_HOME on Windows');
+    }
+    const shutdownTimeoutMs = parsePositiveInteger(environment.SHUTDOWN_TIMEOUT_MS, 10_000, 'SHUTDOWN_TIMEOUT_MS', MAX_SHUTDOWN_TIMEOUT_MS);
+    if (shutdownTimeoutMs < 1_000) {
+        throw new Error('SHUTDOWN_TIMEOUT_MS must be at least 1000');
+    }
+    return Object.freeze({
+        state: Object.freeze({
+            ...enrollment.state,
+            shutdownTimeoutMs,
+        }),
+        ilink: Object.freeze({ enabled: true, ...enrollment.ilink }),
+        codex: Object.freeze({
+            enabled: true,
+            imageTempDirectory,
+            workingDirectory,
+            generatedImageDirectory: path.join(workingDirectory, 'generated_images'),
+        }),
+    });
 }

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

@@ -0,0 +1,74 @@
+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, deferStandaloneStart = false, }) {
+    if (!openControl && !fs.existsSync(config.state.databaseFile)) {
+        if (command === 'list') {
+            stdout('No iLink accounts enrolled.\n');
+            return { runtimeRequired: 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
+                ? `${accounts.map((account) => account.providerAccountId).join('\n')}\n`
+                : 'No iLink accounts enrolled.\n');
+            return {
+                runtimeRequired: false,
+                runningCount: accounts.filter((account) => account.runtimeEnabled).length,
+            };
+        }
+        const account = selectAccount(accounts, selector, runtimeActive);
+        if (command === 'start' && control.mode === 'standalone' && deferStandaloneStart) {
+            return {
+                runtimeRequired: true,
+                runningCount: 0,
+                selectedAccountKey: account.accountKey,
+            };
+        }
+        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 {
+            runtimeRequired: command === 'start' && control.mode === 'standalone',
+            runningCount: result.runningCount,
+            ...(command === 'start' ? { selectedAccountKey: account.accountKey } : {}),
+        };
+    }
+    finally {
+        await control.close();
+    }
+}