@exaudeus/workrail 3.32.0 → 3.33.0

package/dist/cli/commands/worktrain-daemon.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorktrainDaemonCommand = executeWorktrainDaemonCommand;
+const cli_result_js_1 = require("../types/cli-result.js");
+const LAUNCHD_LABEL = 'io.worktrain.daemon';
+const PLIST_FILENAME = `${LAUNCHD_LABEL}.plist`;
+const CAPTURED_ENV_VARS = [
+    'AWS_PROFILE',
+    'AWS_ACCESS_KEY_ID',
+    'AWS_SECRET_ACCESS_KEY',
+    'AWS_SESSION_TOKEN',
+    'ANTHROPIC_API_KEY',
+    'WORKRAIL_TRIGGERS_ENABLED',
+    'WORKRAIL_DEFAULT_WORKSPACE',
+    'GITHUB_TOKEN',
+    'GITLAB_TOKEN',
+    'HOME',
+    'USER',
+    'PATH',
+    'WORKRAIL_DEV',
+    'WORKRAIL_LOG_LEVEL',
+    'WORKRAIL_VERBOSE_LOGGING',
+];
+function buildPlist(nodeBinPath, worktrainBinPath, envVars, logDir, homeDir) {
+    const envEntries = Object.entries(envVars)
+        .map(([k, v]) => `    <key>${escapeXml(k)}</key>\n    <string>${escapeXml(v)}</string>`)
+        .join('\n');
+    const stdoutLog = `${logDir}/daemon.stdout.log`;
+    const stderrLog = `${logDir}/daemon.stderr.log`;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(nodeBinPath)}</string>
+    <string>${escapeXml(worktrainBinPath)}</string>
+    <string>daemon</string>
+  </array>
+
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(homeDir)}</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+${envEntries}
+  </dict>
+
+  <key>StandardOutPath</key>
+  <string>${escapeXml(stdoutLog)}</string>
+
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(stderrLog)}</string>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>KeepAlive</key>
+  <true/>
+
+  <!--
+    ThrottleInterval: minimum seconds between launchd restarts.
+    WHY 30s: prevents launchd from spinning in a tight restart loop if the daemon
+    exits immediately (e.g., missing credentials or invalid workspace path).
+    Without this, a misconfigured service consumes CPU and spams logs.
+  -->
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+</dict>
+</plist>
+`;
+}
+function escapeXml(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function captureEnvVars(env, warn) {
+    const captured = {};
+    for (const key of CAPTURED_ENV_VARS) {
+        const value = env[key];
+        if (value !== undefined && value !== '') {
+            captured[key] = value;
+        }
+    }
+    const existing = captured['WORKRAIL_TRIGGERS_ENABLED'];
+    if (!existing) {
+        captured['WORKRAIL_TRIGGERS_ENABLED'] = 'true';
+    }
+    else if (existing !== 'true') {
+        warn(`[worktrain daemon --install] WORKRAIL_TRIGGERS_ENABLED is set to '${existing}' in your environment. ` +
+            `The plist will override this with 'true' so the daemon can start. ` +
+            `Remove WORKRAIL_TRIGGERS_ENABLED from your shell environment if you do not want this warning.`);
+        captured['WORKRAIL_TRIGGERS_ENABLED'] = 'true';
+    }
+    return captured;
+}
+function parseLaunchctlList(stdout, exitCode) {
+    if (exitCode !== 0) {
+        return { running: false, pid: null, loaded: false };
+    }
+    try {
+        const parsed = JSON.parse(stdout);
+        const pid = typeof parsed['PID'] === 'number' ? parsed['PID'] : null;
+        return { running: pid !== null, pid, loaded: true };
+    }
+    catch {
+        return { running: false, pid: null, loaded: false };
+    }
+}
+async function runInstall(deps) {
+    const home = deps.homedir();
+    const plistDir = deps.joinPath(home, 'Library', 'LaunchAgents');
+    const plistPath = deps.joinPath(plistDir, PLIST_FILENAME);
+    const logDir = deps.joinPath(home, '.workrail', 'logs');
+    const env = deps.env;
+    const hasBedrock = !!(env['AWS_PROFILE'] || env['AWS_ACCESS_KEY_ID']);
+    const hasAnthropic = !!env['ANTHROPIC_API_KEY'];
+    if (!hasBedrock && !hasAnthropic) {
+        return (0, cli_result_js_1.failure)('No LLM credentials found in the current environment. ' +
+            'Set AWS_PROFILE (for Bedrock) or ANTHROPIC_API_KEY (for Anthropic) ' +
+            'before running --install so the daemon can authenticate.', {
+            suggestions: [
+                'export AWS_PROFILE=your-sso-profile',
+                'export ANTHROPIC_API_KEY=sk-ant-...',
+            ],
+        });
+    }
+    deps.print('Installing WorkTrain daemon as a launchd service...');
+    await deps.mkdir(plistDir, { recursive: true });
+    await deps.mkdir(logDir, { recursive: true });
+    const alreadyInstalled = await deps.exists(plistPath);
+    if (alreadyInstalled) {
+        deps.print('  Existing service found -- unloading before reinstall...');
+        await deps.exec('launchctl', ['unload', plistPath]);
+    }
+    const capturedEnv = captureEnvVars(env, (msg) => console.warn(msg));
+    const plist = buildPlist(deps.nodeBinPath, deps.worktrainBinPath, capturedEnv, logDir, home);
+    await deps.writeFile(plistPath, plist);
+    await deps.chmod(plistPath, 0o600);
+    deps.print(`  Plist written: ${plistPath}`);
+    const loadResult = await deps.exec('launchctl', ['load', plistPath]);
+    if (loadResult.exitCode !== 0) {
+        return (0, cli_result_js_1.failure)(`launchctl load failed (exit ${loadResult.exitCode}): ${loadResult.stderr.trim() || loadResult.stdout.trim()}`, {
+            suggestions: [
+                `Check the plist manually: plutil -lint ${plistPath}`,
+                `View daemon logs: tail -f ${logDir}/daemon.stderr.log`,
+            ],
+        });
+    }
+    await deps.sleep(1500);
+    const listResult = await deps.exec('launchctl', ['list', LAUNCHD_LABEL]);
+    const status = parseLaunchctlList(listResult.stdout, listResult.exitCode);
+    if (!status.loaded) {
+        return (0, cli_result_js_1.failure)(`Service loaded but launchctl cannot find it. This may be a transient issue.`, {
+            suggestions: [
+                `Check: launchctl list ${LAUNCHD_LABEL}`,
+                `View daemon logs: tail -f ${logDir}/daemon.stderr.log`,
+            ],
+        });
+    }
+    deps.print('');
+    if (status.running) {
+        deps.print(`WorkTrain daemon installed and running (PID ${status.pid}).`);
+    }
+    else {
+        deps.print(`WorkTrain daemon installed. Service loaded but not yet running.`);
+        deps.print(`This may be normal if WORKRAIL_TRIGGERS_ENABLED was not set.`);
+    }
+    deps.print(`Logs: ${logDir}/daemon.stdout.log`);
+    deps.print(`      ${logDir}/daemon.stderr.log`);
+    return (0, cli_result_js_1.success)({
+        message: status.running
+            ? `WorkTrain daemon installed and running (PID ${status.pid})`
+            : 'WorkTrain daemon installed (service loaded, not yet running)',
+        details: [
+            `Plist: ${plistPath}`,
+            `Logs:  ${logDir}/daemon.stdout.log`,
+            `       ${logDir}/daemon.stderr.log`,
+        ],
+    });
+}
+async function runUninstall(deps) {
+    const home = deps.homedir();
+    const plistPath = deps.joinPath(home, 'Library', 'LaunchAgents', PLIST_FILENAME);
+    const exists = await deps.exists(plistPath);
+    if (!exists) {
+        return (0, cli_result_js_1.failure)('WorkTrain daemon is not installed (plist not found).', { suggestions: [`Expected: ${plistPath}`] });
+    }
+    deps.print('Uninstalling WorkTrain daemon...');
+    const unloadResult = await deps.exec('launchctl', ['unload', plistPath]);
+    if (unloadResult.exitCode !== 0) {
+        deps.print(`  Warning: launchctl unload returned non-zero: ${unloadResult.stderr.trim()}`);
+    }
+    else {
+        deps.print('  Service unloaded.');
+    }
+    await deps.removeFile(plistPath);
+    deps.print(`  Plist removed: ${plistPath}`);
+    return (0, cli_result_js_1.success)({ message: 'WorkTrain daemon uninstalled successfully.' });
+}
+async function runStatus(deps) {
+    const home = deps.homedir();
+    const plistPath = deps.joinPath(home, 'Library', 'LaunchAgents', PLIST_FILENAME);
+    const logDir = deps.joinPath(home, '.workrail', 'logs');
+    const plistExists = await deps.exists(plistPath);
+    const listResult = await deps.exec('launchctl', ['list', LAUNCHD_LABEL]);
+    const status = parseLaunchctlList(listResult.stdout, listResult.exitCode);
+    deps.print('');
+    deps.print('WorkTrain daemon status:');
+    deps.print(`  Plist installed : ${plistExists ? `yes (${plistPath})` : 'no'}`);
+    deps.print(`  Service loaded  : ${status.loaded ? 'yes' : 'no'}`);
+    deps.print(`  Running         : ${status.running ? `yes (PID ${status.pid})` : 'no'}`);
+    if (plistExists || status.loaded) {
+        deps.print(`  Logs (stdout)   : ${logDir}/daemon.stdout.log`);
+        deps.print(`  Logs (stderr)   : ${logDir}/daemon.stderr.log`);
+    }
+    if (!plistExists && !status.loaded) {
+        deps.print('');
+        deps.print('Daemon is not installed. Run: worktrain daemon --install');
+    }
+    else if (plistExists && !status.running) {
+        deps.print('');
+        deps.print(`Daemon installed but not running. Check logs: tail -f ${logDir}/daemon.stderr.log`);
+    }
+    deps.print('');
+    return (0, cli_result_js_1.success)({
+        message: status.running
+            ? `WorkTrain daemon is running (PID ${status.pid})`
+            : plistExists
+                ? 'WorkTrain daemon is installed but not running'
+                : 'WorkTrain daemon is not installed',
+    });
+}
+async function executeWorktrainDaemonCommand(deps, opts) {
+    const flagCount = [opts.install, opts.uninstall, opts.status].filter(Boolean).length;
+    if (flagCount === 0) {
+        if (deps.startDaemon) {
+            await deps.startDaemon();
+            return (0, cli_result_js_1.success)({ message: 'WorkTrain daemon stopped.' });
+        }
+        return (0, cli_result_js_1.misuse)('Specify one of: --install, --uninstall, or --status', [
+            'worktrain daemon --install    Install and start as a launchd service',
+            'worktrain daemon --uninstall  Stop and remove the launchd service',
+            'worktrain daemon --status     Show service status',
+        ]);
+    }
+    if (flagCount > 1) {
+        return (0, cli_result_js_1.misuse)('--install, --uninstall, and --status are mutually exclusive. Specify only one.');
+    }
+    if (deps.platform !== 'darwin') {
+        return (0, cli_result_js_1.failure)(`worktrain daemon --install requires macOS (launchd). ` +
+            `Current platform: ${deps.platform}.`, {
+            suggestions: [
+                'On Linux, use systemd: create a user service with systemctl --user.',
+                'See docs/daemon-service.md for platform-specific instructions.',
+            ],
+        });
+    }
+    if (opts.install)
+        return runInstall(deps);
+    if (opts.uninstall)
+        return runUninstall(deps);
+    return runStatus(deps);
+}

package/dist/cli/commands/worktrain-spawn.js

@@ -3,20 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeWorktrainSpawnCommand = executeWorktrainSpawnCommand;
 const cli_result_js_1 = require("../types/cli-result.js");
 const DEFAULT_CONSOLE_PORT = 3456;
-const LOCK_FILE_NAME = 'dashboard.lock';
+const LOCK_FILE_NAMES = ['daemon-console.lock', 'dashboard.lock'];
 async function discoverConsolePort(deps, portOverride) {
     if (portOverride !== undefined && portOverride > 0) {
         return portOverride;
     }
-    const lockPath = deps.joinPath(deps.homedir(), '.workrail', LOCK_FILE_NAME);
-    try {
-        const raw = await deps.readFile(lockPath);
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.port === 'number' && parsed.port > 0) {
-            return parsed.port;
+    for (const lockFileName of LOCK_FILE_NAMES) {
+        const lockPath = deps.joinPath(deps.homedir(), '.workrail', lockFileName);
+        try {
+            const raw = await deps.readFile(lockPath);
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.port === 'number' && parsed.port > 0) {
+                return parsed.port;
+            }
+        }
+        catch {
         }
-    }
-    catch {
     }
     return DEFAULT_CONSOLE_PORT;
 }

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,300 @@ 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 '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':
+            return `${prefix}  workflow=${obj['workflowId'] ?? '?'} outcome=${obj['outcome'] ?? '?'}${obj['detail'] ? ` (${obj['detail']})` : ''}`;
+        case 'step_advanced':
+            return `${prefix}`;
+        case 'issue_reported':
+            return `${prefix}  severity=${obj['severity'] ?? '?'} ${String(obj['summary'] ?? '').slice(0, 80)}`;
+        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 prefix (first 8 chars or full UUID)')
+    .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'] : '';
+                    if (!sid.startsWith(options.session) && sid !== options.session) {
+                        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;
+    }
+    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.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);
     };