@ebowwa/workflows 0.1.0

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@ebowwa/workflows",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp/index.d.ts",
+      "import": "./dist/mcp/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && bun build ./src/index.ts ./src/mcp/index.ts --outdir ./dist --target bun --format esm && tsc --emitDeclarationOnly --declaration",
+    "dev": "bun run --watch src/index.ts",
+    "mcp": "bun run src/mcp/index.ts",
+    "server": "bun run server/index.ts",
+    "gui": "cd gui && bunx vite --port 3000",
+    "gui:build": "cd gui && bunx vite build",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ebowwa/cron-notifier": "^0.7.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "xterm": "^5.3.0",
+    "xterm-addon-fit": "^0.8.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@vitejs/plugin-react": "^4.2.0",
+    "typescript": "^5.0.0",
+    "vite": "^5.0.0"
+  },
+  "ownership": {
+    "domain": "automation",
+    "responsibilities": [
+      "ci-cd",
+      "workflows",
+      "job-scheduling",
+      "process-isolation"
+    ]
+  }
+}

package/src/index.ts

@@ -0,0 +1,72 @@
+/**
+ * @ebowwa/workflows - CI/CD Workflow System
+ *
+ * A GitHub Actions-like workflow system with process-level isolation,
+ * job scheduling, and real-time event streaming.
+ *
+ * @example
+ * ```typescript
+ * import { createRunner, WorkflowSchema } from '@ebowwa/workflows';
+ *
+ * const workflow = WorkflowSchema.parse({
+ *   id: 'build-test',
+ *   name: 'Build and Test',
+ *   triggers: [{ type: 'manual' }],
+ *   jobs: {
+ *     build: {
+ *       name: 'Build',
+ *       runsOn: 'bun',
+ *       steps: [
+ *         { name: 'Install', run: 'bun install' },
+ *         { name: 'Build', run: 'bun run build' },
+ *       ],
+ *     },
+ *     test: {
+ *       name: 'Test',
+ *       runsOn: 'bun',
+ *       needs: ['build'],
+ *       steps: [
+ *         { name: 'Test', run: 'bun test' },
+ *       ],
+ *     },
+ *   },
+ * });
+ *
+ * const runner = createRunner();
+ * runner.on('event', (event) => console.log(event));
+ * runner.on('log', (log) => process.stdout.write(log.content));
+ *
+ * const run = await runner.runWorkflow(workflow);
+ * console.log(`Workflow ${run.status}`);
+ * ```
+ */
+
+// Core types
+export * from './types.js';
+
+// Sandbox (process isolation)
+export {
+  ProcessSandbox,
+  createSandbox,
+  evaluateCondition,
+  type SandboxOptions,
+  type ActiveProcess,
+} from './sandbox.js';
+
+// Scheduler (job dependencies)
+export {
+  JobScheduler,
+  buildDependencyGraph,
+  createExecutionPlan,
+  getReadyJobs,
+  type JobNode,
+  type ExecutionPlan,
+} from './scheduler.js';
+
+// Runner (execution engine)
+export {
+  WorkflowRunner,
+  createRunner,
+  type RunnerOptions,
+  type RunOptions,
+} from './runner.js';

package/src/mcp/index.ts

@@ -0,0 +1,572 @@
+#!/usr/bin/env bun
+/**
+ * MCP Server for Workflow Control
+ *
+ * Provides MCP tools for:
+ * - Listing and managing workflows
+ * - Triggering workflow runs
+ * - Checking run status
+ * - Canceling runs
+ * - Streaming logs
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type Tool,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { randomUUID } from 'node:crypto';
+import {
+  WorkflowRunner,
+  createRunner,
+  WorkflowSchema,
+  type Workflow,
+  type WorkflowRun,
+  type Trigger,
+  type LogEntry,
+} from '../index.js';
+
+// ============================================================================
+// Tool Definitions
+// ============================================================================
+
+const WORKFLOW_LIST_TOOL: Tool = {
+  name: 'workflow_list',
+  description: 'List all registered workflows',
+  inputSchema: {
+    type: 'object',
+    properties: {},
+  },
+};
+
+const WORKFLOW_CREATE_TOOL: Tool = {
+  name: 'workflow_create',
+  description: 'Create a new workflow from a definition',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      workflow: {
+        type: 'object',
+        description: 'Workflow definition (Workflow schema)',
+      },
+    },
+    required: ['workflow'],
+  },
+};
+
+const WORKFLOW_GET_TOOL: Tool = {
+  name: 'workflow_get',
+  description: 'Get details of a specific workflow',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to retrieve',
+      },
+    },
+    required: ['workflowId'],
+  },
+};
+
+const WORKFLOW_DELETE_TOOL: Tool = {
+  name: 'workflow_delete',
+  description: 'Delete a workflow',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to delete',
+      },
+    },
+    required: ['workflowId'],
+  },
+};
+
+const WORKFLOW_RUN_TOOL: Tool = {
+  name: 'workflow_run',
+  description: 'Trigger a workflow run',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to run',
+      },
+      trigger: {
+        type: 'object',
+        description: 'Optional trigger configuration',
+      },
+      env: {
+        type: 'object',
+        description: 'Optional environment variables for this run',
+      },
+    },
+    required: ['workflowId'],
+  },
+};
+
+const RUN_LIST_TOOL: Tool = {
+  name: 'run_list',
+  description: 'List all workflow runs',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      workflowId: {
+        type: 'string',
+        description: 'Filter by workflow ID',
+      },
+      status: {
+        type: 'string',
+        enum: ['pending', 'running', 'success', 'failed', 'cancelled'],
+        description: 'Filter by status',
+      },
+      limit: {
+        type: 'number',
+        description: 'Maximum number of runs to return',
+      },
+    },
+  },
+};
+
+const RUN_GET_TOOL: Tool = {
+  name: 'run_get',
+  description: 'Get details of a specific run',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      runId: {
+        type: 'string',
+        description: 'Run ID to retrieve',
+      },
+    },
+    required: ['runId'],
+  },
+};
+
+const RUN_CANCEL_TOOL: Tool = {
+  name: 'run_cancel',
+  description: 'Cancel a running workflow',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      runId: {
+        type: 'string',
+        description: 'Run ID to cancel',
+      },
+    },
+    required: ['runId'],
+  },
+};
+
+const RUN_LOGS_TOOL: Tool = {
+  name: 'run_logs',
+  description: 'Get logs for a workflow run',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      runId: {
+        type: 'string',
+        description: 'Run ID to get logs for',
+      },
+      jobId: {
+        type: 'string',
+        description: 'Filter by job ID',
+      },
+    },
+    required: ['runId'],
+  },
+};
+
+// ============================================================================
+// MCP Server Implementation
+// ============================================================================
+
+export interface WorkflowMCPOptions {
+  /** Default workspace directory */
+  workspace?: string;
+  /** Default environment variables */
+  env?: Record<string, string>;
+}
+
+export class WorkflowMCPServer {
+  private server: Server;
+  private runner: WorkflowRunner;
+  private workflows = new Map<string, Workflow>();
+  private runs = new Map<string, WorkflowRun>();
+  private logs = new Map<string, LogEntry[]>();
+
+  constructor(options: WorkflowMCPOptions = {}) {
+    this.runner = createRunner({
+      workspace: options.workspace,
+      env: options.env,
+    });
+
+    // Collect logs for each run
+    this.runner.on('log', (entry: LogEntry) => {
+      const runLogs = this.logs.get(entry.stepId) ?? [];
+      runLogs.push(entry);
+      this.logs.set(entry.stepId, runLogs);
+    });
+
+    this.server = new Server(
+      {
+        name: '@ebowwa/workflows-mcp',
+        version: '0.1.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupHandlers();
+  }
+
+  private setupHandlers(): void {
+    // List tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          WORKFLOW_LIST_TOOL,
+          WORKFLOW_CREATE_TOOL,
+          WORKFLOW_GET_TOOL,
+          WORKFLOW_DELETE_TOOL,
+          WORKFLOW_RUN_TOOL,
+          RUN_LIST_TOOL,
+          RUN_GET_TOOL,
+          RUN_CANCEL_TOOL,
+          RUN_LOGS_TOOL,
+        ],
+      };
+    });
+
+    // Handle tool calls
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        switch (name) {
+          case 'workflow_list':
+            return await this.handleWorkflowList();
+
+          case 'workflow_create':
+            return await this.handleWorkflowCreate(args as { workflow: unknown });
+
+          case 'workflow_get':
+            return await this.handleWorkflowGet(args as { workflowId: string });
+
+          case 'workflow_delete':
+            return await this.handleWorkflowDelete(args as { workflowId: string });
+
+          case 'workflow_run':
+            return await this.handleWorkflowRun(args as {
+              workflowId: string;
+              trigger?: Trigger;
+              env?: Record<string, string>;
+            });
+
+          case 'run_list':
+            return await this.handleRunList(args as {
+              workflowId?: string;
+              status?: string;
+              limit?: number;
+            });
+
+          case 'run_get':
+            return await this.handleRunGet(args as { runId: string });
+
+          case 'run_cancel':
+            return await this.handleRunCancel(args as { runId: string });
+
+          case 'run_logs':
+            return await this.handleRunLogs(args as { runId: string; jobId?: string });
+
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+          content: [{ type: 'text', text: `Error: ${message}` }],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  // Workflow handlers
+  private async handleWorkflowList() {
+    const workflows = Array.from(this.workflows.values()).map(w => ({
+      id: w.id,
+      name: w.name,
+      triggers: w.triggers,
+      jobCount: Object.keys(w.jobs).length,
+    }));
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({ workflows, total: workflows.length }, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleWorkflowCreate(args: { workflow: unknown }) {
+    const workflow = WorkflowSchema.parse(args.workflow);
+
+    if (this.workflows.has(workflow.id)) {
+      throw new Error(`Workflow already exists: ${workflow.id}`);
+    }
+
+    this.workflows.set(workflow.id, workflow);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: true,
+            workflowId: workflow.id,
+            message: `Workflow '${workflow.name}' created`,
+          }, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleWorkflowGet(args: { workflowId: string }) {
+    const workflow = this.workflows.get(args.workflowId);
+
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${args.workflowId}`);
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(workflow, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleWorkflowDelete(args: { workflowId: string }) {
+    const deleted = this.workflows.delete(args.workflowId);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: deleted,
+            message: deleted
+              ? `Workflow ${args.workflowId} deleted`
+              : `Workflow ${args.workflowId} not found`,
+          }, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleWorkflowRun(args: {
+    workflowId: string;
+    trigger?: Trigger;
+    env?: Record<string, string>;
+  }) {
+    const workflow = this.workflows.get(args.workflowId);
+
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${args.workflowId}`);
+    }
+
+    // Run workflow asynchronously
+    const runPromise = this.runner.runWorkflow(workflow, {
+      trigger: args.trigger,
+      env: args.env,
+    });
+
+    // Store run when complete
+    runPromise.then(run => {
+      this.runs.set(run.id, run);
+    });
+
+    // Return immediately with run ID
+    const runId = randomUUID(); // This is a placeholder - actual ID generated by runner
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: true,
+            runId,
+            workflowId: args.workflowId,
+            message: `Workflow '${workflow.name}' triggered`,
+          }, null, 2),
+        },
+      ],
+    };
+  }
+
+  // Run handlers
+  private async handleRunList(args: {
+    workflowId?: string;
+    status?: string;
+    limit?: number;
+  }) {
+    let runs = Array.from(this.runs.values());
+
+    if (args.workflowId) {
+      runs = runs.filter(r => r.workflowId === args.workflowId);
+    }
+
+    if (args.status) {
+      runs = runs.filter(r => r.status === args.status);
+    }
+
+    if (args.limit) {
+      runs = runs.slice(0, args.limit);
+    }
+
+    const summary = runs.map(r => ({
+      id: r.id,
+      workflowId: r.workflowId,
+      status: r.status,
+      startedAt: r.startedAt,
+      finishedAt: r.finishedAt,
+    }));
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({ runs: summary, total: summary.length }, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleRunGet(args: { runId: string }) {
+    const run = this.runs.get(args.runId);
+
+    if (!run) {
+      throw new Error(`Run not found: ${args.runId}`);
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(run, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleRunCancel(args: { runId: string }) {
+    const cancelled = this.runner.cancelRun(args.runId);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: cancelled,
+            message: cancelled
+              ? `Run ${args.runId} cancelled`
+              : `Run ${args.runId} not found or already complete`,
+          }, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleRunLogs(args: { runId: string; jobId?: string }) {
+    const run = this.runs.get(args.runId);
+
+    if (!run) {
+      throw new Error(`Run not found: ${args.runId}`);
+    }
+
+    // Get logs for all jobs or specific job
+    let logs: LogEntry[] = [];
+
+    if (args.jobId) {
+      const jobRun = run.jobs[args.jobId];
+      if (jobRun?.logs) {
+        logs = jobRun.logs;
+      }
+    } else {
+      // Collect all logs
+      for (const jobRun of Object.values(run.jobs)) {
+        if (jobRun.logs) {
+          logs.push(...jobRun.logs);
+        }
+      }
+    }
+
+    // Sort by timestamp
+    logs.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({ runId: args.runId, logs }, null, 2),
+        },
+      ],
+    };
+  }
+
+  /**
+   * Start the MCP server
+   */
+  async start(): Promise<void> {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+  }
+
+  /**
+   * Get the underlying runner for direct access
+   */
+  getRunner(): WorkflowRunner {
+    return this.runner;
+  }
+
+  /**
+   * Add a workflow programmatically
+   */
+  addWorkflow(workflow: Workflow): void {
+    this.workflows.set(workflow.id, workflow);
+  }
+
+  /**
+   * Get a workflow by ID
+   */
+  getWorkflow(id: string): Workflow | undefined {
+    return this.workflows.get(id);
+  }
+}
+
+/**
+ * Create and start an MCP server
+ */
+export async function createMCPServer(options?: WorkflowMCPOptions): Promise<WorkflowMCPServer> {
+  const server = new WorkflowMCPServer(options);
+  await server.start();
+  return server;
+}
+
+// Auto-start if run directly
+if (import.meta.main) {
+  createMCPServer().catch(console.error);
+}