@stonerzju/opencode 1.2.16-offline.1

package/src/util/log.ts

@@ -0,0 +1,182 @@
+import path from "path"
+import fs from "fs/promises"
+import { createWriteStream } from "fs"
+import { Global } from "../global"
+import z from "zod"
+import { Glob } from "./glob"
+
+export namespace Log {
+  export const Level = z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" })
+  export type Level = z.infer<typeof Level>
+
+  const levelPriority: Record<Level, number> = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+  }
+
+  let level: Level = "INFO"
+
+  function shouldLog(input: Level): boolean {
+    return levelPriority[input] >= levelPriority[level]
+  }
+
+  export type Logger = {
+    debug(message?: any, extra?: Record<string, any>): void
+    info(message?: any, extra?: Record<string, any>): void
+    error(message?: any, extra?: Record<string, any>): void
+    warn(message?: any, extra?: Record<string, any>): void
+    tag(key: string, value: string): Logger
+    clone(): Logger
+    time(
+      message: string,
+      extra?: Record<string, any>,
+    ): {
+      stop(): void
+      [Symbol.dispose](): void
+    }
+  }
+
+  const loggers = new Map<string, Logger>()
+
+  export const Default = create({ service: "default" })
+
+  export interface Options {
+    print: boolean
+    dev?: boolean
+    level?: Level
+  }
+
+  let logpath = ""
+  export function file() {
+    return logpath
+  }
+  let write = (msg: any) => {
+    process.stderr.write(msg)
+    return msg.length
+  }
+
+  export async function init(options: Options) {
+    if (options.level) level = options.level
+    cleanup(Global.Path.log)
+    if (options.print) return
+    logpath = path.join(
+      Global.Path.log,
+      options.dev ? "dev.log" : new Date().toISOString().split(".")[0].replace(/:/g, "") + ".log",
+    )
+    await fs.truncate(logpath).catch(() => {})
+    const stream = createWriteStream(logpath, { flags: "a" })
+    write = async (msg: any) => {
+      return new Promise((resolve, reject) => {
+        stream.write(msg, (err) => {
+          if (err) reject(err)
+          else resolve(msg.length)
+        })
+      })
+    }
+  }
+
+  async function cleanup(dir: string) {
+    const files = await Glob.scan("????-??-??T??????.log", {
+      cwd: dir,
+      absolute: true,
+      include: "file",
+    })
+    if (files.length <= 5) return
+
+    const filesToDelete = files.slice(0, -10)
+    await Promise.all(filesToDelete.map((file) => fs.unlink(file).catch(() => {})))
+  }
+
+  function formatError(error: Error, depth = 0): string {
+    const result = error.message
+    return error.cause instanceof Error && depth < 10
+      ? result + " Caused by: " + formatError(error.cause, depth + 1)
+      : result
+  }
+
+  let last = Date.now()
+  export function create(tags?: Record<string, any>) {
+    tags = tags || {}
+
+    const service = tags["service"]
+    if (service && typeof service === "string") {
+      const cached = loggers.get(service)
+      if (cached) {
+        return cached
+      }
+    }
+
+    function build(message: any, extra?: Record<string, any>) {
+      const prefix = Object.entries({
+        ...tags,
+        ...extra,
+      })
+        .filter(([_, value]) => value !== undefined && value !== null)
+        .map(([key, value]) => {
+          const prefix = `${key}=`
+          if (value instanceof Error) return prefix + formatError(value)
+          if (typeof value === "object") return prefix + JSON.stringify(value)
+          return prefix + value
+        })
+        .join(" ")
+      const next = new Date()
+      const diff = next.getTime() - last
+      last = next.getTime()
+      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n"
+    }
+    const result: Logger = {
+      debug(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("DEBUG")) {
+          write("DEBUG " + build(message, extra))
+        }
+      },
+      info(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("INFO")) {
+          write("INFO  " + build(message, extra))
+        }
+      },
+      error(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("ERROR")) {
+          write("ERROR " + build(message, extra))
+        }
+      },
+      warn(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("WARN")) {
+          write("WARN  " + build(message, extra))
+        }
+      },
+      tag(key: string, value: string) {
+        if (tags) tags[key] = value
+        return result
+      },
+      clone() {
+        return Log.create({ ...tags })
+      },
+      time(message: string, extra?: Record<string, any>) {
+        const now = Date.now()
+        result.info(message, { status: "started", ...extra })
+        function stop() {
+          result.info(message, {
+            status: "completed",
+            duration: Date.now() - now,
+            ...extra,
+          })
+        }
+        return {
+          stop,
+          [Symbol.dispose]() {
+            stop()
+          },
+        }
+      },
+    }
+
+    if (service && typeof service === "string") {
+      loggers.set(service, result)
+    }
+
+    return result
+  }
+}

package/src/util/process.ts

@@ -0,0 +1,126 @@
+import { spawn as launch, type ChildProcess } from "child_process"
+import { buffer } from "node:stream/consumers"
+
+export namespace Process {
+  export type Stdio = "inherit" | "pipe" | "ignore"
+
+  export interface Options {
+    cwd?: string
+    env?: NodeJS.ProcessEnv | null
+    stdin?: Stdio
+    stdout?: Stdio
+    stderr?: Stdio
+    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 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,
+      env: opts.env === null ? {} : opts.env ? { ...process.env, ...opts.env } : undefined,
+      stdio: [opts.stdin ?? "ignore", opts.stdout ?? "ignore", opts.stderr ?? "ignore"],
+    })
+
+    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)
+      })
+    })
+
+    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,
+      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 [code, stdout, stderr] = await Promise.all([proc.exited, buffer(proc.stdout), buffer(proc.stderr)])
+    const out = {
+      code,
+      stdout,
+      stderr,
+    }
+    if (out.code === 0 || opts.nothrow) return out
+    throw new RunFailedError(cmd, out.code, out.stdout, out.stderr)
+  }
+}

package/src/util/proxied.ts

@@ -0,0 +1,3 @@
+export function proxied() {
+  return !!(process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)
+}

package/src/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/util/rpc.ts

@@ -0,0 +1,66 @@
+export namespace Rpc {
+  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)
+        }
+      },
+    }
+  }
+}

package/src/util/scrap.ts

@@ -0,0 +1,10 @@
+export const foo: string = "42"
+export const bar: number = 123
+
+export function dummyFunction(): void {
+  console.log("This is a dummy function")
+}
+
+export function randomHelper(): boolean {
+  return Math.random() > 0.5
+}

package/src/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/util/timeout.ts

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

package/src/util/token.ts

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

package/src/util/wildcard.ts

@@ -0,0 +1,59 @@
+import { sortBy, pipe } from "remeda"
+
+export namespace Wildcard {
+  export function match(str: string, pattern: string) {
+    if (str) str = str.replaceAll("\\", "/")
+    if (pattern) pattern = pattern.replaceAll("\\", "/")
+    let escaped = pattern
+      .replace(/[.+^${}()|[\]\\]/g, "\\$&") // escape special regex chars
+      .replace(/\*/g, ".*") // * becomes .*
+      .replace(/\?/g, ".") // ? becomes .
+
+    // If pattern ends with " *" (space + wildcard), make the trailing part optional
+    // This allows "ls *" to match both "ls" and "ls -la"
+    if (escaped.endsWith(" .*")) {
+      escaped = escaped.slice(0, -3) + "( .*)?"
+    }
+
+    const flags = process.platform === "win32" ? "si" : "s"
+    return new RegExp("^" + escaped + "$", flags).test(str)
+  }
+
+  export function all(input: string, patterns: Record<string, any>) {
+    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
+    let result = undefined
+    for (const [pattern, value] of sorted) {
+      if (match(input, pattern)) {
+        result = value
+        continue
+      }
+    }
+    return result
+  }
+
+  export function allStructured(input: { head: string; tail: string[] }, patterns: Record<string, any>) {
+    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
+    let result = undefined
+    for (const [pattern, value] of sorted) {
+      const parts = pattern.split(/\s+/)
+      if (!match(input.head, parts[0])) continue
+      if (parts.length === 1 || matchSequence(input.tail, parts.slice(1))) {
+        result = value
+        continue
+      }
+    }
+    return result
+  }
+
+  function matchSequence(items: string[], patterns: string[]): boolean {
+    if (patterns.length === 0) return true
+    const [pattern, ...rest] = patterns
+    if (pattern === "*") return matchSequence(items, rest)
+    for (let i = 0; i < items.length; i++) {
+      if (match(items[i], pattern) && matchSequence(items.slice(i + 1), rest)) {
+        return true
+      }
+    }
+    return false
+  }
+}