elasticdash-sdk 0.2.0

package/src/execution/tool-runner.ts

@@ -0,0 +1,352 @@
+/**
+ * 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'
+import { debugLog } from '../utils/debug.js'
+
+/**
+ * Resolve a worker script relative to the current module.
+ * Works in both ESM (import.meta.url is a valid file:// URL) and CJS
+ * (bundled as dist/index.cjs where import.meta is shimmed to {}).
+ */
+function resolveWorkerScript(relativePath: string): string {
+  try {
+    return new URL(relativePath, import.meta.url).pathname
+  } catch {
+    // CJS fallback: in the bundled index.cjs, import.meta.url is undefined.
+    // The worker script is a separate file in the same dist/ directory as the
+    // bundle, so resolve its basename against __dirname.
+    const workerName = path.basename(relativePath)
+    const dir = typeof __dirname !== 'undefined' ? __dirname : process.cwd()
+    return path.resolve(dir, workerName)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 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[],
+  frozenEvents?: unknown[],
+): Promise<RerunResult> {
+  return new Promise((resolve) => {
+    debugLog('[elasticdash portal] Spawning tool subprocess', { toolsModulePath, toolName, args, frozenEventsCount: frozenEvents?.length ?? 0 })
+    const startMs = Date.now()
+    const workerScript = resolveWorkerScript('../tool-runner-worker.js')
+    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]
+    debugLog(`[elasticdash portal] Runtime for tool subprocess: ${runtime} ${runtimeArgs.join(' ')}`, { isDenoProject: denoProject })
+
+    const child = spawn(runtime, runtimeArgs, {
+      env: childEnv,
+      cwd: projectDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const RESULT_PREFIX = '__ELASTICDASH_RESULT__:'
+    let resultLine = ''
+    let stderr = ''
+
+    // Line-buffer stdout so that large result JSON lines split across multiple
+    // data events are reassembled before processing.
+    let stdoutBuf = ''
+    child.stdout.on('data', (chunk: Buffer) => {
+      stdoutBuf += chunk.toString()
+      const lines = stdoutBuf.split('\n')
+      stdoutBuf = lines.pop() ?? '' // keep last (possibly incomplete) line
+      for (const line of lines) {
+        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
+
+      // Flush any remaining buffered stdout line (e.g. result with no trailing newline)
+      if (stdoutBuf.startsWith(RESULT_PREFIX)) {
+        resultLine = stdoutBuf.slice(RESULT_PREFIX.length)
+      } else if (stdoutBuf) {
+        process.stdout.write(stdoutBuf + '\n')
+      }
+
+      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)'
+        : ''
+      debugLog(`[elasticdash portal] Failed to spawn tool subprocess: ${err.message}${hint}`)
+      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,
+      frozenEvents: frozenEvents || [],
+    })
+    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!) }
+  // Wrapped: const name = wrapTool('name', [async] (params) => …)
+  m = src.match(new RegExp(`(?:export\\s+)?const\\s+${escaped}\\s*=\\s*\\w+\\(\\s*['"][^'"]*['"]\\s*,\\s*(async\\s*)?(\\([^)]*\\))\\s*=>`))
+  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. Wrapped: export const name = wrapTool('name', [async] (params) => …)
+  for (const m of src.matchAll(/export\s+const\s+(\w+)\s*=\s*\w+\(\s*['"][^'"]*['"]\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!),
+    })
+  }
+
+  // 4. 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,
+      })
+    }
+  }
+
+  // 5. 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 []
+}