elasticdash-test 0.1.17 → 0.1.18-alpha

package/dist/utils/debug.js

@@ -0,0 +1,8 @@
+const DEBUG_KEY = 'ELASTICDASH_DEBUG';
+/** Log only when ELASTICDASH_DEBUG=1 is set. Drop-in replacement for console.log in interceptors. */
+export function debugLog(...args) {
+    if (typeof process !== 'undefined' && process.env?.[DEBUG_KEY] === '1') {
+        console.log(...args);
+    }
+}
+//# sourceMappingURL=debug.js.map

package/dist/utils/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.js","sourceRoot":"","sources":["../../src/utils/debug.ts"],"names":[],"mappings":"AAAA,MAAM,SAAS,GAAG,mBAAmB,CAAA;AAErC,qGAAqG;AACrG,MAAM,UAAU,QAAQ,CAAC,GAAG,IAAe;IACzC,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,KAAK,GAAG,EAAE,CAAC;QACvE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAA;IACtB,CAAC;AACH,CAAC"}

package/dist/utils/redact.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Deep-clones a value and replaces any object property whose key matches
+ * one of `keys` (case-insensitive) with "[REDACTED]".
+ * Returns the original value when `keys` is empty.
+ */
+export declare function redactPayload(value: unknown, keys: string[]): unknown;
+//# sourceMappingURL=redact.d.ts.map

package/dist/utils/redact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../src/utils/redact.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAIrE"}

package/dist/utils/redact.js

@@ -0,0 +1,26 @@
+/**
+ * Deep-clones a value and replaces any object property whose key matches
+ * one of `keys` (case-insensitive) with "[REDACTED]".
+ * Returns the original value when `keys` is empty.
+ */
+export function redactPayload(value, keys) {
+    if (keys.length === 0)
+        return value;
+    const lowerKeys = new Set(keys.map((k) => k.toLowerCase()));
+    return redact(value, lowerKeys);
+}
+function redact(value, keys) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value !== 'object')
+        return value;
+    if (Array.isArray(value)) {
+        return value.map((item) => redact(item, keys));
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        out[k] = keys.has(k.toLowerCase()) ? '[REDACTED]' : redact(v, keys);
+    }
+    return out;
+}
+//# sourceMappingURL=redact.js.map

package/dist/utils/redact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.js","sourceRoot":"","sources":["../../src/utils/redact.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc,EAAE,IAAc;IAC1D,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IACnC,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAA;IAC3D,OAAO,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;AACjC,CAAC;AAED,SAAS,MAAM,CAAC,KAAc,EAAE,IAAiB;IAC/C,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAA;IACvD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IAE3C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;IAChD,CAAC;IAED,MAAM,GAAG,GAA4B,EAAE,CAAA;IACvC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAgC,CAAC,EAAE,CAAC;QACtE,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAA;IACrE,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elasticdash-test",
-  "version": "0.1.17",
+  "version": "0.1.18-alpha",
   "description": "AI-native test runner for ElasticDash workflow testing",
   "type": "module",
   "bin": {
@@ -17,6 +17,14 @@
     "./http": {
       "types": "./dist/http.d.ts",
       "default": "./dist/http.js"
+    },
+    "./observability": {
+      "types": "./dist/observability.d.ts",
+      "default": "./dist/observability.js"
+    },
+    "./portal": {
+      "types": "./dist/portal-server.d.ts",
+      "default": "./dist/portal-server.js"
     }
   },
   "files": [

package/src/capture/event.ts

@@ -1,4 +1,4 @@
-export type WorkflowEventType = 'ai' | 'tool' | 'http' | 'db' | 'side_effect'
+export type WorkflowEventType = 'ai' | 'tool' | 'http' | 'db' | 'side_effect' | 'workflow'
 
 export interface WorkflowEvent {
   id: number
@@ -18,6 +18,10 @@ export interface WorkflowEvent {
   streamed?: boolean
   /** Raw buffered text of a streamed response (used for replay) */
   streamRaw?: string
+  /** Schema version for forward compatibility (default 1) */
+  schemaVersion?: number
+  /** Optional request-level trace ID for grouping events within a session */
+  traceId?: string
 }
 
 export interface WorkflowTrace {

package/src/cli.ts

@@ -12,6 +12,8 @@ import { runFiles } from './runner.js'
 import { reportResults } from './reporter.js'
 import { startBrowserUiServer, type UiEvent } from './browser-ui.js'
 import { startDashboardServer } from './dashboard-server.js'
+import { initObservability, shutdownObservability } from './observability.js'
+import { startPortalServer } from './portal-server.js'
 
 function stripAnsi(input?: string): string | undefined {
   if (!input) return input
@@ -306,6 +308,113 @@ async function bootstrap(): Promise<void> {
       process.once('SIGTERM', cleanup)
     })
 
+  // elasticdash observe
+  program
+    .command('observe')
+    .description('Start observability mode — stream trace events to ElasticDash backend')
+    .option('--server <url>', 'ElasticDash backend API URL', process.env.ELASTICDASH_API_URL)
+    .option('--api-key <key>', 'Project API key', process.env.ELASTICDASH_API_KEY)
+    .option('--service-id <id>', 'Service identifier', process.env.ELASTICDASH_SERVICE_ID)
+    .action(async (options: { server?: string; apiKey?: string; serviceId?: string }) => {
+      const serverUrl = options.server
+      if (!serverUrl) {
+        console.error('[elasticdash] Error: --server or ELASTICDASH_API_URL is required')
+        process.exit(1)
+      }
+
+      const handle = initObservability({
+        serverUrl,
+        apiKey: options.apiKey,
+        serviceId: options.serviceId,
+      })
+
+      console.log(`[elasticdash] Observability active`)
+      console.log(`  Session ID : ${handle.sessionId}`)
+      console.log(`  Server     : ${serverUrl}`)
+      console.log(`  Service    : ${options.serviceId ?? process.env.ELASTICDASH_SERVICE_ID ?? 'unknown-service'}`)
+      console.log(`[elasticdash] Press Ctrl+C to stop`)
+
+      let isShuttingDown = false
+      const cleanup = async () => {
+        if (isShuttingDown) {
+          process.exit(1)
+        }
+        isShuttingDown = true
+        console.log('\n[elasticdash] Shutting down observability...')
+        await shutdownObservability()
+        process.exit(0)
+      }
+
+      process.once('SIGINT', cleanup)
+      process.once('SIGTERM', cleanup)
+    })
+
+  // elasticdash portal
+  program
+    .command('portal')
+    .description('Start a portal server to receive and execute rerun tasks from ElasticDash backend')
+    .option('--server <url>', 'ElasticDash backend API URL to POST results to', process.env.ELASTICDASH_API_URL)
+    .option('--api-key <key>', 'Project API key', process.env.ELASTICDASH_API_KEY)
+    .option('--port <port>', 'Portal server port', (v) => Number(v), process.env.ELASTICDASH_PORTAL_PORT ? Number(process.env.ELASTICDASH_PORTAL_PORT) : 4574)
+    .option('--allowed-origins <origins>', 'Comma-separated list of additional allowed origin domains', process.env.ELASTICDASH_ALLOWED_ORIGINS)
+    .action(async (options: { server?: string; apiKey?: string; port: number; allowedOrigins?: string }) => {
+      const backendUrl = options.server
+      if (!backendUrl) {
+        console.error('[elasticdash] Error: --server or ELASTICDASH_API_URL is required')
+        process.exit(1)
+      }
+
+      const allowedOrigins = options.allowedOrigins
+        ? options.allowedOrigins.split(',').map(s => s.trim()).filter(Boolean)
+        : undefined
+
+      const handle = await startPortalServer({
+        port: options.port,
+        backendUrl,
+        apiKey: options.apiKey,
+        cwd,
+        allowedOrigins,
+      })
+
+      console.log(`[elasticdash] Portal server running`)
+      console.log(`  URL     : ${handle.url}`)
+      console.log(`  Backend : ${backendUrl}`)
+      console.log(`  Port    : ${handle.port}`)
+      console.log(`[elasticdash] Waiting for tasks from backend... Press Ctrl+C to stop`)
+
+      // Register with backend
+      try {
+        const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+        if (options.apiKey) headers['Authorization'] = `Bearer ${options.apiKey}`
+        const res = await fetch(`${backendUrl}/api/portal/register`, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({ portalUrl: handle.url }),
+        })
+        if (res.ok) {
+          console.log(`[elasticdash] Registered with backend`)
+        } else {
+          console.warn(`[elasticdash] Backend registration returned ${res.status} — portal will still accept tasks directly`)
+        }
+      } catch {
+        console.warn(`[elasticdash] Could not register with backend — portal will still accept tasks directly`)
+      }
+
+      let isShuttingDown = false
+      const cleanup = async () => {
+        if (isShuttingDown) {
+          process.exit(1)
+        }
+        isShuttingDown = true
+        console.log('\n[elasticdash] Shutting down portal...')
+        await handle.close()
+        process.exit(0)
+      }
+
+      process.once('SIGINT', cleanup)
+      process.once('SIGTERM', cleanup)
+    })
+
   await program.parseAsync(process.argv)
 }
 

package/src/execution/tool-runner.ts

@@ -0,0 +1,304 @@
+/**
+ * Shared tool/AI execution helpers for portal and dashboard.
+ * These are extracted versions of the helpers in dashboard-server.ts
+ * to avoid importing the full dashboard server module.
+ */
+import path from 'node:path'
+import { existsSync, readFileSync } from 'node:fs'
+import { spawn } from 'node:child_process'
+import { pathToFileURL } from 'node:url'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ToolInfo {
+  name: string
+  isAsync: boolean
+  signature: string
+  filePath: string
+  lineNumber?: number
+  sourceCode?: string
+}
+
+export interface RerunResult {
+  ok: boolean
+  currentOutput?: unknown
+  currentDurationMs?: number
+  currentUsage?: { inputTokens?: number; outputTokens?: number; totalTokens?: number }
+  error?: string
+}
+
+interface ParsedExport {
+  name: string
+  isAsync: boolean
+  signature: string
+  filePath: string
+  lineNumber?: number
+  sourceCode?: string
+}
+
+// ---------------------------------------------------------------------------
+// Runtime helpers
+// ---------------------------------------------------------------------------
+
+export function isDenoProject(dir: string): boolean {
+  return existsSync(path.join(dir, 'deno.json')) || existsSync(path.join(dir, 'deno.jsonc'))
+}
+
+export function resolveRuntimeModule(cwd: string, baseName: string): string | null {
+  for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+    const candidate = path.join(cwd, `${baseName}${ext}`)
+    if (existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+function parseSignatureParams(signature?: string): string[] {
+  if (!signature) return []
+  const trimmed = signature.trim()
+  if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) return []
+  const body = trimmed.slice(1, -1).trim()
+  if (!body) return []
+  return body
+    .split(',')
+    .map(part => part.trim())
+    .filter(Boolean)
+    .map(part => part.replace(/^\.\.\./, '').split('=')[0].split(':')[0].replace(/\?/g, '').trim())
+    .filter(part => /^[$A-Z_][0-9A-Z_$]*$/i.test(part))
+}
+
+// ---------------------------------------------------------------------------
+// Argument building
+// ---------------------------------------------------------------------------
+
+export function buildToolArgs(input: unknown, tool?: ToolInfo): unknown[] {
+  if (input === undefined) return []
+  if (Array.isArray(input)) return input
+  if (input && typeof input === 'object') {
+    const argObject = input as Record<string, unknown>
+    const paramNames = parseSignatureParams(tool?.signature)
+    if (paramNames.length > 0 && paramNames.every(name => Object.prototype.hasOwnProperty.call(argObject, name))) {
+      return paramNames.map(name => argObject[name])
+    }
+    return [input]
+  }
+  return [input]
+}
+
+// ---------------------------------------------------------------------------
+// Subprocess execution
+// ---------------------------------------------------------------------------
+
+export function runToolInSubprocess(
+  toolsModulePath: string,
+  toolName: string,
+  args: unknown[],
+): Promise<RerunResult> {
+  return new Promise((resolve) => {
+    const startMs = Date.now()
+    const workerScript = new URL('../tool-runner-worker.js', import.meta.url).pathname
+    const projectDir = path.dirname(toolsModulePath)
+    const denoProject = isDenoProject(projectDir)
+
+    const nodeOptions = process.env.NODE_OPTIONS ?? ''
+    const tsxFlag = '--import tsx'
+    const childNodeOptions = nodeOptions.includes('tsx') ? nodeOptions : `${nodeOptions} ${tsxFlag}`.trim()
+    const childEnv = { ...process.env, NODE_OPTIONS: denoProject ? nodeOptions : childNodeOptions }
+
+    const runtime = denoProject ? 'deno' : process.execPath
+    const runtimeArgs = denoProject ? ['run', '--allow-all', workerScript] : [workerScript]
+
+    const child = spawn(runtime, runtimeArgs, {
+      env: childEnv,
+      cwd: projectDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const RESULT_PREFIX = '__ELASTICDASH_RESULT__:'
+    let resultLine = ''
+    let stderr = ''
+
+    child.stdout.on('data', (chunk: Buffer) => {
+      const text = chunk.toString()
+      for (const line of text.split('\n')) {
+        if (line.startsWith(RESULT_PREFIX)) {
+          resultLine = line.slice(RESULT_PREFIX.length)
+        } else if (line) {
+          process.stdout.write(line + '\n')
+        }
+      }
+    })
+    child.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString()
+      process.stderr.write(chunk)
+    })
+
+    child.on('close', () => {
+      const currentDurationMs = Date.now() - startMs
+      if (resultLine) {
+        try {
+          resolve({ ...JSON.parse(resultLine), currentDurationMs })
+          return
+        } catch { /* fall through */ }
+      }
+      resolve({ ok: false, error: stderr.trim() || 'Tool subprocess produced no output.', currentDurationMs })
+    })
+
+    child.on('error', (err) => {
+      const hint = denoProject && (err as NodeJS.ErrnoException).code === 'ENOENT'
+        ? ' (Deno project detected — ensure "deno" is installed and available in PATH)'
+        : ''
+      resolve({ ok: false, error: `Failed to spawn tool subprocess: ${err.message}${hint}`, currentDurationMs: Date.now() - startMs })
+    })
+
+    const payload = JSON.stringify({
+      toolsModulePath: pathToFileURL(toolsModulePath).pathname,
+      toolName,
+      args,
+    })
+    child.stdin.write(payload)
+    child.stdin.end()
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Tool scanning (static analysis of ed_tools.ts/js)
+// ---------------------------------------------------------------------------
+
+function resolveModulePath(fromDir: string, specifier: string): string | null {
+  if (!specifier.startsWith('.')) return null
+  const exts = ['.ts', '.tsx', '.js', '.jsx', '']
+  for (const ext of exts) {
+    const candidate = path.resolve(fromDir, specifier + ext)
+    if (existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+function lineAt(src: string, index: number): number {
+  return src.slice(0, index).split('\n').length
+}
+
+function extractSource(src: string, index: number): string {
+  const snippet = src.slice(index, index + 2000)
+  return snippet.length < 2000 ? snippet : snippet + '\n// (truncated)'
+}
+
+function findFunctionInSource(src: string, name: string): { isAsync: boolean; signature: string; lineNumber?: number; sourceCode?: string } {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  let m = src.match(new RegExp(`export\\s+(async\\s+)?function\\s+${escaped}\\s*(\\([^)]*\\))`))
+  if (m) return { isAsync: !!m[1], signature: m[2], lineNumber: lineAt(src, m.index!), sourceCode: extractSource(src, m.index!) }
+  m = src.match(new RegExp(`(?:^|\\n)\\s*(?:async\\s+)?function\\s+${escaped}\\s*(\\([^)]*\\))`, 'm'))
+  if (m) return {
+    isAsync: new RegExp(`async\\s+function\\s+${escaped}`).test(src),
+    signature: m[1],
+    lineNumber: lineAt(src, m.index!),
+    sourceCode: extractSource(src, m.index!),
+  }
+  m = src.match(new RegExp(`export\\s+const\\s+${escaped}\\s*=\\s*(async\\s*)?(\\([^)]*\\))\\s*=>`))
+  if (m) return { isAsync: !!m[1], signature: m[2], lineNumber: lineAt(src, m.index!) }
+  m = src.match(new RegExp(`(?:^|\\n)\\s*const\\s+${escaped}\\s*=\\s*(async\\s*)?(\\([^)]*\\))\\s*=>`, 'm'))
+  if (m) return { isAsync: !!m[1], signature: m[2], lineNumber: lineAt(src, m.index!) }
+  return { isAsync: false, signature: '()' }
+}
+
+function extractExportsFromSource(filePath: string): ParsedExport[] {
+  let src: string
+  try {
+    src = readFileSync(filePath, 'utf8')
+  } catch {
+    return []
+  }
+  const dir = path.dirname(filePath)
+  const results: ParsedExport[] = []
+
+  // 1. Direct: export [async] function name(params) { … }
+  for (const m of src.matchAll(/export\s+(async\s+)?function\s+(\w+)\s*(\([^)]*\))/g)) {
+    results.push({
+      name: m[2], isAsync: !!m[1], signature: m[3], filePath,
+      lineNumber: lineAt(src, m.index!), sourceCode: extractSource(src, m.index!),
+    })
+  }
+
+  // 2. Direct: export const name = [async] (params) => …
+  for (const m of src.matchAll(/export\s+const\s+(\w+)\s*=\s*(async\s*)?\(([^)]*)\)\s*=>/g)) {
+    results.push({
+      name: m[1], isAsync: !!m[2], signature: `(${m[3]})`, filePath,
+      lineNumber: lineAt(src, m.index!), sourceCode: extractSource(src, m.index!),
+    })
+  }
+
+  // 3. Named re-exports: export { X [as Y], … } from './module'
+  for (const m of src.matchAll(/export\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g)) {
+    const modulePath = resolveModulePath(dir, m[2])
+    let moduleSrc = ''
+    try { if (modulePath) moduleSrc = readFileSync(modulePath, 'utf8') } catch { /* ignore */ }
+    for (const spec of m[1].split(',')) {
+      const parts = spec.trim().split(/\s+as\s+/)
+      const originalName = parts[0].trim()
+      const exportedName = (parts[1] ?? parts[0]).trim()
+      if (!exportedName || exportedName === 'default') continue
+      const info = moduleSrc ? findFunctionInSource(moduleSrc, originalName) : { isAsync: false, signature: '()' }
+      results.push({
+        name: exportedName, isAsync: info.isAsync, signature: info.signature,
+        filePath: modulePath ?? filePath, lineNumber: info.lineNumber, sourceCode: info.sourceCode,
+      })
+    }
+  }
+
+  // 4. Import + destructure: import { obj } from './m'  +  export const { a, b } = obj
+  for (const imp of src.matchAll(/import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g)) {
+    const importedNames = imp[1].split(',').map(s => {
+      const parts = s.trim().split(/\s+as\s+/)
+      return { original: parts[0].trim(), local: (parts[1] ?? parts[0]).trim() }
+    }).filter(n => n.local)
+    const modulePath = resolveModulePath(dir, imp[2])
+    for (const { local } of importedNames) {
+      const destructureRe = new RegExp(`export\\s+const\\s+\\{([^}]+)\\}\\s*=\\s*${local.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`)
+      const dm = src.match(destructureRe)
+      if (!dm) continue
+      let moduleSrc = ''
+      try { if (modulePath) moduleSrc = readFileSync(modulePath, 'utf8') } catch { /* ignore */ }
+      for (const member of dm[1].split(',')) {
+        const name = member.trim()
+        if (!name) continue
+        const info = moduleSrc ? findFunctionInSource(moduleSrc, name) : { isAsync: false, signature: '()' }
+        results.push({
+          name, isAsync: info.isAsync, signature: info.signature,
+          filePath: modulePath ?? filePath, lineNumber: info.lineNumber, sourceCode: info.sourceCode,
+        })
+      }
+    }
+  }
+
+  return results
+}
+
+export function scanTools(cwd: string): ToolInfo[] {
+  for (const candidate of [path.join(cwd, 'ed_tools.ts'), path.join(cwd, 'ed_tools.js')]) {
+    if (!existsSync(candidate)) continue
+    const exports = extractExportsFromSource(candidate)
+    if (exports.length > 0) {
+      return exports.map(e => ({
+        name: e.name, isAsync: e.isAsync, signature: e.signature,
+        filePath: e.filePath, lineNumber: e.lineNumber, sourceCode: e.sourceCode,
+      }))
+    }
+  }
+  return []
+}
+
+export function scanWorkflows(cwd: string): ToolInfo[] {
+  for (const candidate of [path.join(cwd, 'ed_workflows.ts'), path.join(cwd, 'ed_workflows.js')]) {
+    if (!existsSync(candidate)) continue
+    const exports = extractExportsFromSource(candidate)
+    if (exports.length > 0) {
+      return exports.map(e => ({
+        name: e.name, isAsync: e.isAsync, signature: e.signature,
+        filePath: e.filePath, lineNumber: e.lineNumber, sourceCode: e.sourceCode,
+      }))
+    }
+  }
+  return []
+}

package/src/http.ts

@@ -6,3 +6,5 @@
 export { setHttpRunContext, initHttpRunContext, getHttpRunContext } from './interceptors/telemetry-push.js'
 export { wrapTool } from './interceptors/tool.js'
 export { wrapAI } from './interceptors/workflow-ai.js'
+export { wrapDB, wrapPgClient, wrapKnex, wrapMongoCollection, wrapRedisClient } from './interceptors/db.js'
+export { initObservability, shutdownObservability, startTrace, wrapWorkflow } from './observability.js'

package/src/index.ts

@@ -71,6 +71,15 @@ export { interceptRandom, restoreRandom, interceptDateNow, restoreDateNow } from
 // AI interceptor (monkey-patch based)
 export { installAIInterceptor, uninstallAIInterceptor } from './interceptors/ai-interceptor.js'
 
+// Observability
+export { initObservability, shutdownObservability, startTrace, wrapWorkflow } from './observability.js'
+export type { ObservabilityOptions, ObservabilityHandle } from './observability.js'
+export { TelemetryBatcher } from './telemetry-batcher.js'
+export type { TelemetryBatcherOptions, TriggerSignal, TriggerStep } from './telemetry-batcher.js'
+export type { ObservabilityContext } from './interceptors/telemetry-push.js'
+export { checkToolAvailability, checkAIAvailability } from './portal-executor.js'
+export type { AvailabilityResult } from './portal-executor.js'
+
 // LLM proxy
 export { startLLMProxy, fetchCapturedTrace } from './proxy/llm-capture.js'
 
@@ -85,3 +94,8 @@ export type { RunWorkflowOptions, WorkflowRunResult } from './workflow-runner.js
 // Agent mid-trace replay
 export { serializeAgentState, deserializeAgentState, extractTaskOutputs, resolveTaskInput } from './core/agent-state.js'
 export type { AgentTask, AgentPlan, AgentState, AgentTaskStatus, AgentPlanStatus } from './types/agent.js'
+
+// Portal (remote rerun queue)
+export { startPortalServer } from './portal-server.js'
+export { executePortalTask } from './portal-executor.js'
+export type { PortalTask, PortalTaskResult, PortalServerOptions, PortalServerHandle, PortalStatus } from './types/portal.js'