@ebowwa/workflows 0.1.0

package/README.md

@@ -0,0 +1,257 @@
+# @ebowwa/workflows
+
+CI/CD Workflow System with process-level isolation, job scheduling, and real-time GUI support.
+
+## Features
+
+- **Process-level isolation** - Each step runs in an isolated process
+- **Job dependencies** - Define job ordering with `needs` field
+- **Parallel execution** - Jobs run in parallel when dependencies allow
+- **Real-time streaming** - WebSocket-based log streaming
+- **MCP integration** - Control workflows via Model Context Protocol
+- **Type-safe** - Full TypeScript support with Zod validation
+
+## Installation
+
+```bash
+bun add @ebowwa/workflows
+```
+
+## Quick Start
+
+### Define a Workflow
+
+```typescript
+import { WorkflowSchema, createRunner } 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' },
+      ],
+    },
+  },
+});
+```
+
+### Run the Workflow
+
+```typescript
+const runner = createRunner();
+
+// Listen for events
+runner.on('event', (event) => {
+  console.log(`[${event.type}] ${event.runId}`);
+});
+
+runner.on('log', (log) => {
+  process.stdout.write(log.content);
+});
+
+// Execute
+const run = await runner.runWorkflow(workflow);
+console.log(`Workflow ${run.status}`);
+```
+
+## API Reference
+
+### Types
+
+```typescript
+interface Workflow {
+  id: string;
+  name: string;
+  triggers: Trigger[];
+  jobs: Record<string, Job>;
+  env?: Record<string, string>;
+}
+
+interface Job {
+  name: string;
+  runsOn: 'bun' | 'tsx' | 'rust' | 'bash';
+  steps: Step[];
+  needs?: string[];  // Job dependencies
+  env?: Record<string, string>;
+  timeout?: number;
+}
+
+interface Step {
+  id?: string;
+  name?: string;
+  run: string;
+  cwd?: string;
+  env?: Record<string, string>;
+  condition?: string;  // 'success()', 'failure()', 'always()'
+  retry?: number;
+  timeout?: number;
+}
+```
+
+### Runner
+
+```typescript
+import { createRunner, WorkflowRunner } from '@ebowwa/workflows';
+
+const runner = createRunner({
+  workspace: '/path/to/workspace',
+  env: { NODE_ENV: 'production' },
+  maxConcurrentJobs: 4,
+});
+
+// Run workflow
+const run = await runner.runWorkflow(workflow, {
+  trigger: { type: 'manual' },
+  env: { CUSTOM_VAR: 'value' },
+});
+
+// Cancel run
+runner.cancelRun(run.id);
+
+// Events
+runner.on('event', (event) => { /* ... */ });
+runner.on('log', (log) => { /* ... */ });
+```
+
+## MCP Server
+
+Run the MCP server for LLM integration:
+
+```bash
+bun run @ebowwa/workflows/mcp
+```
+
+### MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `workflow_list` | List all workflows |
+| `workflow_create` | Create a new workflow |
+| `workflow_get` | Get workflow details |
+| `workflow_delete` | Delete a workflow |
+| `workflow_run` | Trigger a workflow run |
+| `run_list` | List workflow runs |
+| `run_get` | Get run details |
+| `run_cancel` | Cancel a running workflow |
+| `run_logs` | Get run logs |
+
+## REST API Server
+
+Run the API server with WebSocket support:
+
+```bash
+bun run server/index.ts
+```
+
+### Endpoints
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/workflows` | List workflows |
+| POST | `/api/workflows` | Create workflow |
+| GET | `/api/workflows/:id` | Get workflow |
+| DELETE | `/api/workflows/:id` | Delete workflow |
+| POST | `/api/workflows/:id/run` | Trigger run |
+| GET | `/api/runs` | List runs |
+| GET | `/api/runs/:id` | Get run |
+| DELETE | `/api/runs/:id` | Cancel run |
+| WS | `/ws/:runId` | Real-time logs |
+
+### WebSocket Protocol
+
+**Server → Client:**
+```typescript
+type ServerMessage =
+  | { type: 'job_started'; jobId: string }
+  | { type: 'step_started'; jobId: string; stepId: string }
+  | { type: 'log'; jobId: string; stepId: string; content: string; stream: 'stdout' | 'stderr' }
+  | { type: 'step_finished'; jobId: string; stepId: string; exitCode: number; duration: number }
+  | { type: 'job_finished'; jobId: string; status: string }
+  | { type: 'workflow_finished'; status: string };
+```
+
+**Client → Server:**
+```typescript
+type ClientMessage =
+  | { type: 'subscribe'; runId: string }
+  | { type: 'cancel' };
+```
+
+## Example: Complete Pipeline
+
+```typescript
+import { WorkflowSchema, createRunner } from '@ebowwa/workflows';
+
+const pipeline = WorkflowSchema.parse({
+  id: 'full-pipeline',
+  name: 'Full CI/CD Pipeline',
+  triggers: [
+    { type: 'git', events: ['push', 'pr'] },
+  ],
+  env: {
+    NODE_ENV: 'production',
+  },
+  jobs: {
+    install: {
+      name: 'Install Dependencies',
+      runsOn: 'bun',
+      steps: [
+        { name: 'Install', run: 'bun install --frozen-lockfile' },
+      ],
+    },
+    lint: {
+      name: 'Lint',
+      runsOn: 'bun',
+      needs: ['install'],
+      steps: [
+        { name: 'Lint', run: 'bun run lint' },
+      ],
+    },
+    test: {
+      name: 'Test',
+      runsOn: 'bun',
+      needs: ['install'],
+      steps: [
+        { name: 'Test', run: 'bun test --coverage' },
+      ],
+    },
+    build: {
+      name: 'Build',
+      runsOn: 'bun',
+      needs: ['lint', 'test'],
+      steps: [
+        { name: 'Build', run: 'bun run build' },
+      ],
+    },
+    deploy: {
+      name: 'Deploy',
+      runsOn: 'bun',
+      needs: ['build'],
+      steps: [
+        { name: 'Deploy', run: 'bun run deploy' },
+      ],
+    },
+  },
+});
+
+const runner = createRunner();
+const run = await runner.runWorkflow(pipeline);
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @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}`);
+ * ```
+ */
+export * from './types.js';
+export { ProcessSandbox, createSandbox, evaluateCondition, type SandboxOptions, type ActiveProcess, } from './sandbox.js';
+export { JobScheduler, buildDependencyGraph, createExecutionPlan, getReadyJobs, type JobNode, type ExecutionPlan, } from './scheduler.js';
+export { WorkflowRunner, createRunner, type RunnerOptions, type RunOptions, } from './runner.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EACL,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,KAAK,OAAO,EACZ,KAAK,aAAa,GACnB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,cAAc,EACd,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,UAAU,GAChB,MAAM,aAAa,CAAC"}