@saeeol/sdk 7.3.2 → 7.3.4

package/src/v2/index.ts

@@ -0,0 +1,23 @@
+export * from "./client.js"
+export * from "./server.js"
+
+import { createSaeeolClient } from "./client.js"
+import { createSaeeolServer } from "./server.js"
+import type { ServerOptions } from "./server.js"
+
+export * as data from "./data.js"
+
+export async function createSaeeol(options?: ServerOptions) {
+  const server = await createSaeeolServer({
+    ...options,
+  })
+
+  const client = createSaeeolClient({
+    baseUrl: server.url,
+  })
+
+  return {
+    client,
+    server,
+  }
+}

package/src/v2/server.ts

@@ -0,0 +1,163 @@
+import launch from "cross-spawn"
+import { type Config } from "./gen/types.gen.js"
+import { stop, bindAbort } from "../process.js"
+// This preserves Saeeol-injected modes when spawning nested CLI instances
+function mergeConfig(existing: Config | undefined, incoming: Config | undefined): Config {
+  const base = existing ?? {}
+  const override = incoming ?? {}
+  return {
+    ...base,
+    ...override,
+    agent: { ...base.agent, ...override.agent },
+    command: { ...base.command, ...override.command },
+    mcp: { ...base.mcp, ...override.mcp },
+    mode: { ...base.mode, ...override.mode },
+    plugin: [...(base.plugin ?? []), ...(override.plugin ?? [])],
+    instructions: [...(base.instructions ?? []), ...(override.instructions ?? [])],
+  }
+}
+
+function parseExistingConfig(): Config | undefined {
+  const content = process.env.SAEEOL_CONFIG_CONTENT
+  if (!content) return undefined
+  try {
+    return JSON.parse(content)
+  } catch {
+    return undefined
+  }
+}
+
+export function buildConfigEnv(config?: Config): string {
+  const merged = mergeConfig(parseExistingConfig(), config)
+  return JSON.stringify(merged)
+}
+
+export type ServerOptions = {
+  hostname?: string
+  port?: number
+  signal?: AbortSignal
+  timeout?: number
+  config?: Config
+}
+
+export type TuiOptions = {
+  project?: string
+  model?: string
+  session?: string
+  agent?: string
+  signal?: AbortSignal
+  config?: Config
+}
+
+export async function createSaeeolServer(options?: ServerOptions) {
+  options = Object.assign(
+    {
+      hostname: "127.0.0.1",
+      port: 4096,
+      timeout: 5000,
+    },
+    options ?? {},
+  )
+
+  const args = [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`]
+  if (options.config?.logLevel) args.push(`--log-level=${options.config.logLevel}`)
+  const proc = launch(`saeeol`, args, {
+    env: {
+      ...process.env,
+      SAEEOL_CONFIG_CONTENT: buildConfigEnv(options.config), 
+    },
+  })
+  let clear = () => {}
+
+  const url = await new Promise<string>((resolve, reject) => {
+    const id = setTimeout(() => {
+      clear()
+      stop(proc)
+      reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`))
+    }, options.timeout)
+    let output = ""
+    let resolved = false
+    proc.stdout?.on("data", (chunk) => {
+      if (resolved) return
+      output += chunk.toString()
+      const lines = output.split("\n")
+      for (const line of lines) {
+        if (line.startsWith("saeeol server listening")) {
+          const match = line.match(/on\s+(https?:\/\/[^\s]+)/)
+          if (!match) {
+            clear()
+            stop(proc)
+            clearTimeout(id)
+            reject(new Error(`Failed to parse server url from output: ${line}`))
+            return
+          }
+          clearTimeout(id)
+          resolved = true
+          resolve(match[1]!)
+          return
+        }
+      }
+    })
+    proc.stderr?.on("data", (chunk) => {
+      output += chunk.toString()
+    })
+    proc.on("exit", (code) => {
+      clearTimeout(id)
+      let msg = `Server exited with code ${code}`
+      if (output.trim()) {
+        msg += `\nServer output: ${output}`
+      }
+      reject(new Error(msg))
+    })
+    proc.on("error", (error) => {
+      clearTimeout(id)
+      reject(error)
+    })
+    clear = bindAbort(proc, options.signal, () => {
+      clearTimeout(id)
+      reject(options.signal?.reason)
+    })
+  })
+
+  return {
+    url,
+    close() {
+      clear()
+      stop(proc)
+    },
+  }
+}
+
+export function createSaeeolTui(options?: TuiOptions) {
+  const args = []
+
+  if (options?.project) {
+    args.push(`--project=${options.project}`)
+  }
+  if (options?.model) {
+    args.push(`--model=${options.model}`)
+  }
+  if (options?.session) {
+    args.push(`--session=${options.session}`)
+  }
+  if (options?.agent) {
+    args.push(`--agent=${options.agent}`)
+  }
+  const proc = launch(`saeeol`, args, {
+    stdio: "inherit",
+    windowsHide: true,
+    env: {
+      ...process.env,
+      SAEEOL_CONFIG_CONTENT: buildConfigEnv(options?.config), 
+    },
+  })
+
+  const clear = bindAbort(proc, options?.signal)
+
+  return {
+    close() {
+      clear()
+      stop(proc)
+    },
+  }
+}