@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.4

package/src/util/log.ts

@@ -0,0 +1,234 @@
+import path from "path"
+import fs from "fs/promises"
+import { createWriteStream } from "fs"
+import { Global } from "../global"
+import { Flag } from "../flag/flag"
+import z from "zod"
+
+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,
+}
+const keep = 10
+// Cap a single log file so one long-running or runaway session can't write an
+// unbounded file, and cap the total of archived logs so the directory can't
+// fill the disk. The active file is excluded from the total and kept separate.
+const MAX_FILE_SIZE = 50 * 1024 * 1024
+const MAX_TOTAL_SIZE = 200 * 1024 * 1024
+
+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
+  // Defaults to enabled. When false, the active log file grows in place and is
+  // never archived to <name>.log.<stamp> on reaching MAX_FILE_SIZE.
+  rotate?: boolean
+}
+
+let logpath = ""
+export function file() {
+  return logpath
+}
+let stream: ReturnType<typeof createWriteStream> | undefined
+let written = 0
+let rotation = true
+let write = (msg: any) => {
+  process.stderr.write(msg)
+  return msg.length
+}
+
+function stamp() {
+  return new Date().toISOString().split(".")[0].replace(/:/g, "")
+}
+
+export async function init(options: Options) {
+  if (options.level) level = options.level
+  rotation = options.rotate ?? !Flag.SLEEPYCODE_DISABLE_LOG_ROTATION
+  void cleanup(Global.Path.log)
+  if (options.print) return
+  logpath = path.join(Global.Path.log, options.dev ? "dev.log" : stamp() + ".log")
+  if (options.dev) {
+    // Preserve previous dev.log as dev.log.<timestamp> for hang/incident
+    // forensics. cleanup() above already prunes old archived logs.
+    const stat = await fs.stat(logpath).catch(() => null)
+    if (stat && stat.size > 0) await fs.rename(logpath, `${logpath}.${stamp()}`).catch(() => {})
+  } else {
+    await fs.truncate(logpath).catch(() => {})
+  }
+  stream = createWriteStream(logpath, { flags: "a" })
+  written = 0
+  write = async (msg: any) => {
+    written += Buffer.byteLength(msg)
+    if (rotation && written >= MAX_FILE_SIZE) {
+      written = 0
+      await rotate()
+    }
+    return new Promise((resolve, reject) => {
+      stream!.write(msg, (err) => {
+        if (err) reject(err)
+        else resolve(msg.length)
+      })
+    })
+  }
+}
+
+// Archive the active file as <logpath>.<timestamp> and start a fresh one at the
+// same path, so file() stays stable. The renamed file is then subject to
+// cleanup's total-size budget.
+async function rotate() {
+  const previous = stream
+  await fs.rename(logpath, `${logpath}.${stamp()}`).catch(() => {})
+  stream = createWriteStream(logpath, { flags: "a" })
+  if (previous) previous.end()
+  void cleanup(Global.Path.log)
+}
+
+async function cleanup(dir: string) {
+  const entries = await fs.readdir(dir).catch(() => [] as string[])
+  const stats = await Promise.all(
+    entries
+      // Match session logs (<iso>.log), dev rotations (dev.log.<stamp>) and
+      // size rotations (<name>.log.<stamp>). Skip the active file so it is
+      // never deleted out from under the open write stream.
+      .filter((name) => name.includes(".log") && path.join(dir, name) !== logpath)
+      .map(async (name) => {
+        const stat = await fs.stat(path.join(dir, name)).catch(() => null)
+        return stat?.isFile() ? { name, size: stat.size } : null
+      }),
+  )
+  // Sort oldest first by name; filenames are timestamp-encoded so lexical order
+  // is chronological within each family.
+  const files = stats.flatMap((f) => (f ? [f] : [])).sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+
+  let total = files.reduce((sum, f) => sum + f.size, 0)
+  let remaining = files.length
+  const doomed = files.filter((f) => {
+    if (remaining <= keep && total <= MAX_TOTAL_SIZE) return false
+    total -= f.size
+    remaining -= 1
+    return true
+  })
+  await Promise.all(doomed.map((f) => fs.unlink(path.join(dir, f.name)).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 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/media.ts

@@ -0,0 +1,26 @@
+const startsWith = (bytes: Uint8Array, prefix: number[]) => prefix.every((value, index) => bytes[index] === value)
+
+export function isPdfAttachment(mime: string) {
+  return mime === "application/pdf"
+}
+
+export function isMedia(mime: string) {
+  return mime.startsWith("image/") || isPdfAttachment(mime)
+}
+
+export function isImageAttachment(mime: string) {
+  return mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet"
+}
+
+export function sniffAttachmentMime(bytes: Uint8Array, fallback: string) {
+  if (startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) return "image/png"
+  if (startsWith(bytes, [0xff, 0xd8, 0xff])) return "image/jpeg"
+  if (startsWith(bytes, [0x47, 0x49, 0x46, 0x38])) return "image/gif"
+  if (startsWith(bytes, [0x42, 0x4d])) return "image/bmp"
+  if (startsWith(bytes, [0x25, 0x50, 0x44, 0x46, 0x2d])) return "application/pdf"
+  if (startsWith(bytes, [0x52, 0x49, 0x46, 0x46]) && startsWith(bytes.subarray(8), [0x57, 0x45, 0x42, 0x50])) {
+    return "image/webp"
+  }
+
+  return fallback
+}

package/src/util/network.ts

@@ -0,0 +1,9 @@
+export function online() {
+  const nav = globalThis.navigator
+  if (!nav || typeof nav.onLine !== "boolean") return true
+  return nav.onLine
+}
+
+export function proxied() {
+  return !!(process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)
+}

package/src/util/process.ts

@@ -0,0 +1,174 @@
+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)
+}

package/src/util/provider-priority.ts

@@ -0,0 +1,48 @@
+const HEAD_POPULAR_PROVIDERS = ["sleepy", "openai", "anthropic"] as const
+
+const CHINA_POPULAR_BEFORE_ALIBABA = [
+  "deepseek",
+  "zai",
+  "zhipuai",
+  "moonshotai",
+  "moonshotai-cn",
+  "kimi-for-coding",
+  "stepfun",
+] as const
+
+const MID_POPULAR_PROVIDERS = ["opencode", "openrouter"] as const
+
+const CHINA_POPULAR_FROM_ALIBABA = [
+  "alibaba",
+  "alibaba-cn",
+  "bytedance",
+  "alibaba-coding-plan",
+  "alibaba-coding-plan-cn",
+  "zai-coding-plan",
+  "zhipuai-coding-plan",
+  "tencent-coding-plan",
+  "minimax-coding-plan",
+  "minimax-cn-coding-plan",
+  "kuae-cloud-coding-plan",
+] as const
+
+const TAIL_POPULAR_PROVIDERS = ["opencode-go", "github-copilot", "google", "vercel"] as const
+
+const POPULAR_PROVIDER_GROUPS = [
+  HEAD_POPULAR_PROVIDERS,
+  CHINA_POPULAR_BEFORE_ALIBABA,
+  MID_POPULAR_PROVIDERS,
+  CHINA_POPULAR_FROM_ALIBABA,
+  TAIL_POPULAR_PROVIDERS,
+] as const
+
+export const PROVIDER_PRIORITY: Record<string, number> = Object.fromEntries(
+  POPULAR_PROVIDER_GROUPS.flatMap((group, groupIndex, groups) => {
+    const offset = groups.slice(0, groupIndex).reduce((sum, g) => sum + g.length, 0)
+    return group.map((id, index) => [id, offset + index])
+  }),
+)
+
+export function isPopularProvider(id: string) {
+  return id in PROVIDER_PRIORITY
+}

package/src/util/queue.ts

@@ -0,0 +1,60 @@
+export class AsyncQueue<T> implements AsyncIterable<T> {
+  private queue: T[] = []
+  private resolvers: ((value: T) => void)[] = []
+  private readonly capacity: number
+  /** Count of items dropped because the buffer was full (drop-oldest). */
+  dropped = 0
+
+  /**
+   * @param options.capacity Max buffered items when nobody is awaiting. When
+   * the buffer is full, the OLDEST item is dropped to make room for the new
+   * one (`dropped` is incremented). Defaults to Infinity (unbounded).
+   *
+   * Bounding matters for fan-out streams (e.g. SSE event endpoints) where a
+   * slow/stalled consumer would otherwise let the buffer grow without limit
+   * and exhaust process memory, since `push` never blocks the producer.
+   */
+  constructor(options?: { capacity?: number }) {
+    this.capacity = options?.capacity ?? Infinity
+  }
+
+  push(item: T) {
+    const resolve = this.resolvers.shift()
+    if (resolve) {
+      resolve(item)
+      return
+    }
+    if (this.queue.length >= this.capacity) {
+      this.queue.shift()
+      this.dropped++
+    }
+    this.queue.push(item)
+  }
+
+  /** Number of items currently buffered (not yet consumed). */
+  get size() {
+    return this.queue.length
+  }
+
+  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/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/util/rpc.ts

@@ -0,0 +1,64 @@
+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/schema.ts

@@ -0,0 +1,53 @@
+import { Schema } from "effect"
+
+/**
+ * Attach static methods to a schema object. Designed to be used with `.pipe()`:
+ *
+ * @example
+ *   export const Foo = fooSchema.pipe(
+ *     withStatics((schema) => ({
+ *       zero: schema.make(0),
+ *       from: Schema.decodeUnknownOption(schema),
+ *     }))
+ *   )
+ */
+export const withStatics =
+  <S extends object, M extends Record<string, unknown>>(methods: (schema: S) => M) =>
+  (schema: S): S & M =>
+    Object.assign(schema, methods(schema))
+
+declare const NewtypeBrand: unique symbol
+type NewtypeBrand<Tag extends string> = { readonly [NewtypeBrand]: Tag }
+
+/**
+ * Nominal wrapper for scalar types. The class itself is a valid schema —
+ * pass it directly to `Schema.decode`, `Schema.decodeEffect`, etc.
+ *
+ * @example
+ *   class QuestionID extends Newtype<QuestionID>()("QuestionID", Schema.String) {
+ *     static make(id: string): QuestionID {
+ *       return this.make(id)
+ *     }
+ *   }
+ *
+ *   Schema.decodeEffect(QuestionID)(input)
+ */
+export function Newtype<Self>() {
+  return <const Tag extends string, S extends Schema.Top>(tag: Tag, schema: S) => {
+    type Branded = NewtypeBrand<Tag>
+
+    abstract class Base {
+      declare readonly [NewtypeBrand]: Tag
+
+      static make(value: Schema.Schema.Type<S>): Self {
+        return value as unknown as Self
+      }
+    }
+
+    Object.setPrototypeOf(Base, schema)
+
+    return Base as unknown as (abstract new (_: never) => Branded) & {
+      readonly make: (value: Schema.Schema.Type<S>) => Self
+    } & Omit<Schema.Opaque<Self, S, {}>, "make">
+  }
+}

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
+    },
+  }
+}