@controlflow-ai/daemon 0.1.2 → 0.1.3

package/src/workflow-runtime.ts

@@ -0,0 +1,275 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Script, createContext } from 'node:vm';
+import type { MessageStore } from './db.js';
+import type { Message, RoomTask, WorkflowNode, WorkflowRunRecord } from './types.js';
+
+export interface WorkflowRunOptions {
+  filePath: string;
+  goal?: string | null;
+  createdBy?: string | null;
+  executor?: WorkflowAgentExecutor;
+}
+
+export interface WorkflowAgentNodeInput {
+  title: string;
+  role: string;
+  context?: Record<string, unknown> | null;
+  instruction: string;
+  capabilities?: string[];
+  outputContract?: Record<string, unknown> | null;
+}
+
+export interface WorkflowAgentExecutionInput extends WorkflowAgentNodeInput {
+  runId: string;
+  nodeId: string;
+}
+
+export interface WorkflowAgentExecutionResult {
+  output: Record<string, unknown>;
+  evidence?: Record<string, unknown> | null;
+}
+
+export type WorkflowAgentExecutor = (input: WorkflowAgentExecutionInput) => Promise<WorkflowAgentExecutionResult> | WorkflowAgentExecutionResult;
+
+export interface WorkflowContext {
+  readonly runId: string;
+  readonly goal: string | null;
+  phase<T>(title: string, fn: () => Promise<T> | T): Promise<T>;
+  agentNode(input: WorkflowAgentNodeInput): Promise<WorkflowNode>;
+  collectResults(nodes: WorkflowNode[]): Record<string, unknown>[];
+  createTask(input: { roomId: string; title: string; createdBy?: string | null; sourceMessageId?: number | null }): RoomTask;
+  sendRoomMessage(input: { roomId?: string; room?: string; sender: string; content: string; mentions?: string[] }): Message;
+  waitForNodeResult(node: WorkflowNode): Record<string, unknown>;
+  finalize(output: Record<string, unknown>, evidence?: Record<string, unknown> | null): WorkflowNode;
+}
+
+type WorkflowModule = {
+  default?: unknown;
+  workflow?: unknown;
+};
+
+const forbiddenWorkflowPatterns: Array<{ pattern: RegExp; label: string }> = [
+  { pattern: /^\s*import\s+(?!type\b)/mu, label: 'runtime imports are not allowed in workflow files' },
+  { pattern: /^\s*export\s+[^;\n]*\s+from\s+['"]/mu, label: 're-exports are not allowed in workflow files' },
+  { pattern: /\bimport\s*\(/u, label: 'dynamic import is not allowed in workflow files' },
+  { pattern: /\brequire\s*\(/u, label: 'require is not allowed in workflow files' },
+  { pattern: /\b(?:Bun|process|Deno)\b/u, label: 'host runtime globals are not available to workflow files' },
+  { pattern: /\b(?:eval|Function)\s*\(/u, label: 'dynamic code evaluation is not allowed in workflow files' },
+];
+
+function assertWorkflowSourceAllowed(filePath: string): void {
+  const source = readFileSync(filePath, 'utf8');
+  for (const rule of forbiddenWorkflowPatterns) {
+    if (rule.pattern.test(source)) {
+      throw new Error(`WORKFLOW_SCRIPT_REJECTED: ${rule.label}`);
+    }
+  }
+}
+
+function transformWorkflowSource(source: string): string {
+  const transpiler = new Bun.Transpiler({ loader: 'ts' });
+  const js = transpiler.transformSync(source);
+  return js
+    .replace(/\bexport\s+default\s+async\s+function\s+([A-Za-z_$][\w$]*)?/u, (_match, name: string | undefined) => `module.default = async function ${name ?? ''}`)
+    .replace(/\bexport\s+default\s+function\s+([A-Za-z_$][\w$]*)?/u, (_match, name: string | undefined) => `module.default = function ${name ?? ''}`)
+    .replace(/\bexport\s+default\s+/u, 'module.default = ')
+    .replace(/\bexport\s+async\s+function\s+workflow\s*\(/u, 'module.workflow = async function workflow(')
+    .replace(/\bexport\s+function\s+workflow\s*\(/u, 'module.workflow = function workflow(');
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  if (value && typeof value === 'object' && !Array.isArray(value)) return value as Record<string, unknown>;
+  return { value };
+}
+
+function normalizeAgentExecutionResult(value: unknown): WorkflowAgentExecutionResult {
+  if (value && typeof value === 'object' && !Array.isArray(value) && 'output' in value) {
+    const candidate = value as { output?: unknown; evidence?: unknown };
+    return {
+      output: asRecord(candidate.output),
+      evidence: candidate.evidence === undefined || candidate.evidence === null ? null : asRecord(candidate.evidence),
+    };
+  }
+  return { output: asRecord(value), evidence: null };
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+async function loadWorkflowFunction(filePath: string): Promise<(workflow: WorkflowContext) => Promise<unknown> | unknown> {
+  assertWorkflowSourceAllowed(filePath);
+  const source = readFileSync(filePath, 'utf8');
+  const module: WorkflowModule = {};
+  const context = createContext({
+    module,
+    exports: module,
+    console: Object.freeze({
+      log: console.log.bind(console),
+      warn: console.warn.bind(console),
+      error: console.error.bind(console),
+    }),
+  });
+  const script = new Script(`'use strict';\n${transformWorkflowSource(source)}`, {
+    filename: filePath,
+  });
+  script.runInContext(context, { timeout: 1000 });
+  const workflow = module.default ?? module.workflow;
+  if (typeof workflow !== 'function') {
+    throw new Error('workflow file must export a default function or named workflow function');
+  }
+  return workflow as (workflow: WorkflowContext) => Promise<unknown> | unknown;
+}
+
+export async function runWorkflowFile(store: MessageStore, options: WorkflowRunOptions): Promise<WorkflowRunRecord> {
+  const filePath = resolve(options.filePath);
+  if (!existsSync(filePath)) throw new Error(`workflow file was not found: ${filePath}`);
+
+  const run = store.createWorkflowRun({
+    filePath,
+    goal: options.goal ?? null,
+    createdBy: options.createdBy ?? null,
+  });
+  const parentStack: string[] = [];
+  let finalized = false;
+
+  const currentParentId = () => parentStack.at(-1) ?? null;
+
+  const context: WorkflowContext = {
+    runId: run.id,
+    goal: options.goal ?? null,
+
+    async phase<T>(title: string, fn: () => Promise<T> | T): Promise<T> {
+      const phase = store.createWorkflowNode({
+        runId: run.id,
+        parentId: currentParentId(),
+        kind: 'phase',
+        title,
+        status: 'running',
+      });
+      parentStack.push(phase.id);
+      try {
+        const result = await fn();
+        store.updateWorkflowNode(phase.id, { status: 'done', output: asRecord(result ?? { ok: true }) });
+        return result;
+      } catch (error) {
+        store.updateWorkflowNode(phase.id, { status: 'failed', evidence: { error: errorMessage(error) } });
+        throw error;
+      } finally {
+        parentStack.pop();
+      }
+    },
+
+    async agentNode(input: WorkflowAgentNodeInput): Promise<WorkflowNode> {
+      if (!input.role.trim()) throw new Error('agent node role is required');
+      if (!input.instruction.trim()) throw new Error('agent node instruction is required');
+      const node = store.createWorkflowNode({
+        runId: run.id,
+        parentId: currentParentId(),
+        kind: 'agent',
+        title: input.title,
+        role: input.role,
+        status: 'running',
+        context: input.context ?? null,
+        instruction: input.instruction,
+        capabilities: input.capabilities ?? [],
+        outputContract: input.outputContract ?? null,
+      });
+      try {
+        if (!options.executor) {
+          throw new Error('NO_WORKFLOW_AGENT_EXECUTOR: provide a deterministic or real agent executor');
+        }
+        const execution = normalizeAgentExecutionResult(await options.executor({ ...input, runId: run.id, nodeId: node.id }));
+        return store.updateWorkflowNode(node.id, {
+          status: 'done',
+          output: execution.output,
+          evidence: execution.evidence ?? { executor: 'workflow' },
+        });
+      } catch (error) {
+        store.updateWorkflowNode(node.id, { status: 'failed', evidence: { error: errorMessage(error) } });
+        throw error;
+      }
+    },
+
+    collectResults(nodes: WorkflowNode[]): Record<string, unknown>[] {
+      return nodes.map((node) => context.waitForNodeResult(node));
+    },
+
+    createTask(input: { roomId: string; title: string; createdBy?: string | null; sourceMessageId?: number | null }): RoomTask {
+      const task = store.createRoomTasks({
+        roomId: input.roomId,
+        titles: [input.title],
+        createdBy: input.createdBy ?? options.createdBy ?? null,
+        sourceMessageId: input.sourceMessageId ?? null,
+      })[0]!;
+      store.createWorkflowNode({
+        runId: run.id,
+        parentId: currentParentId(),
+        kind: 'task',
+        title: input.title,
+        status: 'done',
+        taskId: task.id,
+        output: { task_number: task.task_number, status: task.status, room_id: task.room_id },
+        evidence: { task_id: task.id },
+      });
+      return task;
+    },
+
+    sendRoomMessage(input: { roomId?: string; room?: string; sender: string; content: string; mentions?: string[] }): Message {
+      const message = store.createMessage({
+        chatId: input.roomId,
+        chatName: input.room,
+        sender: input.sender,
+        content: input.content,
+        mentions: input.mentions,
+      });
+      store.createWorkflowNode({
+        runId: run.id,
+        parentId: currentParentId(),
+        kind: 'message',
+        title: `Send room message #${message.id}`,
+        status: 'done',
+        messageId: message.id,
+        output: { message_id: message.id, room_id: message.chat_id },
+        evidence: { sender: message.sender },
+      });
+      return message;
+    },
+
+    waitForNodeResult(node: WorkflowNode): Record<string, unknown> {
+      const latest = store.getWorkflowNode(node.id);
+      if (!latest) throw new Error(`workflow node ${node.id} was not found`);
+      if (latest.status !== 'done') throw new Error(`workflow node ${node.id} is not done`);
+      return latest.output ?? {};
+    },
+
+    finalize(output: Record<string, unknown>, evidence?: Record<string, unknown> | null): WorkflowNode {
+      finalized = true;
+      const node = store.createWorkflowNode({
+        runId: run.id,
+        parentId: currentParentId(),
+        kind: 'final',
+        title: 'Finalize workflow output',
+        status: 'done',
+        output,
+        evidence: evidence ?? null,
+      });
+      store.finishWorkflowRun(run.id, { status: 'completed', finalOutput: output });
+      return node;
+    },
+  };
+
+  try {
+    const workflow = await loadWorkflowFunction(filePath);
+    const result = await workflow(context);
+    if (!finalized) {
+      store.finishWorkflowRun(run.id, { status: 'completed', finalOutput: asRecord(result ?? { ok: true }) });
+    }
+  } catch (error) {
+    store.finishWorkflowRun(run.id, { status: 'failed', error: errorMessage(error) });
+    throw error;
+  }
+
+  return store.getWorkflowRunRecord(run.id)!;
+}