@exaudeus/workrail 0.6.0 → 0.6.1-beta.1

package/dist/infrastructure/session/HttpServer.d.ts

@@ -0,0 +1,22 @@
+import { SessionManager } from './SessionManager.js';
+export interface ServerConfig {
+    port?: number;
+    autoOpen?: boolean;
+}
+export declare class HttpServer {
+    private sessionManager;
+    private config;
+    private app;
+    private server;
+    private port;
+    private baseUrl;
+    constructor(sessionManager: SessionManager, config?: ServerConfig);
+    private setupMiddleware;
+    private setupRoutes;
+    start(): Promise<string>;
+    private printBanner;
+    openDashboard(sessionId?: string): Promise<string>;
+    stop(): Promise<void>;
+    getBaseUrl(): string;
+    getPort(): number;
+}

package/dist/infrastructure/session/HttpServer.js

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpServer = void 0;
+const express_1 = __importDefault(require("express"));
+const http_1 = require("http");
+const path_1 = __importDefault(require("path"));
+const cors_1 = __importDefault(require("cors"));
+const open_1 = __importDefault(require("open"));
+class HttpServer {
+    constructor(sessionManager, config = {}) {
+        this.sessionManager = sessionManager;
+        this.config = config;
+        this.server = null;
+        this.baseUrl = '';
+        this.port = config.port || 3456;
+        this.app = (0, express_1.default)();
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+    setupMiddleware() {
+        this.app.use((0, cors_1.default)({
+            origin: '*',
+            methods: ['GET', 'HEAD', 'OPTIONS'],
+            allowedHeaders: ['Content-Type', 'If-None-Match']
+        }));
+        this.app.set('etag', 'strong');
+        this.app.use(express_1.default.json());
+        this.app.use((req, res, next) => {
+            const start = Date.now();
+            res.on('finish', () => {
+                const duration = Date.now() - start;
+                console.log(`[HTTP] ${req.method} ${req.path} ${res.statusCode} (${duration}ms)`);
+            });
+            next();
+        });
+    }
+    setupRoutes() {
+        const webDir = path_1.default.join(__dirname, '../../../web');
+        this.app.use('/web', express_1.default.static(webDir));
+        this.app.get('/', async (req, res) => {
+            try {
+                const indexPath = path_1.default.join(webDir, 'index.html');
+                res.sendFile(indexPath);
+            }
+            catch (error) {
+                res.status(500).json({
+                    error: 'Dashboard UI not found',
+                    message: 'The dashboard web files are not yet built. This is expected during development.',
+                    details: 'Web files will be available in a future step.'
+                });
+            }
+        });
+        this.app.get('/api/sessions', async (req, res) => {
+            try {
+                const sessions = await this.sessionManager.listAllSessions();
+                res.json({
+                    success: true,
+                    count: sessions.length,
+                    sessions: sessions.map(s => ({
+                        id: s.id,
+                        workflowId: s.workflowId,
+                        createdAt: s.createdAt,
+                        updatedAt: s.updatedAt,
+                        url: `/api/sessions/${s.workflowId}/${s.id}`
+                    }))
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    success: false,
+                    error: 'Failed to list sessions',
+                    message: error.message
+                });
+            }
+        });
+        this.app.get('/api/sessions/:workflow/:id', async (req, res) => {
+            try {
+                const { workflow, id } = req.params;
+                const session = await this.sessionManager.getSession(workflow, id);
+                if (!session) {
+                    return res.status(404).json({
+                        success: false,
+                        error: 'Session not found',
+                        workflowId: workflow,
+                        sessionId: id
+                    });
+                }
+                res.json({
+                    success: true,
+                    session
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    success: false,
+                    error: 'Failed to get session',
+                    message: error.message
+                });
+            }
+        });
+        this.app.get('/api/current-project', async (req, res) => {
+            try {
+                const project = await this.sessionManager.getCurrentProject();
+                res.json({
+                    success: true,
+                    project
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    success: false,
+                    error: 'Failed to get project info',
+                    message: error.message
+                });
+            }
+        });
+        this.app.get('/api/projects', async (req, res) => {
+            try {
+                const projects = await this.sessionManager.listProjects();
+                res.json({
+                    success: true,
+                    count: projects.length,
+                    projects
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    success: false,
+                    error: 'Failed to list projects',
+                    message: error.message
+                });
+            }
+        });
+        this.app.get('/api/health', (req, res) => {
+            res.json({
+                success: true,
+                status: 'healthy',
+                uptime: process.uptime(),
+                timestamp: new Date().toISOString()
+            });
+        });
+        this.app.use((req, res) => {
+            res.status(404).json({
+                success: false,
+                error: 'Not found',
+                path: req.path
+            });
+        });
+    }
+    async start() {
+        while (this.port < 3500) {
+            try {
+                await new Promise((resolve, reject) => {
+                    this.server = (0, http_1.createServer)(this.app);
+                    this.server.on('error', (error) => {
+                        if (error.code === 'EADDRINUSE') {
+                            reject(new Error('Port in use'));
+                        }
+                        else {
+                            reject(error);
+                        }
+                    });
+                    this.server.listen(this.port, () => {
+                        resolve();
+                    });
+                });
+                this.baseUrl = `http://localhost:${this.port}`;
+                this.printBanner();
+                return this.baseUrl;
+            }
+            catch (error) {
+                if (error.message === 'Port in use') {
+                    this.port++;
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new Error('No available ports in range 3456-3499');
+    }
+    printBanner() {
+        const line = '═'.repeat(60);
+        console.log(`\n${line}`);
+        console.log(`🔧 Workrail MCP Server Started`);
+        console.log(line);
+        console.log(`📊 Dashboard: ${this.baseUrl}`);
+        console.log(`💾 Sessions:  ${this.sessionManager.getSessionsRoot()}`);
+        console.log(`🏗️  Project:   ${this.sessionManager.getProjectId()}`);
+        console.log(line);
+        console.log();
+    }
+    async openDashboard(sessionId) {
+        let url = this.baseUrl;
+        if (sessionId) {
+            url += `?session=${sessionId}`;
+        }
+        if (this.config.autoOpen !== false) {
+            try {
+                await (0, open_1.default)(url);
+                console.log(`🌐 Opened dashboard: ${url}`);
+            }
+            catch (error) {
+                console.log(`🌐 Dashboard URL: ${url} (auto-open failed, please open manually)`);
+            }
+        }
+        return url;
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    console.log('HTTP server stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    getPort() {
+        return this.port;
+    }
+}
+exports.HttpServer = HttpServer;

package/dist/infrastructure/session/SessionManager.d.ts

@@ -0,0 +1,38 @@
+export interface Session {
+    id: string;
+    workflowId: string;
+    projectId: string;
+    projectPath: string;
+    createdAt: string;
+    updatedAt: string;
+    data: Record<string, any>;
+}
+export interface ProjectMetadata {
+    id: string;
+    path: string;
+    updatedAt: string;
+    sessionCount: number;
+    workflows: string[];
+}
+export declare class SessionManager {
+    private projectPath;
+    private sessionsRoot;
+    private projectId;
+    constructor(projectPath?: string);
+    private hashProjectPath;
+    private getProjectRoot;
+    getSessionPath(workflowId: string, sessionId: string): string;
+    createSession(workflowId: string, sessionId: string, initialData?: Record<string, any>): Promise<Session>;
+    updateSession(workflowId: string, sessionId: string, updates: Record<string, any>): Promise<Session>;
+    readSession(workflowId: string, sessionId: string, queryPath?: string): Promise<any>;
+    getSession(workflowId: string, sessionId: string): Promise<Session | null>;
+    listAllSessions(): Promise<Session[]>;
+    getCurrentProject(): Promise<ProjectMetadata>;
+    listProjects(): Promise<ProjectMetadata[]>;
+    getSessionsRoot(): string;
+    getProjectId(): string;
+    private updateProjectMetadata;
+    private deepMerge;
+    private getPath;
+    private atomicWrite;
+}

package/dist/infrastructure/session/SessionManager.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const os_1 = __importDefault(require("os"));
+class SessionManager {
+    constructor(projectPath = process.cwd()) {
+        this.projectPath = projectPath;
+        this.sessionsRoot = path_1.default.join(os_1.default.homedir(), '.workrail', 'sessions');
+        this.projectId = this.hashProjectPath(projectPath);
+    }
+    hashProjectPath(projectPath) {
+        return (0, crypto_1.createHash)('sha256')
+            .update(path_1.default.resolve(projectPath))
+            .digest('hex')
+            .substring(0, 12);
+    }
+    getProjectRoot() {
+        return path_1.default.join(this.sessionsRoot, this.projectId);
+    }
+    getSessionPath(workflowId, sessionId) {
+        return path_1.default.join(this.getProjectRoot(), workflowId, `${sessionId}.json`);
+    }
+    async createSession(workflowId, sessionId, initialData = {}) {
+        const sessionPath = this.getSessionPath(workflowId, sessionId);
+        await promises_1.default.mkdir(path_1.default.dirname(sessionPath), { recursive: true });
+        const session = {
+            id: sessionId,
+            workflowId,
+            projectId: this.projectId,
+            projectPath: this.projectPath,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            data: initialData
+        };
+        await this.atomicWrite(sessionPath, session);
+        await this.updateProjectMetadata();
+        return session;
+    }
+    async updateSession(workflowId, sessionId, updates) {
+        const sessionPath = this.getSessionPath(workflowId, sessionId);
+        const session = await this.getSession(workflowId, sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${workflowId}/${sessionId}`);
+        }
+        session.data = this.deepMerge(session.data, updates);
+        session.updatedAt = new Date().toISOString();
+        await this.atomicWrite(sessionPath, session);
+        return session;
+    }
+    async readSession(workflowId, sessionId, queryPath) {
+        const session = await this.getSession(workflowId, sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${workflowId}/${sessionId}`);
+        }
+        if (!queryPath) {
+            return session.data;
+        }
+        return this.getPath(session.data, queryPath);
+    }
+    async getSession(workflowId, sessionId) {
+        try {
+            const sessionPath = this.getSessionPath(workflowId, sessionId);
+            const content = await promises_1.default.readFile(sessionPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+    }
+    async listAllSessions() {
+        const sessions = [];
+        const projectRoot = this.getProjectRoot();
+        try {
+            const workflows = await promises_1.default.readdir(projectRoot);
+            for (const workflow of workflows) {
+                if (workflow === 'project.json')
+                    continue;
+                const workflowPath = path_1.default.join(projectRoot, workflow);
+                const stat = await promises_1.default.stat(workflowPath);
+                if (!stat.isDirectory())
+                    continue;
+                const files = await promises_1.default.readdir(workflowPath);
+                for (const file of files) {
+                    if (!file.endsWith('.json'))
+                        continue;
+                    const sessionPath = path_1.default.join(workflowPath, file);
+                    const content = await promises_1.default.readFile(sessionPath, 'utf-8');
+                    sessions.push(JSON.parse(content));
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    async getCurrentProject() {
+        const projectPath = path_1.default.join(this.getProjectRoot(), 'project.json');
+        try {
+            const content = await promises_1.default.readFile(projectPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return {
+                    id: this.projectId,
+                    path: this.projectPath,
+                    updatedAt: new Date().toISOString(),
+                    sessionCount: 0,
+                    workflows: []
+                };
+            }
+            throw error;
+        }
+    }
+    async listProjects() {
+        const projects = [];
+        try {
+            const projectDirs = await promises_1.default.readdir(this.sessionsRoot);
+            for (const projectId of projectDirs) {
+                const projectPath = path_1.default.join(this.sessionsRoot, projectId, 'project.json');
+                try {
+                    const content = await promises_1.default.readFile(projectPath, 'utf-8');
+                    projects.push(JSON.parse(content));
+                }
+                catch (error) {
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        return projects;
+    }
+    getSessionsRoot() {
+        return this.sessionsRoot;
+    }
+    getProjectId() {
+        return this.projectId;
+    }
+    async updateProjectMetadata() {
+        const projectPath = path_1.default.join(this.getProjectRoot(), 'project.json');
+        const sessions = await this.listAllSessions();
+        const metadata = {
+            id: this.projectId,
+            path: this.projectPath,
+            updatedAt: new Date().toISOString(),
+            sessionCount: sessions.length,
+            workflows: [...new Set(sessions.map(s => s.workflowId))]
+        };
+        await promises_1.default.mkdir(path_1.default.dirname(projectPath), { recursive: true });
+        await promises_1.default.writeFile(projectPath, JSON.stringify(metadata, null, 2));
+    }
+    deepMerge(target, source) {
+        if (!source)
+            return target;
+        if (!target)
+            return source;
+        if (Array.isArray(source)) {
+            return source;
+        }
+        if (typeof source !== 'object') {
+            return source;
+        }
+        const output = { ...target };
+        for (const key in source) {
+            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+                output[key] = this.deepMerge(target[key] || {}, source[key]);
+            }
+            else {
+                output[key] = source[key];
+            }
+        }
+        return output;
+    }
+    getPath(obj, queryPath) {
+        const parts = queryPath.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === undefined || current === null)
+                return undefined;
+            const arrayMatch = part.match(/^(\w+)\[(.+)\]$/);
+            if (arrayMatch) {
+                const [, key, query] = arrayMatch;
+                current = current[key];
+                if (!current)
+                    return undefined;
+                if (Array.isArray(current) && query.startsWith('?')) {
+                    const filterMatch = query.match(/\?(\w+)==[']?([^']+)[']?/);
+                    if (filterMatch) {
+                        const [, field, value] = filterMatch;
+                        current = current.filter(item => String(item[field]) === value);
+                    }
+                }
+                else if (query.match(/^\d+$/)) {
+                    current = current[parseInt(query)];
+                }
+            }
+            else {
+                current = current[part];
+            }
+        }
+        return current;
+    }
+    async atomicWrite(filePath, data) {
+        const tempPath = `${filePath}.tmp.${Date.now()}`;
+        try {
+            await promises_1.default.writeFile(tempPath, JSON.stringify(data, null, 2), 'utf-8');
+            await promises_1.default.rename(tempPath, filePath);
+        }
+        catch (error) {
+            try {
+                await promises_1.default.unlink(tempPath);
+            }
+            catch { }
+            throw error;
+        }
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/infrastructure/session/index.d.ts

@@ -0,0 +1,2 @@
+export { SessionManager, Session, ProjectMetadata } from './SessionManager.js';
+export { HttpServer, ServerConfig } from './HttpServer.js';

package/dist/infrastructure/session/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpServer = exports.SessionManager = void 0;
+var SessionManager_js_1 = require("./SessionManager.js");
+Object.defineProperty(exports, "SessionManager", { enumerable: true, get: function () { return SessionManager_js_1.SessionManager; } });
+var HttpServer_js_1 = require("./HttpServer.js");
+Object.defineProperty(exports, "HttpServer", { enumerable: true, get: function () { return HttpServer_js_1.HttpServer; } });

package/dist/mcp-server.js

@@ -35,9 +35,23 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const container_js_1 = require("./container.js");
+const index_js_1 = require("./infrastructure/session/index.js");
+const session_tools_js_1 = require("./tools/session-tools.js");
 class WorkflowOrchestrationServer {
     constructor() {
         this.container = (0, container_js_1.createAppContainer)();
+        this.sessionManager = new index_js_1.SessionManager();
+        this.httpServer = new index_js_1.HttpServer(this.sessionManager, { autoOpen: false });
+        this.sessionTools = (0, session_tools_js_1.createSessionTools)(this.sessionManager, this.httpServer);
+    }
+    async initialize() {
+        await this.httpServer.start();
+    }
+    getSessionTools() {
+        return this.sessionTools;
+    }
+    async handleSessionTool(name, args) {
+        return (0, session_tools_js_1.handleSessionTool)(name, args, this.sessionManager, this.httpServer);
     }
     async callWorkflowMethod(method, params) {
         try {
@@ -341,6 +355,7 @@ async function runServer() {
         },
     });
     const workflowServer = new WorkflowOrchestrationServer();
+    await workflowServer.initialize();
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: [
             WORKFLOW_LIST_TOOL,
@@ -348,7 +363,8 @@ async function runServer() {
             WORKFLOW_NEXT_TOOL,
             WORKFLOW_VALIDATE_TOOL,
             WORKFLOW_VALIDATE_JSON_TOOL,
-            WORKFLOW_GET_SCHEMA_TOOL
+            WORKFLOW_GET_SCHEMA_TOOL,
+            ...workflowServer.getSessionTools()
         ],
     }));
     server.setRequestHandler(ListRootsRequestSchema, async () => {
@@ -366,6 +382,9 @@ async function runServer() {
     });
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
+        if (name.startsWith('workrail_')) {
+            return await workflowServer.handleSessionTool(name, args || {});
+        }
         switch (name) {
             case "workflow_list":
                 return await workflowServer.listWorkflows();

package/dist/tools/session-tools.d.ts

@@ -0,0 +1,5 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { SessionManager } from '../infrastructure/session/SessionManager.js';
+import { HttpServer } from '../infrastructure/session/HttpServer.js';
+export declare function createSessionTools(sessionManager: SessionManager, httpServer: HttpServer): Tool[];
+export declare function handleSessionTool(name: string, args: any, sessionManager: SessionManager, httpServer: HttpServer): Promise<any>;