@sleepy-ai/cli 0.1.16 → 0.1.17

package/src/util/log.ts

@@ -1,234 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

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

@@ -1,48 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

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

package/src/util/rpc.ts

@@ -1,64 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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