@exaudeus/workrail 3.31.1 → 3.33.0

package/dist/cli.js

@@ -190,7 +190,7 @@ 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')));
     const { requireV2Context } = await Promise.resolve().then(() => __importStar(require('./mcp/types.js')));
@@ -216,10 +216,12 @@ program
         console.error('No LLM credentials found. Set AWS_PROFILE (for Bedrock) or ANTHROPIC_API_KEY (for direct Anthropic).');
         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.');
@@ -232,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>;

package/dist/console/standalone-console.js

@@ -0,0 +1,142 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStandaloneConsole = startStandaloneConsole;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const http = __importStar(require("node:http"));
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const index_js_1 = require("../v2/infra/local/data-dir/index.js");
+const index_js_2 = require("../v2/infra/local/directory-listing/index.js");
+const index_js_3 = require("../v2/infra/local/fs/index.js");
+const index_js_4 = require("../v2/infra/local/sha256/index.js");
+const index_js_5 = require("../v2/infra/local/crypto/index.js");
+const index_js_6 = require("../v2/infra/local/snapshot-store/index.js");
+const index_js_7 = require("../v2/infra/local/pinned-workflow-store/index.js");
+const index_js_8 = require("../v2/infra/local/session-store/index.js");
+const console_service_js_1 = require("../v2/usecases/console-service.js");
+const console_routes_js_1 = require("../v2/usecases/console-routes.js");
+async function startStandaloneConsole(options = {}) {
+    const port = options.port ?? 3456;
+    const env = process.env;
+    const dataRoot = options.dataDir
+        ?? env['WORKRAIL_DATA_DIR']
+        ?? path.join(os.homedir(), '.workrail', 'data');
+    const envWithDataDir = {
+        ...env,
+        WORKRAIL_DATA_DIR: dataRoot,
+    };
+    const lockFilePath = options.lockFilePath
+        ?? path.join(os.homedir(), '.workrail', 'daemon-console.lock');
+    const dataDir = new index_js_1.LocalDataDirV2(envWithDataDir);
+    const fsPort = new index_js_3.NodeFileSystemV2();
+    const sha256 = new index_js_4.NodeSha256V2();
+    const crypto = new index_js_5.NodeCryptoV2();
+    const directoryListing = new index_js_2.LocalDirectoryListingV2(fsPort);
+    const sessionStore = new index_js_8.LocalSessionEventLogStoreV2(dataDir, fsPort, sha256);
+    const snapshotStore = new index_js_6.LocalSnapshotStoreV2(dataDir, fsPort, crypto);
+    const pinnedWorkflowStore = new index_js_7.LocalPinnedWorkflowStoreV2(dataDir, fsPort);
+    const consoleService = new console_service_js_1.ConsoleService({
+        directoryListing,
+        dataDir,
+        sessionStore,
+        snapshotStore,
+        pinnedWorkflowStore,
+    });
+    const app = (0, express_1.default)();
+    app.use((0, cors_1.default)({
+        origin: '*',
+        methods: ['GET', 'HEAD', 'OPTIONS', 'POST', 'DELETE'],
+        allowedHeaders: ['Content-Type', 'If-None-Match'],
+    }));
+    app.set('etag', 'strong');
+    const stopWatcher = (0, console_routes_js_1.mountConsoleRoutes)(app, consoleService, undefined, undefined, undefined, undefined, undefined, undefined);
+    app.get('/', (_req, res) => {
+        res.redirect('/console');
+    });
+    app.use((req, res) => {
+        res.status(404).json({ success: false, error: 'Not found', path: req.path });
+    });
+    return new Promise((resolve) => {
+        const server = http.createServer(app);
+        server.on('error', (error) => {
+            try {
+                stopWatcher();
+            }
+            catch { }
+            if (error.code === 'EADDRINUSE') {
+                resolve({ kind: 'port_conflict', port });
+            }
+            else {
+                resolve({ kind: 'io_error', message: error.message });
+            }
+        });
+        server.listen(port, '127.0.0.1', () => {
+            const addr = server.address();
+            const actualPort = (addr && typeof addr === 'object') ? addr.port : port;
+            const lockDir = path.dirname(lockFilePath);
+            void fs.mkdir(lockDir, { recursive: true })
+                .then(() => fs.writeFile(lockFilePath, JSON.stringify({ pid: process.pid, port: actualPort }), 'utf-8'))
+                .catch((writeErr) => {
+                console.warn('[StandaloneConsole] Could not write lock file:', writeErr instanceof Error ? writeErr.message : String(writeErr));
+            });
+            let stopped = false;
+            const stop = () => {
+                if (stopped)
+                    return Promise.resolve();
+                stopped = true;
+                return new Promise((res) => {
+                    try {
+                        stopWatcher();
+                    }
+                    catch { }
+                    const safetyTimer = setTimeout(() => res(), 5000);
+                    server.close(() => {
+                        clearTimeout(safetyTimer);
+                        void fs.unlink(lockFilePath)
+                            .catch(() => { })
+                            .finally(() => res());
+                    });
+                });
+            };
+            resolve({ kind: 'ok', port: actualPort, stop });
+        });
+    });
+}