alchemylab-opencode 1.0.7 → 1.0.9

package/packages/sdk/src/index.ts

@@ -1,21 +0,0 @@
-export * from "./client.js"
-export * from "./server.js"
-
-import { createOpencodeClient } from "./client.js"
-import { createOpencodeServer } from "./server.js"
-import type { ServerOptions } from "./server.js"
-
-export async function createOpencode(options?: ServerOptions) {
-  const server = await createOpencodeServer({
-    ...options,
-  })
-
-  const client = createOpencodeClient({
-    baseUrl: server.url,
-  })
-
-  return {
-    client,
-    server,
-  }
-}

package/packages/sdk/src/process.ts

@@ -1,31 +0,0 @@
-import { type ChildProcess, spawnSync } from "node:child_process"
-
-// Duplicated from `packages/opencode/src/util/process.ts` because the SDK cannot
-// import `opencode` without creating a cycle (`opencode` depends on `@opencode-ai/sdk`).
-export function stop(proc: ChildProcess) {
-  if (proc.exitCode !== null || proc.signalCode !== null) return
-  if (process.platform === "win32" && proc.pid) {
-    const out = spawnSync("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true })
-    if (!out.error && out.status === 0) return
-  }
-  proc.kill()
-}
-
-export function bindAbort(proc: ChildProcess, signal?: AbortSignal, onAbort?: () => void) {
-  if (!signal) return () => {}
-  const abort = () => {
-    clear()
-    stop(proc)
-    onAbort?.()
-  }
-  const clear = () => {
-    signal.removeEventListener("abort", abort)
-    proc.off("exit", clear)
-    proc.off("error", clear)
-  }
-  signal.addEventListener("abort", abort, { once: true })
-  proc.on("exit", clear)
-  proc.on("error", clear)
-  if (signal.aborted) abort()
-  return clear
-}

package/packages/sdk/src/server.ts

@@ -1,134 +0,0 @@
-import launch from "cross-spawn"
-import { type Config } from "./gen/types.gen.js"
-import { stop, bindAbort } from "./process.js"
-
-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 createOpencodeServer(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(`opencode`, args, {
-    env: {
-      ...process.env,
-      OPENCODE_CONFIG_CONTENT: JSON.stringify(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("opencode 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 createOpencodeTui(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(`opencode`, args, {
-    stdio: "inherit",
-    env: {
-      ...process.env,
-      OPENCODE_CONFIG_CONTENT: JSON.stringify(options?.config ?? {}),
-    },
-  })
-
-  const clear = bindAbort(proc, options?.signal)
-
-  return {
-    close() {
-      clear()
-      stop(proc)
-    },
-  }
-}

package/packages/sdk/src/v2/client.ts

@@ -1,81 +0,0 @@
-export * from "./gen/types.gen.js"
-
-import { createClient } from "./gen/client/client.gen.js"
-import { type Config } from "./gen/client/types.gen.js"
-import { OpencodeClient } from "./gen/sdk.gen.js"
-export { type Config as OpencodeClientConfig, OpencodeClient }
-
-function pick(value: string | null, fallback?: string, encode?: (value: string) => string) {
-  if (!value) return
-  if (!fallback) return value
-  if (value === fallback) return fallback
-  if (encode && value === encode(fallback)) return fallback
-  return value
-}
-
-function rewrite(request: Request, values: { directory?: string; workspace?: string }) {
-  if (request.method !== "GET" && request.method !== "HEAD") return request
-
-  const url = new URL(request.url)
-  let changed = false
-
-  for (const [name, key] of [
-    ["x-opencode-directory", "directory"],
-    ["x-opencode-workspace", "workspace"],
-  ] as const) {
-    const value = pick(
-      request.headers.get(name),
-      key === "directory" ? values.directory : values.workspace,
-      key === "directory" ? encodeURIComponent : undefined,
-    )
-    if (!value) continue
-    if (!url.searchParams.has(key)) {
-      url.searchParams.set(key, value)
-    }
-    changed = true
-  }
-
-  if (!changed) return request
-
-  const next = new Request(url, request)
-  next.headers.delete("x-opencode-directory")
-  next.headers.delete("x-opencode-workspace")
-  return next
-}
-
-export function createOpencodeClient(config?: Config & { directory?: string; experimental_workspaceID?: string }) {
-  if (!config?.fetch) {
-    const customFetch: any = (req: any) => {
-      // @ts-ignore
-      req.timeout = false
-      return fetch(req)
-    }
-    config = {
-      ...config,
-      fetch: customFetch,
-    }
-  }
-
-  if (config?.directory) {
-    config.headers = {
-      ...config.headers,
-      "x-opencode-directory": encodeURIComponent(config.directory),
-    }
-  }
-
-  if (config?.experimental_workspaceID) {
-    config.headers = {
-      ...config.headers,
-      "x-opencode-workspace": config.experimental_workspaceID,
-    }
-  }
-
-  const client = createClient(config)
-  client.interceptors.request.use((request) =>
-    rewrite(request, {
-      directory: config?.directory,
-      workspace: config?.experimental_workspaceID,
-    }),
-  )
-  return new OpencodeClient({ client })
-}

package/packages/sdk/src/v2/gen/client/client.gen.ts

@@ -1,285 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-import { createSseClient } from "../core/serverSentEvents.gen.js"
-import type { HttpMethod } from "../core/types.gen.js"
-import { getValidRequestBody } from "../core/utils.gen.js"
-import type { Client, Config, RequestOptions, ResolvedRequestOptions } from "./types.gen.js"
-import {
-  buildUrl,
-  createConfig,
-  createInterceptors,
-  getParseAs,
-  mergeConfigs,
-  mergeHeaders,
-  setAuthParams,
-} from "./utils.gen.js"
-
-type ReqInit = Omit<RequestInit, "body" | "headers"> & {
-  body?: any
-  headers: ReturnType<typeof mergeHeaders>
-}
-
-export const createClient = (config: Config = {}): Client => {
-  let _config = mergeConfigs(createConfig(), config)
-
-  const getConfig = (): Config => ({ ..._config })
-
-  const setConfig = (config: Config): Config => {
-    _config = mergeConfigs(_config, config)
-    return getConfig()
-  }
-
-  const interceptors = createInterceptors<Request, Response, unknown, ResolvedRequestOptions>()
-
-  const beforeRequest = async (options: RequestOptions) => {
-    const opts = {
-      ..._config,
-      ...options,
-      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders(_config.headers, options.headers),
-      serializedBody: undefined,
-    }
-
-    if (opts.security) {
-      await setAuthParams({
-        ...opts,
-        security: opts.security,
-      })
-    }
-
-    if (opts.requestValidator) {
-      await opts.requestValidator(opts)
-    }
-
-    if (opts.body !== undefined && opts.bodySerializer) {
-      opts.serializedBody = opts.bodySerializer(opts.body)
-    }
-
-    // remove Content-Type header if body is empty to avoid sending invalid requests
-    if (opts.body === undefined || opts.serializedBody === "") {
-      opts.headers.delete("Content-Type")
-    }
-
-    const url = buildUrl(opts)
-
-    return { opts, url }
-  }
-
-  const request: Client["request"] = async (options) => {
-    // @ts-expect-error
-    const { opts, url } = await beforeRequest(options)
-    const requestInit: ReqInit = {
-      redirect: "follow",
-      ...opts,
-      body: getValidRequestBody(opts),
-    }
-
-    let request = new Request(url, requestInit)
-
-    for (const fn of interceptors.request.fns) {
-      if (fn) {
-        request = await fn(request, opts)
-      }
-    }
-
-    // fetch must be assigned here, otherwise it would throw the error:
-    // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
-    const _fetch = opts.fetch!
-    let response: Response
-
-    try {
-      response = await _fetch(request)
-    } catch (error) {
-      // Handle fetch exceptions (AbortError, network errors, etc.)
-      let finalError = error
-
-      for (const fn of interceptors.error.fns) {
-        if (fn) {
-          finalError = (await fn(error, undefined as any, request, opts)) as unknown
-        }
-      }
-
-      finalError = finalError || ({} as unknown)
-
-      if (opts.throwOnError) {
-        throw finalError
-      }
-
-      // Return error response
-      return opts.responseStyle === "data"
-        ? undefined
-        : {
-            error: finalError,
-            request,
-            response: undefined as any,
-          }
-    }
-
-    for (const fn of interceptors.response.fns) {
-      if (fn) {
-        response = await fn(response, request, opts)
-      }
-    }
-
-    const result = {
-      request,
-      response,
-    }
-
-    if (response.ok) {
-      const parseAs =
-        (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json"
-
-      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
-        let emptyData: any
-        switch (parseAs) {
-          case "arrayBuffer":
-          case "blob":
-          case "text":
-            emptyData = await response[parseAs]()
-            break
-          case "formData":
-            emptyData = new FormData()
-            break
-          case "stream":
-            emptyData = response.body
-            break
-          case "json":
-          default:
-            emptyData = {}
-            break
-        }
-        return opts.responseStyle === "data"
-          ? emptyData
-          : {
-              data: emptyData,
-              ...result,
-            }
-      }
-
-      let data: any
-      switch (parseAs) {
-        case "arrayBuffer":
-        case "blob":
-        case "formData":
-        case "text":
-          data = await response[parseAs]()
-          break
-        case "json": {
-          // Some servers return 200 with no Content-Length and empty body.
-          // response.json() would throw; read as text and parse if non-empty.
-          const text = await response.text()
-          data = text ? JSON.parse(text) : {}
-          break
-        }
-        case "stream":
-          return opts.responseStyle === "data"
-            ? response.body
-            : {
-                data: response.body,
-                ...result,
-              }
-      }
-
-      if (parseAs === "json") {
-        if (opts.responseValidator) {
-          await opts.responseValidator(data)
-        }
-
-        if (opts.responseTransformer) {
-          data = await opts.responseTransformer(data)
-        }
-      }
-
-      return opts.responseStyle === "data"
-        ? data
-        : {
-            data,
-            ...result,
-          }
-    }
-
-    const textError = await response.text()
-    let jsonError: unknown
-
-    try {
-      jsonError = JSON.parse(textError)
-    } catch {
-      // noop
-    }
-
-    const error = jsonError ?? textError
-    let finalError = error
-
-    for (const fn of interceptors.error.fns) {
-      if (fn) {
-        finalError = (await fn(error, response, request, opts)) as string
-      }
-    }
-
-    finalError = finalError || ({} as string)
-
-    if (opts.throwOnError) {
-      throw finalError
-    }
-
-    // TODO: we probably want to return error and improve types
-    return opts.responseStyle === "data"
-      ? undefined
-      : {
-          error: finalError,
-          ...result,
-        }
-  }
-
-  const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) => request({ ...options, method })
-
-  const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
-    const { opts, url } = await beforeRequest(options)
-    return createSseClient({
-      ...opts,
-      body: opts.body as BodyInit | null | undefined,
-      headers: opts.headers as unknown as Record<string, string>,
-      method,
-      onRequest: async (url, init) => {
-        let request = new Request(url, init)
-        for (const fn of interceptors.request.fns) {
-          if (fn) {
-            request = await fn(request, opts)
-          }
-        }
-        return request
-      },
-      serializedBody: getValidRequestBody(opts) as BodyInit | null | undefined,
-      url,
-    })
-  }
-
-  return {
-    buildUrl,
-    connect: makeMethodFn("CONNECT"),
-    delete: makeMethodFn("DELETE"),
-    get: makeMethodFn("GET"),
-    getConfig,
-    head: makeMethodFn("HEAD"),
-    interceptors,
-    options: makeMethodFn("OPTIONS"),
-    patch: makeMethodFn("PATCH"),
-    post: makeMethodFn("POST"),
-    put: makeMethodFn("PUT"),
-    request,
-    setConfig,
-    sse: {
-      connect: makeSseFn("CONNECT"),
-      delete: makeSseFn("DELETE"),
-      get: makeSseFn("GET"),
-      head: makeSseFn("HEAD"),
-      options: makeSseFn("OPTIONS"),
-      patch: makeSseFn("PATCH"),
-      post: makeSseFn("POST"),
-      put: makeSseFn("PUT"),
-      trace: makeSseFn("TRACE"),
-    },
-    trace: makeMethodFn("TRACE"),
-  } as Client
-}

package/packages/sdk/src/v2/gen/client/index.ts

@@ -1,25 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-export type { Auth } from "../core/auth.gen.js"
-export type { QuerySerializerOptions } from "../core/bodySerializer.gen.js"
-export {
-  formDataBodySerializer,
-  jsonBodySerializer,
-  urlSearchParamsBodySerializer,
-} from "../core/bodySerializer.gen.js"
-export { buildClientParams } from "../core/params.gen.js"
-export { serializeQueryKeyValue } from "../core/queryKeySerializer.gen.js"
-export { createClient } from "./client.gen.js"
-export type {
-  Client,
-  ClientOptions,
-  Config,
-  CreateClientConfig,
-  Options,
-  RequestOptions,
-  RequestResult,
-  ResolvedRequestOptions,
-  ResponseStyle,
-  TDataShape,
-} from "./types.gen.js"
-export { createConfig, mergeHeaders } from "./utils.gen.js"