elasticdash-sdk 0.2.0

package/src/workflow-runner-worker.ts

@@ -0,0 +1,386 @@
+// Mark this process as an Elasticdash worker before anything else runs
+;(globalThis as any).__ELASTICDASH_WORKER__ = true
+
+// Ensure .env is loaded in the worker subprocess
+import 'dotenv/config'
+/**
+ * workflow-runner-worker.ts
+ *
+ * Subprocess entry point for running a workflow function in an isolated Node.js
+ * process with a fresh ESM module cache, guaranteeing that packages with only an
+ * "import" exports condition (e.g. jaison) resolve correctly.
+ *
+ * Protocol (via stdin/stdout):
+ *   stdin  — one JSON line:
+ *              { workflowsModulePath, toolsModulePath?, workflowName, args, input }
+ *   stdout — prefixed result line: __ELASTICDASH_RESULT__:{...json...}
+ */
+
+import { startTraceSession, setCurrentTrace } from './trace-adapter/context.js'
+import { installAIInterceptor, uninstallAIInterceptor } from './interceptors/ai-interceptor.js'
+import { TraceRecorder, setCaptureContext, getCaptureContext } from './capture/recorder.js'
+import { ReplayController } from './capture/replay.js'
+import { interceptFetch, restoreFetch } from './interceptors/http.js'
+import { interceptRandom, restoreRandom, interceptDateNow, restoreDateNow, rawDateNow } from './interceptors/side-effects.js'
+import { installDBAutoInterceptor, uninstallDBAutoInterceptor } from './interceptors/db-auto.js'
+import { pathToFileURL } from 'node:url'
+import type { TraceHandle } from './trace-adapter/context.js'
+import type { WorkflowEvent } from './capture/event.js'
+import type { AgentState } from './types/agent.js'
+import fs from 'node:fs'
+
+const TOOL_WRAPPER_ACTIVE_KEY = '__elasticdash_tool_wrapper_active__'
+
+async function readStdin(): Promise<string> {
+  let raw = ''
+  for await (const chunk of process.stdin) {
+    raw += chunk
+  }
+  return raw.trim()
+}
+
+
+const RESULT_PREFIX = '__ELASTICDASH_RESULT__:'
+
+const IS_DENO = typeof (globalThis as any).Deno !== 'undefined'
+
+/** Write the result JSON to fd3 pipe (Node.js) or a prefixed stdout line (Deno).
+ *  Under Deno, fs.write on fd3 silently drops data before process exit, so we
+ *  use stdout with a unique prefix that the parent dashboard server reads. */
+function writeResult(result: unknown): Promise<void> {
+  return new Promise((resolve) => {
+    const json = JSON.stringify(result)
+    if (IS_DENO) {
+      process.stdout.write(RESULT_PREFIX + json + '\n', () => resolve())
+      return
+    }
+    try {
+      fs.write(3, json + '\n', (err) => {
+        if (err) {
+          process.stdout.write(RESULT_PREFIX + json + '\n', () => resolve())
+        } else {
+          resolve()
+        }
+      })
+    } catch {
+      process.stdout.write(RESULT_PREFIX + json + '\n', () => resolve())
+    }
+  })
+}
+
+/** Per-tool mock configuration sent from the dashboard UI */
+interface ToolMockEntry {
+  mode: 'live' | 'mock-all' | 'mock-specific'
+  callIndices?: number[]
+  mockData?: Record<number, unknown>
+}
+
+interface ToolMockConfig {
+  [toolName: string]: ToolMockEntry
+}
+
+/** Per-model AI mock configuration (mirrors ToolMockConfig) */
+interface AIMockEntry {
+  mode: 'live' | 'mock-all' | 'mock-specific'
+  callIndices?: number[]
+  mockData?: Record<number, unknown>
+}
+
+interface AIMockConfig {
+  [modelName: string]: AIMockEntry
+}
+
+/** Minimal inline tool-wrapping — records each tool call to the trace. */
+async function loadAndWrapTools(
+  toolsModulePath: string,
+  trace: TraceHandle,
+  toolMockConfig?: ToolMockConfig,
+): Promise<Record<string, (...a: unknown[]) => unknown>> {
+  try {
+    // Use absolute file URL for ESM import
+    const toolsMod = await import(pathToFileURL(toolsModulePath).href)
+    const wrapped: Record<string, (...a: unknown[]) => unknown> = {}
+    // Track per-tool call counters for mock-specific mode
+    const toolCallCounters: Record<string, number> = {}
+    for (const [name, fn] of Object.entries(toolsMod)) {
+      if (typeof fn !== 'function') continue
+      const mockEntry = toolMockConfig?.[name]
+      wrapped[name] = new Proxy(fn as (...a: unknown[]) => unknown, {
+        apply(target, thisArg, args) {
+          const recordedArgs = args.length === 1 ? args[0] : args
+          const ctx = getCaptureContext()
+          const id = ctx ? ctx.recorder.nextId() : -1
+          const start = rawDateNow()
+
+          // Replay: return historical result without executing
+          if (ctx && ctx.replay.shouldReplay(id)) {
+            const historical = ctx.replay.getRecordedEvent(id)
+            if (historical) ctx.recorder.record(historical)
+            const replayed = ctx.replay.getRecordedResult(id)
+            trace.recordToolCall({ name, args: recordedArgs, result: replayed, workflowEventId: id })
+            return replayed
+          }
+
+          // Mock: check if this tool call should be mocked
+          if (mockEntry && mockEntry.mode !== 'live') {
+            // Increment call counter for this tool (1-based)
+            if (!toolCallCounters[name]) toolCallCounters[name] = 0
+            toolCallCounters[name]++
+            const callNumber = toolCallCounters[name]
+
+            let shouldMock = false
+            let mockResult: unknown
+
+            if (mockEntry.mode === 'mock-all') {
+              shouldMock = true
+              // Use per-call mock data if available, otherwise default (key 0)
+              const data = mockEntry.mockData ?? {}
+              mockResult = data[callNumber] !== undefined ? data[callNumber] : data[0]
+            } else if (mockEntry.mode === 'mock-specific') {
+              const indices = mockEntry.callIndices ?? []
+              if (indices.includes(callNumber)) {
+                shouldMock = true
+                const data = mockEntry.mockData ?? {}
+                mockResult = data[callNumber]
+              }
+            }
+
+            if (shouldMock) {
+              if (ctx) ctx.recorder.record({ id, type: 'tool', name, input: recordedArgs, output: mockResult, timestamp: start, durationMs: 0 })
+              trace.recordToolCall({ name, args: recordedArgs, result: mockResult, workflowEventId: id })
+              return Promise.resolve(mockResult)
+            }
+          } else {
+            // Still track call count even for live tools
+            if (!toolCallCounters[name]) toolCallCounters[name] = 0
+            toolCallCounters[name]++
+          }
+
+          const g = globalThis as Record<string, unknown>
+          const prev = g[TOOL_WRAPPER_ACTIVE_KEY]
+          const restoreWrapperFlag = () => {
+            if (prev === undefined) delete g[TOOL_WRAPPER_ACTIVE_KEY]
+            else g[TOOL_WRAPPER_ACTIVE_KEY] = prev
+          }
+
+          g[TOOL_WRAPPER_ACTIVE_KEY] = true
+
+          let result: unknown
+          try {
+            result = Reflect.apply(target, thisArg, args)
+          } catch (e) {
+            restoreWrapperFlag()
+            throw e
+          }
+
+          if (result && typeof (result as Promise<unknown>).then === 'function') {
+            return (result as Promise<unknown>).then((v: unknown) => {
+              restoreWrapperFlag()
+              const durationMs = rawDateNow() - start
+              if (ctx) ctx.recorder.record({ id, type: 'tool', name, input: recordedArgs, output: v, timestamp: start, durationMs })
+              trace.recordToolCall({ name, args: recordedArgs, result: v, workflowEventId: id, durationMs })
+              return v
+            }).catch((e: unknown) => {
+              restoreWrapperFlag()
+              const durationMs = rawDateNow() - start
+              if (ctx) ctx.recorder.record({ id, type: 'tool', name, input: recordedArgs, output: { error: String(e) }, timestamp: start, durationMs })
+              trace.recordToolCall({ name, args: recordedArgs, result: { error: String(e) }, workflowEventId: id, durationMs })
+              throw e
+            })
+          }
+          restoreWrapperFlag()
+          const durationMs = rawDateNow() - start
+          if (ctx) ctx.recorder.record({ id, type: 'tool', name, input: recordedArgs, output: result, timestamp: start, durationMs })
+          trace.recordToolCall({ name, args: recordedArgs, result, workflowEventId: id, durationMs })
+          return result
+        },
+      })
+    }
+    return wrapped
+  } catch {
+    return {}
+  }
+}
+
+async function main() {
+  // Keep a reference to the real process.exit so we can call it after flushing stdout.
+  const originalExit = process.exit.bind(process)
+
+  const raw = await readStdin()
+
+  let payload: {
+    workflowsModulePath: string
+    toolsModulePath?: string
+    workflowName: string
+    args: unknown[]
+    input: unknown
+    replayMode?: boolean
+    checkpoint?: number
+    history?: WorkflowEvent[]
+    /** Optional agent state for mid-trace agent resumption */
+    agentState?: AgentState
+    /** Optional tool mock configuration from the dashboard UI */
+    toolMockConfig?: ToolMockConfig
+    /** Optional AI/LLM mock configuration from the dashboard UI */
+    aiMockConfig?: AIMockConfig
+    /** Optional prompt mock config: system prompt overrides keyed by original system prompt text */
+    promptMockConfig?: Record<string, unknown>
+    /** Optional user prompt mock config: keyed by original user message text */
+    userPromptMockConfig?: Record<string, { mode: 'live' | 'replace-all' | 'replace-specific'; replacement: string; callIndices?: number[] }>
+  }
+  try {
+    payload = JSON.parse(raw)
+  } catch (e) {
+    await writeResult({ ok: false, error: `Invalid JSON input: ${(e as Error).message}` })
+    originalExit(1)
+    return
+  }
+
+  const { workflowsModulePath, toolsModulePath, workflowName, args, input, replayMode = false, checkpoint = 0, history = [], agentState, toolMockConfig, aiMockConfig, promptMockConfig, userPromptMockConfig } = payload
+
+  const { context, finalise } = startTraceSession()
+  setCurrentTrace(context.trace)
+
+  const recorder = new TraceRecorder()
+  const replay = new ReplayController(replayMode, checkpoint, history)
+  setCaptureContext({ recorder, replay })
+
+  // Inject wrapped tools into global scope so the workflow can call them
+  // NOTE: This only works if the workflow accesses tools as globals, not via import.
+  // If the workflow uses import { tool } from './tools', the injected global will NOT be used.
+  // For maximum robustness, prefer passing tools as explicit arguments or context.
+  const globals = global as Record<string, unknown>
+  const originalValues: Record<string, unknown> = {}
+  let wrappedTools: Record<string, (...a: unknown[]) => unknown> = {}
+
+  if (toolsModulePath) {
+    wrappedTools = await loadAndWrapTools(toolsModulePath, context.trace, toolMockConfig)
+    for (const [name, fn] of Object.entries(wrappedTools)) {
+      originalValues[name] = globals[name]
+      globals[name] = fn
+    }
+  }
+
+  // Intercept process.exit() so that workflows that call it internally (e.g. agent
+  // frameworks that call process.exit(0) after completing) don't kill the subprocess
+  // before we write the result.
+  // WARNING: This only intercepts process.exit() in this scope. Libraries that cache their own reference to process.exit may still terminate the process.
+  let pendingExitCode: number | undefined
+  ;(process as NodeJS.Process).exit = (code?: number) => {
+    pendingExitCode = code ?? 0
+    return undefined as never
+  }
+
+  let currentOutput: unknown
+  let workflowError: Error | undefined
+
+  try {
+    // Write mock configs to globals so module-imported tools/AI can read them via resolveMock/resolveAIMock()
+    ;(globalThis as any).__ELASTICDASH_TOOL_MOCKS__ = toolMockConfig ?? {}
+    ;(globalThis as any).__ELASTICDASH_TOOL_CALL_COUNTERS__ = {}
+    ;(globalThis as any).__ELASTICDASH_AI_MOCKS__ = aiMockConfig ?? {}
+    ;(globalThis as any).__ELASTICDASH_AI_CALL_COUNTERS__ = {}
+    ;(globalThis as any).__ELASTICDASH_PROMPT_MOCKS__ = promptMockConfig ?? {}
+    ;(globalThis as any).__ELASTICDASH_PROMPT_CALL_COUNTERS__ = {}
+    ;(globalThis as any).__ELASTICDASH_USER_PROMPT_MOCKS__ = userPromptMockConfig ?? {}
+    ;(globalThis as any).__ELASTICDASH_USER_PROMPT_CALL_COUNTERS__ = {}
+
+    await installDBAutoInterceptor()
+    installAIInterceptor()
+    interceptFetch()
+    interceptRandom()
+    interceptDateNow()
+
+    try {
+      if (agentState) {
+        // Agent mid-trace resumption path: load ed_agents and resume from saved state
+        const agentsModulePath = workflowsModulePath.replace(/ed_workflows(\.[^.]+)?$/, 'ed_agents$1')
+        const agentsMod = await import(pathToFileURL(agentsModulePath).href)
+        if (typeof agentsMod.resumeAgentFromTrace !== 'function') {
+          throw new Error(`"resumeAgentFromTrace" is not an exported function in ${agentsModulePath}`)
+        }
+        currentOutput = await (agentsMod.resumeAgentFromTrace as (s: AgentState) => Promise<unknown>)(agentState)
+        console.error('[worker] resumeAgentFromTrace resolved, currentOutput:', currentOutput)
+      } else {
+        // Standard workflow path
+        const workflowsMod = await import(pathToFileURL(workflowsModulePath).href)
+        const workflowFn = workflowsMod[workflowName]
+        if (typeof workflowFn !== 'function') {
+          ;(process as NodeJS.Process).exit = originalExit
+          await writeResult({ ok: false, error: `"${workflowName}" is not an exported function in the workflow module.` })
+          originalExit(1)
+          return
+        }
+        // Standardize workflow argument resolution: always pass [input] if args is empty
+        const callArgs = args.length ? args : [input]
+        currentOutput = await (workflowFn as (...a: unknown[]) => unknown)(...callArgs)
+        console.error('[worker] workflowFn resolved, currentOutput:', currentOutput)  // stderr so it's visible
+      }
+    } finally {
+      uninstallAIInterceptor()
+      restoreFetch()
+      restoreRandom()
+      restoreDateNow()
+      uninstallDBAutoInterceptor()
+    }
+  } catch (e) {
+    workflowError = e instanceof Error ? e : new Error(String(e))
+  } finally {
+    // Restore real process.exit before any further async work
+    ;(process as NodeJS.Process).exit = originalExit
+
+    // Restore injected globals
+    for (const [name, original] of Object.entries(originalValues)) {
+      if (original === undefined) {
+        delete globals[name]
+      } else {
+        globals[name] = original
+      }
+    }
+    setCurrentTrace(undefined)
+    setCaptureContext(undefined)
+    finalise()
+
+    // Clear mock globals
+    delete (globalThis as any).__ELASTICDASH_TOOL_MOCKS__
+    delete (globalThis as any).__ELASTICDASH_TOOL_CALL_COUNTERS__
+    delete (globalThis as any).__ELASTICDASH_AI_MOCKS__
+    delete (globalThis as any).__ELASTICDASH_AI_CALL_COUNTERS__
+    delete (globalThis as any).__ELASTICDASH_PROMPT_MOCKS__
+    delete (globalThis as any).__ELASTICDASH_PROMPT_CALL_COUNTERS__
+    delete (globalThis as any).__ELASTICDASH_USER_PROMPT_MOCKS__
+    delete (globalThis as any).__ELASTICDASH_USER_PROMPT_CALL_COUNTERS__
+  }
+
+  await recorder.flush()
+
+  const traceData = {
+    steps: context.trace.getSteps(),
+    llmSteps: context.trace.getLLMSteps(),
+    toolCalls: context.trace.getToolCalls(),
+    customSteps: context.trace.getCustomSteps(),
+    workflowTrace: recorder.toTrace(),
+  }
+
+  if (workflowError) {
+    await writeResult({ ok: false, error: workflowError.message ?? String(workflowError), ...traceData })
+    originalExit(pendingExitCode ?? 1)
+  } else {
+    await writeResult({ ok: true, currentOutput, ...traceData })
+    originalExit(pendingExitCode ?? 0)
+  }
+}
+
+
+main().catch((err) => {
+  const errorJson = JSON.stringify({ ok: false, error: err?.message ?? String(err) })
+  if (IS_DENO) {
+    process.stdout.write(RESULT_PREFIX + errorJson + '\n', () => { process.exit(1) })
+    return
+  }
+  try {
+    fs.write(3, errorJson + '\n', () => { process.exit(1) })
+  } catch {
+    process.stdout.write(RESULT_PREFIX + errorJson + '\n', () => { process.exit(1) })
+  }
+})

package/src/workflow-runner.ts

@@ -0,0 +1,58 @@
+import { TraceRecorder, setCaptureContext } from './capture/recorder.js'
+import { ReplayController } from './capture/replay.js'
+import { interceptFetch, restoreFetch } from './interceptors/http.js'
+import { interceptRandom, restoreRandom, interceptDateNow, restoreDateNow } from './interceptors/side-effects.js'
+import { maybeCaptureTrace } from './ci/trace-writer.js'
+import type { WorkflowEvent, WorkflowTrace } from './capture/event.js'
+
+export interface RunWorkflowOptions {
+  replayMode?: boolean
+  checkpoint?: number
+  history?: WorkflowEvent[]
+  interceptHttp?: boolean
+  interceptSideEffects?: boolean
+}
+
+export interface WorkflowRunResult<T = unknown> {
+  result: T
+  trace: WorkflowTrace
+}
+
+export async function runWorkflow<T = unknown>(
+  workflowFn: () => Promise<T>,
+  options: RunWorkflowOptions = {},
+): Promise<WorkflowRunResult<T>> {
+  const {
+    replayMode = false,
+    checkpoint = 0,
+    history = [],
+    interceptHttp = true,
+    interceptSideEffects = true,
+  } = options
+
+  const recorder = new TraceRecorder()
+  const replay = new ReplayController(replayMode, checkpoint, history)
+
+  setCaptureContext({ recorder, replay })
+
+  if (interceptHttp) interceptFetch()
+  if (interceptSideEffects) {
+    interceptRandom()
+    interceptDateNow()
+  }
+
+  try {
+    const result = await workflowFn()
+    await recorder.flush()
+    const trace = recorder.toTrace()
+    await maybeCaptureTrace(trace.events, trace.traceId)
+    return { result, trace }
+  } finally {
+    if (interceptHttp) restoreFetch()
+    if (interceptSideEffects) {
+      restoreRandom()
+      restoreDateNow()
+    }
+    setCaptureContext(undefined)
+  }
+}