bonecode 1.0.0

package/src/engine/util/process.ts

@@ -0,0 +1,176 @@
+import { type ChildProcess } from "child_process"
+import launch from "cross-spawn"
+import { buffer } from "node:stream/consumers"
+import { errorMessage } from "./error"
+
+export type Stdio = "inherit" | "pipe" | "ignore"
+export type Shell = boolean | string
+
+export interface Options {
+  cwd?: string
+  env?: NodeJS.ProcessEnv | null
+  stdin?: Stdio
+  stdout?: Stdio
+  stderr?: Stdio
+  shell?: Shell
+  abort?: AbortSignal
+  kill?: NodeJS.Signals | number
+  timeout?: number
+}
+
+export interface RunOptions extends Omit<Options, "stdout" | "stderr"> {
+  nothrow?: boolean
+}
+
+export interface Result {
+  code: number
+  stdout: Buffer
+  stderr: Buffer
+}
+
+export interface TextResult extends Result {
+  text: string
+}
+
+export class RunFailedError extends Error {
+  readonly cmd: string[]
+  readonly code: number
+  readonly stdout: Buffer
+  readonly stderr: Buffer
+
+  constructor(cmd: string[], code: number, stdout: Buffer, stderr: Buffer) {
+    const text = stderr.toString().trim()
+    super(
+      text
+        ? `Command failed with code ${code}: ${cmd.join(" ")}\n${text}`
+        : `Command failed with code ${code}: ${cmd.join(" ")}`,
+    )
+    this.name = "ProcessRunFailedError"
+    this.cmd = [...cmd]
+    this.code = code
+    this.stdout = stdout
+    this.stderr = stderr
+  }
+}
+
+export type Child = ChildProcess & { exited: Promise<number> }
+
+export function spawn(cmd: string[], opts: Options = {}): Child {
+  if (cmd.length === 0) throw new Error("Command is required")
+  opts.abort?.throwIfAborted()
+
+  const proc = launch(cmd[0], cmd.slice(1), {
+    cwd: opts.cwd,
+    shell: opts.shell,
+    env: opts.env === null ? {} : opts.env ? { ...process.env, ...opts.env } : undefined,
+    stdio: [opts.stdin ?? "ignore", opts.stdout ?? "ignore", opts.stderr ?? "ignore"],
+    windowsHide: process.platform === "win32",
+  })
+
+  let closed = false
+  let timer: ReturnType<typeof setTimeout> | undefined
+
+  const abort = () => {
+    if (closed) return
+    if (proc.exitCode !== null || proc.signalCode !== null) return
+    closed = true
+
+    proc.kill(opts.kill ?? "SIGTERM")
+
+    const ms = opts.timeout ?? 5_000
+    if (ms <= 0) return
+    timer = setTimeout(() => proc.kill("SIGKILL"), ms)
+  }
+
+  const exited = new Promise<number>((resolve, reject) => {
+    const done = () => {
+      opts.abort?.removeEventListener("abort", abort)
+      if (timer) clearTimeout(timer)
+    }
+
+    proc.once("exit", (code, signal) => {
+      done()
+      resolve(code ?? (signal ? 1 : 0))
+    })
+
+    proc.once("error", (error) => {
+      done()
+      reject(error)
+    })
+  })
+  void exited.catch(() => undefined)
+
+  if (opts.abort) {
+    opts.abort.addEventListener("abort", abort, { once: true })
+    if (opts.abort.aborted) abort()
+  }
+
+  const child = proc as Child
+  child.exited = exited
+  return child
+}
+
+export async function run(cmd: string[], opts: RunOptions = {}): Promise<Result> {
+  const proc = spawn(cmd, {
+    cwd: opts.cwd,
+    env: opts.env,
+    stdin: opts.stdin,
+    shell: opts.shell,
+    abort: opts.abort,
+    kill: opts.kill,
+    timeout: opts.timeout,
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+
+  if (!proc.stdout || !proc.stderr) throw new Error("Process output not available")
+
+  const out = await Promise.all([proc.exited, buffer(proc.stdout), buffer(proc.stderr)])
+    .then(([code, stdout, stderr]) => ({
+      code,
+      stdout,
+      stderr,
+    }))
+    .catch((err: unknown) => {
+      if (!opts.nothrow) throw err
+      return {
+        code: 1,
+        stdout: Buffer.alloc(0),
+        stderr: Buffer.from(errorMessage(err)),
+      }
+    })
+  if (out.code === 0 || opts.nothrow) return out
+  throw new RunFailedError(cmd, out.code, out.stdout, out.stderr)
+}
+
+// Duplicated in `packages/sdk/js/src/process.ts` because the SDK cannot import
+// `opencode` without creating a cycle. Keep both copies in sync.
+export async function stop(proc: ChildProcess) {
+  if (proc.exitCode !== null || proc.signalCode !== null) return
+
+  if (process.platform !== "win32" || !proc.pid) {
+    proc.kill()
+    return
+  }
+
+  const out = await run(["taskkill", "/pid", String(proc.pid), "/T", "/F"], {
+    nothrow: true,
+  })
+
+  if (out.code === 0) return
+  proc.kill()
+}
+
+export async function text(cmd: string[], opts: RunOptions = {}): Promise<TextResult> {
+  const out = await run(cmd, opts)
+  return {
+    ...out,
+    text: out.stdout.toString(),
+  }
+}
+
+export async function lines(cmd: string[], opts: RunOptions = {}): Promise<string[]> {
+  return (await text(cmd, opts)).text.split(/\r?\n/).filter(Boolean)
+}
+
+export * as Process from "./process"

package/src/engine/util/queue.ts

@@ -0,0 +1,32 @@
+export class AsyncQueue<T> implements AsyncIterable<T> {
+  private queue: T[] = []
+  private resolvers: ((value: T) => void)[] = []
+
+  push(item: T) {
+    const resolve = this.resolvers.shift()
+    if (resolve) resolve(item)
+    else this.queue.push(item)
+  }
+
+  async next(): Promise<T> {
+    if (this.queue.length > 0) return this.queue.shift()!
+    return new Promise((resolve) => this.resolvers.push(resolve))
+  }
+
+  async *[Symbol.asyncIterator]() {
+    while (true) yield await this.next()
+  }
+}
+
+export async function work<T>(concurrency: number, items: T[], fn: (item: T) => Promise<void>) {
+  const pending = [...items]
+  await Promise.all(
+    Array.from({ length: concurrency }, async () => {
+      while (true) {
+        const item = pending.pop()
+        if (item === undefined) return
+        await fn(item)
+      }
+    }),
+  )
+}

package/src/engine/util/record.ts

@@ -0,0 +1,3 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value)
+}

package/src/engine/util/repository.ts

@@ -0,0 +1,158 @@
+import path from "path"
+import { fileURLToPath } from "url"
+import { Global } from "@opencode-ai/core/global"
+
+export type Reference = {
+  host: string
+  path: string
+  segments: string[]
+  owner?: string
+  repo: string
+  remote: string
+  label: string
+  protocol?: string
+}
+
+function normalize(input: string) {
+  return input
+    .trim()
+    .replace(/^git\+/, "")
+    .replace(/#.*$/, "")
+    .replace(/\/+$/, "")
+}
+
+function trimGitSuffix(input: string) {
+  return input.replace(/\.git$/, "")
+}
+
+function parts(input: string) {
+  return input
+    .split("/")
+    .map((item) => trimGitSuffix(item.trim()))
+    .filter(Boolean)
+}
+
+function safeHost(input: string) {
+  return Boolean(input) && !input.startsWith("-") && !/[\s/\\]/.test(input)
+}
+
+function safeSegment(input: string) {
+  return input !== "." && input !== ".." && !input.includes(":") && !/[\s/\\]/.test(input)
+}
+
+function hostLike(input: string) {
+  return input.includes(".") || input.includes(":") || input === "localhost"
+}
+
+function withSlash(input: string) {
+  return input.endsWith("/") ? input : `${input}/`
+}
+
+function githubRemote(pathname: string) {
+  const base = process.env.OPENCODE_REPO_CLONE_GITHUB_BASE_URL
+  if (!base) return `https://github.com/${pathname}.git`
+  return new URL(`${pathname}.git`, withSlash(base)).href
+}
+
+function build(input: { host: string; segments: string[]; remote?: string; protocol?: string }) {
+  const segments = input.segments.map(trimGitSuffix).filter(Boolean)
+  if (!safeHost(input.host) || !segments.length || segments.some((segment) => !safeSegment(segment))) return null
+  const pathname = segments.join("/")
+  const repo = segments[segments.length - 1]
+  const host = input.host.toLowerCase()
+  return {
+    host,
+    path: pathname,
+    segments,
+    owner: segments.length === 2 ? segments[0] : undefined,
+    repo,
+    remote: input.remote ?? (host === "github.com" ? githubRemote(pathname) : `https://${host}/${pathname}.git`),
+    label: host === "github.com" && segments.length === 2 ? pathname : `${host}/${pathname}`,
+    protocol: input.protocol,
+  } satisfies Reference
+}
+
+function buildFile(input: { url: URL; remote: string }) {
+  const filePath = path.normalize(fileURLToPath(input.url))
+  const segments = filePath.split(/[\\/]+/).filter(Boolean)
+  if (!segments.length) return null
+  return {
+    host: "file",
+    path: filePath,
+    segments: segments.map((segment) => segment.replace(/:$/, "")),
+    owner: undefined,
+    repo: trimGitSuffix(segments[segments.length - 1]),
+    remote: input.remote,
+    label: filePath,
+    protocol: "file:",
+  } satisfies Reference
+}
+
+export function parseRepositoryReference(input: string) {
+  const cleaned = normalize(input)
+  if (!cleaned) return null
+
+  const githubPrefixed = cleaned.match(/^github:([^/\s]+)\/([^/\s]+)$/)
+  if (githubPrefixed) return build({ host: "github.com", segments: [githubPrefixed[1], githubPrefixed[2]] })
+
+  if (!cleaned.includes("://")) {
+    const scp = cleaned.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/)
+    if (scp) return build({ host: scp[1], segments: parts(scp[2]), remote: cleaned })
+
+    const direct = parts(cleaned)
+    if (direct.length >= 2 && hostLike(direct[0])) {
+      return build({ host: direct[0], segments: direct.slice(1) })
+    }
+
+    if (direct.length === 2) {
+      return build({ host: "github.com", segments: direct })
+    }
+  }
+
+  try {
+    const url = new URL(cleaned)
+    if (url.protocol === "file:") return buildFile({ url, remote: cleaned })
+    const pathname = parts(url.pathname)
+    const host = url.host
+    return build({
+      host,
+      segments: pathname,
+      remote: host === "github.com" ? githubRemote(pathname.join("/")) : cleaned,
+      protocol: url.protocol,
+    })
+  } catch {
+    return null
+  }
+}
+
+export function parseRemoteRepositoryReference(input: string) {
+  const reference = parseRepositoryReference(input)
+  if (!reference) throw new Error("Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand")
+  if (reference.protocol === "file:") throw new Error("Local file repositories are not supported")
+  return reference
+}
+
+export function validateRepositoryBranch(branch: string) {
+  if (!/^[A-Za-z0-9/_.-]+$/.test(branch) || branch.startsWith("-") || branch.includes("..")) {
+    throw new Error(
+      "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain ..",
+    )
+  }
+}
+
+export function parseGitHubRemote(input: string) {
+  const cleaned = normalize(input)
+  if (!cleaned.includes("://") && !cleaned.match(/^(?:[^@/\s]+@)?github\.com:/)) return null
+
+  const parsed = parseRepositoryReference(cleaned)
+  if (!parsed || parsed.host !== "github.com" || !parsed.owner || parsed.segments.length !== 2) return null
+  return { owner: parsed.owner, repo: parsed.repo }
+}
+
+export function repositoryCachePath(input: Reference) {
+  return path.join(Global.Path.repos, ...input.host.split(":"), ...input.segments)
+}
+
+export function sameRepositoryReference(left: Reference, right: Reference) {
+  return left.host === right.host && left.path === right.path
+}

package/src/engine/util/rpc.ts

@@ -0,0 +1,66 @@
+type Definition = {
+  [method: string]: (input: any) => any
+}
+
+export function listen(rpc: Definition) {
+  onmessage = async (evt) => {
+    const parsed = JSON.parse(evt.data)
+    if (parsed.type === "rpc.request") {
+      const result = await rpc[parsed.method](parsed.input)
+      postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
+    }
+  }
+}
+
+export function emit(event: string, data: unknown) {
+  postMessage(JSON.stringify({ type: "rpc.event", event, data }))
+}
+
+export function client<T extends Definition>(target: {
+  postMessage: (data: string) => void | null
+  onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
+}) {
+  const pending = new Map<number, (result: any) => void>()
+  const listeners = new Map<string, Set<(data: any) => void>>()
+  let id = 0
+  target.onmessage = async (evt) => {
+    const parsed = JSON.parse(evt.data)
+    if (parsed.type === "rpc.result") {
+      const resolve = pending.get(parsed.id)
+      if (resolve) {
+        resolve(parsed.result)
+        pending.delete(parsed.id)
+      }
+    }
+    if (parsed.type === "rpc.event") {
+      const handlers = listeners.get(parsed.event)
+      if (handlers) {
+        for (const handler of handlers) {
+          handler(parsed.data)
+        }
+      }
+    }
+  }
+  return {
+    call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
+      const requestId = id++
+      return new Promise((resolve) => {
+        pending.set(requestId, resolve)
+        target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
+      })
+    },
+    on<Data>(event: string, handler: (data: Data) => void) {
+      let handlers = listeners.get(event)
+      if (!handlers) {
+        handlers = new Set()
+        listeners.set(event, handlers)
+      }
+      handlers.add(handler)
+      return () => {
+        handlers!.delete(handler)
+      }
+    },
+  }
+}
+
+export * as Rpc from "./rpc"

package/src/engine/util/signal.ts

@@ -0,0 +1,12 @@
+export function signal() {
+  let resolve: any
+  const promise = new Promise((r) => (resolve = r))
+  return {
+    trigger() {
+      return resolve()
+    },
+    wait() {
+      return promise
+    },
+  }
+}

package/src/engine/util/timeout.ts

@@ -0,0 +1,13 @@
+export function withTimeout<T>(promise: Promise<T>, ms: number, label?: string): Promise<T> {
+  let timeout: NodeJS.Timeout
+  return Promise.race([
+    promise.finally(() => {
+      clearTimeout(timeout)
+    }),
+    new Promise<never>((_, reject) => {
+      timeout = setTimeout(() => {
+        reject(new Error(label ?? `Operation timed out after ${ms}ms`))
+      }, ms)
+    }),
+  ])
+}

package/src/engine/util/token.ts

@@ -0,0 +1,7 @@
+const CHARS_PER_TOKEN = 4
+
+export function estimate(input: string) {
+  return Math.max(0, Math.round((input || "").length / CHARS_PER_TOKEN))
+}
+
+export * as Token from "./token"

package/src/engine/util/util/archive.ts

@@ -0,0 +1,17 @@
+import path from "path"
+import * as Process from "./process"
+
+export async function extractZip(zipPath: string, destDir: string) {
+  if (process.platform === "win32") {
+    const winZipPath = path.resolve(zipPath)
+    const winDestDir = path.resolve(destDir)
+    // $global:ProgressPreference suppresses PowerShell's blue progress bar popup
+    const cmd = `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -Path '${winZipPath}' -DestinationPath '${winDestDir}' -Force`
+    await Process.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd])
+    return
+  }
+
+  await Process.run(["unzip", "-o", "-q", zipPath, "-d", destDir])
+}
+
+export * as Archive from "./archive"

package/src/engine/util/util/bom.ts

@@ -0,0 +1,31 @@
+import { Effect } from "effect"
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+
+const BOM_CODE = 0xfeff
+const BOM = String.fromCharCode(BOM_CODE)
+
+export function split(text: string) {
+  if (text.charCodeAt(0) !== BOM_CODE) return { bom: false, text }
+  return { bom: true, text: text.slice(1) }
+}
+
+export function join(text: string, bom: boolean) {
+  const stripped = split(text).text
+  if (!bom) return stripped
+  return BOM + stripped
+}
+
+export const readFile = Effect.fn("Bom.readFile")(function* (fs: AppFileSystem.Interface, filePath: string) {
+  return split(new TextDecoder("utf-8", { ignoreBOM: true }).decode(yield* fs.readFile(filePath)))
+})
+
+export const syncFile = Effect.fn("Bom.syncFile")(function* (
+  fs: AppFileSystem.Interface,
+  filePath: string,
+  bom: boolean,
+) {
+  const current = yield* readFile(fs, filePath)
+  if (current.bom === bom) return current.text
+  yield* fs.writeWithDirs(filePath, join(current.text, bom))
+  return current.text
+})

package/src/engine/util/util/data-url.ts

@@ -0,0 +1,9 @@
+export function decodeDataUrl(url: string) {
+  const idx = url.indexOf(",")
+  if (idx === -1) return ""
+
+  const head = url.slice(0, idx)
+  const body = url.slice(idx + 1)
+  if (head.includes(";base64")) return Buffer.from(body, "base64").toString("utf8")
+  return decodeURIComponent(body)
+}

package/src/engine/util/util/defer.ts

@@ -0,0 +1,10 @@
+export function defer(fn: () => void | Promise<void>): AsyncDisposable & Disposable {
+  return {
+    [Symbol.dispose]() {
+      void fn()
+    },
+    [Symbol.asyncDispose]() {
+      return Promise.resolve(fn())
+    },
+  }
+}

package/src/engine/util/util/effect-http-client.ts

@@ -0,0 +1,11 @@
+import { Schedule } from "effect"
+import { HttpClient } from "effect/unstable/http"
+
+export const withTransientReadRetry = <E, R>(client: HttpClient.HttpClient.With<E, R>) =>
+  client.pipe(
+    HttpClient.retryTransient({
+      retryOn: "errors-and-responses",
+      times: 2,
+      schedule: Schedule.exponential(200).pipe(Schedule.jittered),
+    }),
+  )

package/src/engine/util/util/error.ts

@@ -0,0 +1,88 @@
+import { isRecord } from "./record"
+
+export function errorFormat(error: unknown): string {
+  if (error instanceof Error) {
+    return error.stack ?? `${error.name}: ${error.message}`
+  }
+
+  if (typeof error === "object" && error !== null) {
+    try {
+      const json = JSON.stringify(error, null, 2)
+      // Plain objects whose own properties are all non-enumerable (or empty)
+      // serialize to "{}", which prints as a useless bare `{}` on stderr.
+      // Fall back to a custom toString first, then to ctor name + own prop names.
+      if (json === "{}") {
+        const str = String(error)
+        if (str && str !== "[object Object]") return str
+        const ctor = error.constructor?.name
+        const prefix = ctor && ctor !== "Object" ? ctor : "Error"
+        const names = Object.getOwnPropertyNames(error)
+        return names.length === 0 ? `${prefix} (no message)` : `${prefix} { ${names.join(", ")} }`
+      }
+      return json
+    } catch {
+      return "Unexpected error (unserializable)"
+    }
+  }
+
+  return String(error)
+}
+
+export function errorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    if (error.message) return error.message
+    if (error.name) return error.name
+  }
+
+  if (isRecord(error) && typeof error.message === "string" && error.message) {
+    return error.message
+  }
+
+  if (isRecord(error) && isRecord(error.data) && typeof error.data.message === "string" && error.data.message) {
+    return error.data.message
+  }
+
+  const text = String(error)
+  if (text && text !== "[object Object]") return text
+
+  const formatted = errorFormat(error)
+  if (formatted) return formatted
+  return "unknown error"
+}
+
+export function errorData(error: unknown) {
+  if (error instanceof Error) {
+    return {
+      type: error.name,
+      message: errorMessage(error),
+      stack: error.stack,
+      cause: error.cause === undefined ? undefined : errorFormat(error.cause),
+      formatted: errorFormat(error),
+    }
+  }
+
+  if (!isRecord(error)) {
+    return {
+      type: typeof error,
+      message: errorMessage(error),
+      formatted: errorFormat(error),
+    }
+  }
+
+  const data = Object.getOwnPropertyNames(error).reduce<Record<string, unknown>>((acc, key) => {
+    const value = error[key]
+    if (value === undefined) return acc
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      acc[key] = value
+      return acc
+    }
+    // oxlint-disable-next-line no-base-to-string -- intentional coercion of arbitrary error properties
+    acc[key] = value instanceof Error ? value.message : String(value)
+    return acc
+  }, {})
+
+  if (typeof data.message !== "string") data.message = errorMessage(error)
+  if (typeof data.type !== "string") data.type = error.constructor?.name
+  data.formatted = errorFormat(error)
+  return data
+}