@miphamai/cli 0.3.0 → 0.5.0

package/src/workflow/runtime.ts

@@ -0,0 +1,87 @@
+import { createSandbox } from './sandbox'
+import { createJournal, appendJournal } from './journal'
+import { createBudget } from './budget'
+import { workflowAgent } from './primitives/agent'
+import { parallel } from './primitives/parallel'
+import { pipeline } from './primitives/pipeline'
+import { phase as phasePrimitive } from './primitives/phase'
+import type { ProviderRegistry } from '../providers/registry'
+import type { QueryEngine } from '../core/engine'
+
+export interface WorkflowRunResult {
+  runId: string
+  result: unknown
+  journalEntries: number
+}
+
+/**
+ * Execute a workflow script string.
+ *
+ * The script is evaluated in a sandboxed context with the workflow
+ * primitives (agent, parallel, pipeline, phase, args, budget) injected.
+ */
+export async function runWorkflow(
+  script: string,
+  engine: QueryEngine,
+  args: unknown = {},
+  budgetTotal: number | null = null,
+): Promise<WorkflowRunResult> {
+  const runId = `run-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
+  createJournal(runId, script)
+
+  const registry: ProviderRegistry = engine.getRegistry()
+  const toolRegistry = engine.getTools()
+
+  const budget = createBudget(budgetTotal)
+
+  // Wrap primitives with journal recording
+  const agent = async (prompt: string, opts?: Record<string, unknown>) => {
+    const result = await workflowAgent(
+      prompt,
+      registry,
+      toolRegistry,
+      opts as Record<string, unknown>,
+    )
+    appendJournal(runId, {
+      type: 'agent',
+      prompt,
+      opts: opts as Record<string, unknown> | undefined,
+      result,
+    })
+    return result
+  }
+
+  const wrappedPhase = (title: string) => {
+    phasePrimitive(title)
+    appendJournal(runId, { type: 'phase', message: title })
+  }
+
+  const log = (message: string) => {
+    appendJournal(runId, { type: 'log', message })
+  }
+
+  const sandbox = createSandbox(args, budget)
+
+  // Build the script wrapper
+  const wrappedScript = `
+    return (async () => {
+      ${script}
+    })()
+  `
+
+  // Execute in sandboxed context
+  const scriptFn = new Function(
+    'agent',
+    'parallel',
+    'pipeline',
+    'phase',
+    'log',
+    'args',
+    'budget',
+    wrappedScript,
+  )
+
+  const result = await scriptFn(agent, parallel, pipeline, wrappedPhase, log, args, budget)
+
+  return { runId, result, journalEntries: 0 }
+}

package/src/workflow/sandbox.ts

@@ -0,0 +1,75 @@
+/** APIs disabled in workflow scripts to ensure deterministic replay. */
+const FORBIDDEN = new Set(['Date.now', 'Math.random', 'crypto.randomUUID'])
+
+/**
+ * Create a sandboxed global scope for workflow script execution.
+ * Blocks Date.now(), Math.random(), argless new Date(), crypto.randomUUID().
+ */
+export function createSandbox(
+  args: unknown,
+  budget: { total: number | null; spent(): number; remaining(): number },
+): Record<string, unknown> {
+  const sandbox: Record<string, unknown> = {
+    args,
+    budget,
+    console: {
+      log: (..._a: unknown[]) => {}, // no-op in sandbox
+      error: (..._a: unknown[]) => {},
+    },
+    // Primitives are injected by the runtime, not the sandbox
+  }
+
+  // Override Date to block now() and argless constructor
+  const OriginalDate = Date
+  sandbox.Date = new Proxy(OriginalDate, {
+    construct(_target, constructorArgs) {
+      if (constructorArgs.length === 0) {
+        throw new Error('new Date() is disabled in workflow sandbox. Pass timestamps via args.')
+      }
+      return new (OriginalDate as unknown as new (...a: unknown[]) => Date)(
+        ...(constructorArgs as [number]),
+      )
+    },
+    get(_target, prop) {
+      if (prop === 'now') {
+        throw new Error('Date.now() is disabled in workflow sandbox. Pass timestamps via args.')
+      }
+      const val = (OriginalDate as unknown as Record<string, unknown>)[prop as string]
+      return typeof val === 'function' ? (val as Function).bind(OriginalDate) : val
+    },
+  })
+
+  // Override Math.random
+  sandbox.Math = new Proxy(Math, {
+    get(_target, prop) {
+      if (prop === 'random') {
+        throw new Error('Math.random() is disabled in workflow sandbox. Use a seed from args.')
+      }
+      const val = (Math as unknown as Record<string, unknown>)[prop as string]
+      return typeof val === 'function' ? (val as Function).bind(Math) : val
+    },
+  })
+
+  // Block crypto.randomUUID
+  const globalCrypto = (globalThis as Record<string, unknown>).crypto as
+    | { randomUUID?: unknown; [key: string]: unknown }
+    | undefined
+  if (globalCrypto) {
+    sandbox.crypto = new Proxy(globalCrypto, {
+      get(_target, prop) {
+        if (prop === 'randomUUID') {
+          throw new Error('crypto.randomUUID() is disabled in workflow sandbox.')
+        }
+        const val = (globalCrypto as Record<string, unknown>)[prop as string]
+        return typeof val === 'function' ? (val as Function).bind(globalCrypto) : val
+      },
+    })
+  }
+
+  return sandbox
+}
+
+/** Check whether a given API identifier is in the forbidden set. */
+export function isForbidden(id: string): boolean {
+  return FORBIDDEN.has(id)
+}