@exaudeus/workrail 3.32.0 → 3.34.0

package/dist/cli-worktrain.js

@@ -1,5 +1,38 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -166,4 +199,459 @@ program
     });
     (0, interpret_result_js_1.interpretCliResultWithoutDI)(result);
 });
+program
+    .command('console')
+    .description('Start the WorkRail console UI (reads session files directly, no daemon required)')
+    .option('-p, --port <n>', 'Port to bind the console server (default: 3456)', parseInt)
+    .option('-w, --workspace <path>', 'Workspace path (reserved for future scoped view)')
+    .action(async (options) => {
+    const { startStandaloneConsole } = await Promise.resolve().then(() => __importStar(require('./console/standalone-console.js')));
+    const result = await startStandaloneConsole({
+        port: options.port,
+    });
+    if (result.kind === 'port_conflict') {
+        process.stderr.write(`[Console] Port ${result.port} is already in use. ` +
+            `Use --port to choose a different port, or stop the process holding port ${result.port}.\n`);
+        process.exit(1);
+    }
+    if (result.kind === 'io_error') {
+        process.stderr.write(`[Console] Failed to start: ${result.message}\n`);
+        process.exit(1);
+    }
+    const line = '='.repeat(60);
+    process.stdout.write(`\n${line}\n`);
+    process.stdout.write(`WorkRail Console\n`);
+    process.stdout.write(`${line}\n`);
+    process.stdout.write(`Console:  http://localhost:${result.port}/console\n`);
+    process.stdout.write(`Sessions: ${path_1.default.join(os_1.default.homedir(), '.workrail', 'data', 'sessions')}\n`);
+    process.stdout.write(`${line}\n\n`);
+    process.stdout.write(`Press Ctrl+C to stop.\n`);
+    const shutdown = async () => {
+        process.stdout.write('\n[Console] Shutting down...\n');
+        await result.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => { void shutdown(); });
+    process.on('SIGTERM', () => { void shutdown(); });
+});
+program
+    .command('daemon')
+    .description('Start the WorkTrain daemon, or manage it as a macOS launchd service')
+    .option('--install', 'Create the launchd plist and start the daemon service')
+    .option('--uninstall', 'Stop the daemon service and remove the launchd plist')
+    .option('--status', 'Show the current status of the daemon service')
+    .action(async (options) => {
+    const { execFile: execFileRaw } = await Promise.resolve().then(() => __importStar(require('child_process')));
+    const execFilePromise = (0, util_1.promisify)(execFileRaw);
+    const result = await (0, index_js_1.executeWorktrainDaemonCommand)({
+        env: process_1.env,
+        platform: process.platform,
+        worktrainBinPath: process.argv[1],
+        nodeBinPath: process.execPath,
+        homedir: os_1.default.homedir,
+        joinPath: path_1.default.join,
+        mkdir: (p, opts) => fs_1.default.promises.mkdir(p, opts),
+        writeFile: (p, content) => fs_1.default.promises.writeFile(p, content, 'utf-8'),
+        chmod: (p, mode) => fs_1.default.promises.chmod(p, mode),
+        readFile: (p) => fs_1.default.promises.readFile(p, 'utf-8'),
+        removeFile: (p) => fs_1.default.promises.unlink(p),
+        exists: async (p) => {
+            try {
+                await fs_1.default.promises.access(p);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        exec: async (command, args) => {
+            try {
+                const { stdout, stderr } = await execFilePromise(command, args, { encoding: 'utf-8' });
+                return { stdout: stdout ?? '', stderr: stderr ?? '', exitCode: 0 };
+            }
+            catch (err) {
+                const e = err;
+                return {
+                    stdout: e.stdout ?? '',
+                    stderr: e.stderr ?? '',
+                    exitCode: typeof e.code === 'number' ? e.code : 1,
+                };
+            }
+        },
+        print: (line) => console.log(line),
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        startDaemon: async () => {
+            const { startTriggerListener } = await Promise.resolve().then(() => __importStar(require('./trigger/trigger-listener.js')));
+            const { startDaemonConsole } = await Promise.resolve().then(() => __importStar(require('./trigger/daemon-console.js')));
+            const { DaemonEventEmitter } = await Promise.resolve().then(() => __importStar(require('./daemon/daemon-events.js')));
+            const { initializeContainer, container } = await Promise.resolve().then(() => __importStar(require('./di/container.js')));
+            const { DI } = await Promise.resolve().then(() => __importStar(require('./di/tokens.js')));
+            await initializeContainer({ runtimeMode: { kind: 'cli' } });
+            const { createToolContext } = await Promise.resolve().then(() => __importStar(require('./mcp/server.js')));
+            const { requireV2Context } = await Promise.resolve().then(() => __importStar(require('./mcp/types.js')));
+            const rawCtx = await createToolContext();
+            const v2Guard = requireV2Context(rawCtx);
+            if (!v2Guard.ok) {
+                console.error('v2 engine not available -- ensure WorkRail is fully initialized');
+                process.exit(1);
+            }
+            const ctx = v2Guard.ctx;
+            const { loadWorkrailConfigFile } = await Promise.resolve().then(() => __importStar(require('./config/config-file.js')));
+            const configResult = loadWorkrailConfigFile();
+            const configWorkspace = configResult.kind === 'ok' ? configResult.value['WORKRAIL_DEFAULT_WORKSPACE'] : undefined;
+            const workspacePath = configWorkspace?.trim() || process.cwd();
+            const usesBedrock = !!process.env['AWS_PROFILE'] || !!process.env['AWS_ACCESS_KEY_ID'];
+            const apiKey = process.env['ANTHROPIC_API_KEY'];
+            if (!usesBedrock && !apiKey) {
+                console.error('No LLM credentials found. Set AWS_PROFILE (Bedrock) or ANTHROPIC_API_KEY.');
+                process.exit(1);
+            }
+            const emitter = new DaemonEventEmitter();
+            const handle = await startTriggerListener(ctx, {
+                workspacePath,
+                apiKey: apiKey,
+                env: process.env,
+                emitter,
+            });
+            if (handle === null) {
+                console.error('Daemon is disabled. Set WORKRAIL_TRIGGERS_ENABLED=true to enable.');
+                process.exit(1);
+            }
+            if ('_kind' in handle) {
+                console.error('Failed to start daemon:', handle.error);
+                process.exit(1);
+            }
+            console.log(`WorkRail daemon running on port ${handle.port}`);
+            console.log(`Workspace: ${workspacePath}`);
+            console.log('Waiting for webhook triggers...');
+            const pkg = require('../package.json');
+            const workflowService = container.resolve(DI.Services.Workflow);
+            const consoleResult = await startDaemonConsole(ctx, {
+                triggerRouter: handle.router,
+                serverVersion: pkg.version,
+                workflowService,
+            });
+            let consoleHandle = null;
+            if (consoleResult.kind === 'ok') {
+                consoleHandle = consoleResult.value;
+            }
+            else if (consoleResult.error.kind === 'port_conflict') {
+                console.warn(`[DaemonConsole] Port ${consoleResult.error.port} is already held. ` +
+                    `The daemon is running but the console is unavailable.`);
+            }
+            else {
+                console.warn(`[DaemonConsole] Could not start console: ${consoleResult.error.message}`);
+            }
+            await new Promise((resolve) => {
+                const shutdown = async () => {
+                    console.log('\nShutting down daemon...');
+                    if (consoleHandle) {
+                        await consoleHandle.stop();
+                    }
+                    await handle.stop();
+                    resolve();
+                };
+                process.once('SIGINT', () => void shutdown());
+                process.once('SIGTERM', () => void shutdown());
+            });
+        },
+    }, {
+        install: options.install,
+        uninstall: options.uninstall,
+        status: options.status,
+    });
+    (0, interpret_result_js_1.interpretCliResultWithoutDI)(result);
+});
+function formatDaemonEventLine(raw) {
+    let obj;
+    try {
+        obj = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const ts = typeof obj['ts'] === 'number'
+        ? new Date(obj['ts']).toISOString().replace('T', ' ').slice(0, 23)
+        : '?';
+    const kind = typeof obj['kind'] === 'string' ? obj['kind'] : 'unknown';
+    const sessionId = typeof obj['sessionId'] === 'string' ? obj['sessionId'].slice(0, 8) : null;
+    const prefix = sessionId ? `[${ts}] [${sessionId}] ${kind}` : `[${ts}] ${kind}`;
+    switch (kind) {
+        case 'agent_stuck':
+            return `${prefix}  *** STUCK: ${obj['reason'] ?? '?'} -- ${String(obj['detail'] ?? '').slice(0, 100)}`;
+        case 'llm_turn_started':
+            return `${prefix}  msgs=${obj['messageCount'] ?? '?'}`;
+        case 'llm_turn_completed':
+            return `${prefix}  stop=${obj['stopReason'] ?? '?'} in=${obj['inputTokens'] ?? '?'} out=${obj['outputTokens'] ?? '?'} tools=[${Array.isArray(obj['toolNamesRequested']) ? obj['toolNamesRequested'].join(',') : ''}]`;
+        case 'tool_call_started':
+            return `${prefix}  tool=${obj['toolName'] ?? '?'} args=${String(obj['argsSummary'] ?? '').slice(0, 80)}`;
+        case 'tool_call_completed':
+            return `${prefix}  tool=${obj['toolName'] ?? '?'} ${obj['durationMs'] ?? '?'}ms result=${String(obj['resultSummary'] ?? '').slice(0, 60)}`;
+        case 'tool_call_failed':
+            return `${prefix}  tool=${obj['toolName'] ?? '?'} ${obj['durationMs'] ?? '?'}ms err=${String(obj['errorMessage'] ?? '').slice(0, 80)}`;
+        case 'tool_called':
+            return `${prefix}  tool=${obj['toolName'] ?? '?'} ${obj['summary'] ? String(obj['summary']).slice(0, 80) : ''}`;
+        case 'tool_error':
+            return `${prefix}  tool=${obj['toolName'] ?? '?'} err=${String(obj['error'] ?? '').slice(0, 80)}`;
+        case 'session_started':
+            return `${prefix}  workflow=${obj['workflowId'] ?? '?'} workspace=${obj['workspacePath'] ?? '?'}`;
+        case 'session_completed': {
+            const outcome = obj['outcome'];
+            const detail = obj['detail'] ? ` (${obj['detail']})` : '';
+            if (outcome === 'success') {
+                return `${prefix}  workflow=${obj['workflowId'] ?? '?'} -- session complete${detail}`;
+            }
+            else if (outcome === 'error') {
+                return `${prefix}  workflow=${obj['workflowId'] ?? '?'} -- session FAILED${detail}`;
+            }
+            else if (outcome === 'timeout') {
+                return `${prefix}  workflow=${obj['workflowId'] ?? '?'} -- session TIMEOUT${detail}`;
+            }
+            return `${prefix}  workflow=${obj['workflowId'] ?? '?'} outcome=${outcome ?? '?'}${detail}`;
+        }
+        case 'step_advanced':
+            return `${prefix}  -> step advanced`;
+        case 'issue_reported': {
+            const severity = obj['severity'];
+            const summary = String(obj['summary'] ?? '').slice(0, 100);
+            if (severity === 'fatal') {
+                return `${prefix}  FATAL: ${summary}`;
+            }
+            else if (severity === 'error') {
+                return `${prefix}  ERROR: ${summary}`;
+            }
+            return `${prefix}  severity=${severity ?? '?'} ${summary}`;
+        }
+        default:
+            return `${prefix}  ${JSON.stringify(obj).slice(0, 120)}`;
+    }
+}
+program
+    .command('logs')
+    .description('Read and display the WorkRail daemon event log. Use --follow to stream new events in real time.')
+    .option('--follow', 'Continuously poll the log file for new events (like tail -f)')
+    .option('--session <id>', 'Filter events by sessionId (UUID prefix) or workrailSessionId (sess_xxx prefix)')
+    .action(async (options) => {
+    const eventsDir = path_1.default.join(os_1.default.homedir(), '.workrail', 'events', 'daemon');
+    function todayFilePath() {
+        const date = new Date().toISOString().slice(0, 10);
+        return path_1.default.join(eventsDir, `${date}.jsonl`);
+    }
+    function readNewLines(filePath, fromOffset) {
+        let stat;
+        try {
+            stat = fs_1.default.statSync(filePath);
+        }
+        catch {
+            return null;
+        }
+        if (stat.size <= fromOffset) {
+            return { lines: [], newOffset: fromOffset };
+        }
+        const fd = fs_1.default.openSync(filePath, 'r');
+        try {
+            const len = stat.size - fromOffset;
+            const buf = Buffer.alloc(len);
+            fs_1.default.readSync(fd, buf, 0, len, fromOffset);
+            const text = buf.toString('utf8');
+            const lines = text.split('\n').filter((l) => l.trim().length > 0);
+            return { lines, newOffset: stat.size };
+        }
+        finally {
+            fs_1.default.closeSync(fd);
+        }
+    }
+    function printLines(lines) {
+        for (const line of lines) {
+            if (options.session) {
+                try {
+                    const obj = JSON.parse(line);
+                    const sid = typeof obj['sessionId'] === 'string' ? obj['sessionId'] : '';
+                    const wrid = typeof obj['workrailSessionId'] === 'string' ? obj['workrailSessionId'] : '';
+                    const matchesSession = sid.startsWith(options.session) || sid === options.session ||
+                        wrid.startsWith(options.session) || wrid === options.session;
+                    if (!matchesSession)
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+            }
+            const formatted = formatDaemonEventLine(line);
+            if (formatted !== null) {
+                process.stdout.write(formatted + '\n');
+            }
+        }
+    }
+    const filePath = todayFilePath();
+    if (!options.follow) {
+        const result = readNewLines(filePath, 0);
+        if (result === null) {
+            process.stdout.write(`No events yet. Is the daemon running? (Expected: ${filePath})\n`);
+            return;
+        }
+        printLines(result.lines);
+        return;
+    }
+    process.once('SIGINT', () => process.exit(0));
+    let currentFilePath = filePath;
+    let offset = 0;
+    const initial = readNewLines(currentFilePath, 0);
+    if (initial !== null) {
+        printLines(initial.lines);
+        offset = initial.newOffset;
+    }
+    else {
+        process.stdout.write(`Waiting for events... (${currentFilePath})\n`);
+    }
+    while (true) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        const newFilePath = todayFilePath();
+        if (newFilePath !== currentFilePath) {
+            currentFilePath = newFilePath;
+            offset = 0;
+        }
+        const result = readNewLines(currentFilePath, offset);
+        if (result !== null && result.lines.length > 0) {
+            printLines(result.lines);
+            offset = result.newOffset;
+        }
+        else if (result !== null) {
+            offset = result.newOffset;
+        }
+    }
+});
+program
+    .command('status <sessionId>')
+    .description('Print a health summary for a daemon session. Accepts sessionId (UUID prefix) or workrailSessionId (sess_xxx).')
+    .action(async (sessionId) => {
+    const eventsDir = path_1.default.join(os_1.default.homedir(), '.workrail', 'events', 'daemon');
+    const date = new Date().toISOString().slice(0, 10);
+    const filePath = path_1.default.join(eventsDir, `${date}.jsonl`);
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        process.stdout.write(`No events today. Is the daemon running? (Expected: ${filePath})\n`);
+        return;
+    }
+    let workflowId = null;
+    let firstTs = null;
+    let lastTs = null;
+    let llmTurns = 0;
+    let stepAdvances = 0;
+    let totalToolCalls = 0;
+    let failedToolCalls = 0;
+    let fatalIssues = 0;
+    let errorIssues = 0;
+    let warnIssues = 0;
+    let sessionOutcome = null;
+    let lastToolName = null;
+    let lastToolArgs = null;
+    let stuckCount = 0;
+    let isLive = true;
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const sid = typeof obj['sessionId'] === 'string' ? obj['sessionId'] : '';
+        const wrid = typeof obj['workrailSessionId'] === 'string' ? obj['workrailSessionId'] : '';
+        const matches = sid.startsWith(sessionId) || sid === sessionId ||
+            wrid.startsWith(sessionId) || wrid === sessionId;
+        if (!matches)
+            continue;
+        const ts = typeof obj['ts'] === 'number' ? obj['ts'] : null;
+        if (ts !== null) {
+            if (firstTs === null || ts < firstTs)
+                firstTs = ts;
+            if (lastTs === null || ts > lastTs)
+                lastTs = ts;
+        }
+        const kind = typeof obj['kind'] === 'string' ? obj['kind'] : '';
+        switch (kind) {
+            case 'session_started':
+                workflowId = typeof obj['workflowId'] === 'string' ? obj['workflowId'] : null;
+                break;
+            case 'llm_turn_completed':
+                llmTurns++;
+                break;
+            case 'step_advanced':
+                stepAdvances++;
+                break;
+            case 'tool_call_started':
+                totalToolCalls++;
+                lastToolName = typeof obj['toolName'] === 'string' ? obj['toolName'] : null;
+                lastToolArgs = typeof obj['argsSummary'] === 'string' ? String(obj['argsSummary']).slice(0, 60) : null;
+                break;
+            case 'tool_call_failed':
+                failedToolCalls++;
+                break;
+            case 'issue_reported': {
+                const severity = obj['severity'];
+                if (severity === 'fatal')
+                    fatalIssues++;
+                else if (severity === 'error')
+                    errorIssues++;
+                else if (severity === 'warn')
+                    warnIssues++;
+                break;
+            }
+            case 'agent_stuck':
+                stuckCount++;
+                break;
+            case 'session_completed':
+                sessionOutcome = typeof obj['outcome'] === 'string' ? obj['outcome'] : null;
+                isLive = false;
+                break;
+        }
+    }
+    if (firstTs === null) {
+        process.stdout.write(`No events found for session: ${sessionId}\n`);
+        return;
+    }
+    const durationMs = (lastTs ?? firstTs) - firstTs;
+    const durationSec = Math.floor(durationMs / 1000);
+    const durationMin = Math.floor(durationSec / 60);
+    const durationRemSec = durationSec % 60;
+    const durationStr = durationMin > 0
+        ? `${durationMin}m ${durationRemSec}s`
+        : `${durationSec}s`;
+    const avgTurnSec = llmTurns > 0 ? (durationMs / llmTurns / 1000).toFixed(1) : '?';
+    const failRate = totalToolCalls > 0 ? ((failedToolCalls / totalToolCalls) * 100).toFixed(1) : '0';
+    const sessionStatus = sessionOutcome !== null
+        ? sessionOutcome.toUpperCase()
+        : (isLive ? 'RUNNING' : 'UNKNOWN');
+    const issueStr = (fatalIssues + errorIssues + warnIssues) > 0
+        ? `${fatalIssues + errorIssues + warnIssues} (${fatalIssues} fatal, ${errorIssues} error, ${warnIssues} warn)`
+        : '0';
+    const lastActivityStr = lastTs !== null
+        ? `${lastToolName ?? 'unknown'} ${lastToolArgs ? `"${lastToolArgs}"` : ''} ${Math.round((Date.now() - lastTs) / 1000)}s ago`
+        : 'unknown';
+    process.stdout.write(`\nSession: ${sessionId}    [${sessionStatus}]\n`);
+    if (workflowId)
+        process.stdout.write(`Workflow: ${workflowId}\n`);
+    process.stdout.write(`Duration: ${durationStr}\n`);
+    process.stdout.write(`LLM turns: ${llmTurns}${llmTurns > 0 ? ` (avg ${avgTurnSec}s each)` : ''}\n`);
+    process.stdout.write(`Step advances: ${stepAdvances}\n`);
+    process.stdout.write(`Tool calls: ${totalToolCalls} (${failedToolCalls} failed, ${failRate}% failure rate)\n`);
+    process.stdout.write(`Issues reported: ${issueStr}\n`);
+    process.stdout.write(`Last activity: ${lastActivityStr}\n`);
+    if (stuckCount > 0) {
+        process.stdout.write(`*** WARNING: ${stuckCount} stuck signal(s) detected\n`);
+    }
+    if (fatalIssues > 0) {
+        process.stdout.write(`*** WARNING: ${fatalIssues} FATAL issue(s) reported\n`);
+    }
+    if (llmTurns >= 10 && stepAdvances === 0) {
+        process.stdout.write(`*** WARNING: ${llmTurns} turns with 0 step advances (possible stuck)\n`);
+    }
+    process.stdout.write('\n');
+});
 program.parse();

package/dist/cli.js

@@ -190,7 +190,6 @@ program
     .option('-w, --workspace <path>', 'Path to workspace containing triggers.yml')
     .action(async (options) => {
     const { startTriggerListener } = await Promise.resolve().then(() => __importStar(require('./trigger/trigger-listener.js')));
-    const { startDaemonConsole } = await Promise.resolve().then(() => __importStar(require('./trigger/daemon-console.js')));
     const { DaemonEventEmitter } = await Promise.resolve().then(() => __importStar(require('./daemon/daemon-events.js')));
     await (0, container_js_1.initializeContainer)({ runtimeMode: { kind: 'cli' } });
     const { createToolContext } = await Promise.resolve().then(() => __importStar(require('./mcp/server.js')));
@@ -235,29 +234,9 @@ program
     console.log(`WorkRail daemon running on port ${handle.port}`);
     console.log(`Workspace: ${workspacePath}`);
     console.log('Waiting for webhook triggers...');
-    const pkg = require('../package.json');
-    const consoleResult = await startDaemonConsole(ctx, {
-        triggerRouter: handle.router,
-        serverVersion: pkg.version,
-        workflowService: rawCtx.workflowService,
-    });
-    let consoleHandle = null;
-    if (consoleResult.kind === 'ok') {
-        consoleHandle = consoleResult.value;
-    }
-    else if (consoleResult.error.kind === 'port_conflict') {
-        console.warn(`[DaemonConsole] Port ${consoleResult.error.port} is already held (likely by an MCP server). ` +
-            `The daemon is running but the console is unavailable. ` +
-            `Restart the MCP server while the daemon is running to enable the daemon console.`);
-    }
-    else {
-        console.warn(`[DaemonConsole] Could not start console: ${consoleResult.error.message}`);
-    }
+    console.log('Run "worktrain console" in a separate terminal to start the console UI.');
     const shutdown = async () => {
         console.log('\nShutting down daemon...');
-        if (consoleHandle) {
-            await consoleHandle.stop();
-        }
         await handle.stop();
         process.exit(0);
     };

package/dist/console/standalone-console.d.ts

@@ -0,0 +1,28 @@
+export interface StandaloneConsoleHandle {
+    readonly port: number;
+    stop(): Promise<void>;
+}
+export type StandaloneConsoleError = {
+    readonly kind: 'port_conflict';
+    readonly port: number;
+} | {
+    readonly kind: 'io_error';
+    readonly message: string;
+};
+export type StandaloneConsoleResult = ({
+    readonly kind: 'ok';
+} & StandaloneConsoleHandle) | ({
+    readonly kind: 'port_conflict';
+} & {
+    readonly port: number;
+}) | ({
+    readonly kind: 'io_error';
+} & {
+    readonly message: string;
+});
+export interface StartStandaloneConsoleOptions {
+    readonly port?: number;
+    readonly dataDir?: string;
+    readonly lockFilePath?: string;
+}
+export declare function startStandaloneConsole(options?: StartStandaloneConsoleOptions): Promise<StandaloneConsoleResult>;