cerebras-cli 1.0.0

package/src/pty/index.ts

@@ -0,0 +1,226 @@
+import { type IPty } from "bun-pty"
+import z from "zod"
+import { Identifier } from "../id/id"
+import { Log } from "../util/log"
+import { Bus } from "../bus"
+import type { WSContext } from "hono/ws"
+import { Instance } from "../project/instance"
+import { shell } from "@opencode-ai/util/shell"
+import { lazy } from "@opencode-ai/util/lazy"
+import {} from "process"
+import { Installation } from "@/installation"
+
+export namespace Pty {
+  const log = Log.create({ service: "pty" })
+
+  const pty = lazy(async () => {
+    if (!Installation.isLocal()) {
+      const path = require(
+        `bun-pty/rust-pty/target/release/${
+          process.platform === "win32"
+            ? "rust_pty.dll"
+            : process.platform === "linux" && process.arch === "x64"
+              ? "librust_pty.so"
+              : process.platform === "darwin" && process.arch === "x64"
+                ? "librust_pty.dylib"
+                : process.platform === "darwin" && process.arch === "arm64"
+                  ? "librust_pty_arm64.dylib"
+                  : process.platform === "linux" && process.arch === "arm64"
+                    ? "librust_pty_arm64.so"
+                    : ""
+        }`,
+      )
+      process.env.BUN_PTY_LIB = path
+    }
+    const { spawn } = await import("bun-pty")
+    return spawn
+  })
+
+  export const Info = z
+    .object({
+      id: Identifier.schema("pty"),
+      title: z.string(),
+      command: z.string(),
+      args: z.array(z.string()),
+      cwd: z.string(),
+      status: z.enum(["running", "exited"]),
+      pid: z.number(),
+    })
+    .meta({ ref: "Pty" })
+
+  export type Info = z.infer<typeof Info>
+
+  export const CreateInput = z.object({
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    cwd: z.string().optional(),
+    title: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+  })
+
+  export type CreateInput = z.infer<typeof CreateInput>
+
+  export const UpdateInput = z.object({
+    title: z.string().optional(),
+    size: z
+      .object({
+        rows: z.number(),
+        cols: z.number(),
+      })
+      .optional(),
+  })
+
+  export type UpdateInput = z.infer<typeof UpdateInput>
+
+  export const Event = {
+    Created: Bus.event("pty.created", z.object({ info: Info })),
+    Updated: Bus.event("pty.updated", z.object({ info: Info })),
+    Exited: Bus.event("pty.exited", z.object({ id: Identifier.schema("pty"), exitCode: z.number() })),
+    Deleted: Bus.event("pty.deleted", z.object({ id: Identifier.schema("pty") })),
+  }
+
+  interface ActiveSession {
+    info: Info
+    process: IPty
+    buffer: string
+    subscribers: Set<WSContext>
+  }
+
+  const state = Instance.state(
+    () => new Map<string, ActiveSession>(),
+    async (sessions) => {
+      for (const session of sessions.values()) {
+        try {
+          session.process.kill()
+        } catch {}
+        for (const ws of session.subscribers) {
+          ws.close()
+        }
+      }
+      sessions.clear()
+    },
+  )
+
+  export function list() {
+    return Array.from(state().values()).map((s) => s.info)
+  }
+
+  export function get(id: string) {
+    return state().get(id)?.info
+  }
+
+  export async function create(input: CreateInput) {
+    const id = Identifier.create("pty", false)
+    const command = input.command || shell()
+    const args = input.args || []
+    const cwd = input.cwd || Instance.directory
+    const env = { ...process.env, ...input.env } as Record<string, string>
+    log.info("creating session", { id, cmd: command, args, cwd })
+
+    const spawn = await pty()
+    const ptyProcess = spawn(command, args, {
+      name: "xterm-256color",
+      cwd,
+      env,
+    })
+    const info = {
+      id,
+      title: input.title || `Terminal ${id.slice(-4)}`,
+      command,
+      args,
+      cwd,
+      status: "running",
+      pid: ptyProcess.pid,
+    } as const
+    const session: ActiveSession = {
+      info,
+      process: ptyProcess,
+      buffer: "",
+      subscribers: new Set(),
+    }
+    state().set(id, session)
+    ptyProcess.onData((data) => {
+      if (session.subscribers.size === 0) {
+        session.buffer += data
+        return
+      }
+      for (const ws of session.subscribers) {
+        if (ws.readyState === 1) {
+          ws.send(data)
+        }
+      }
+    })
+    ptyProcess.onExit(({ exitCode }) => {
+      log.info("session exited", { id, exitCode })
+      session.info.status = "exited"
+      Bus.publish(Event.Exited, { id, exitCode })
+      state().delete(id)
+    })
+    Bus.publish(Event.Created, { info })
+    return info
+  }
+
+  export async function update(id: string, input: UpdateInput) {
+    const session = state().get(id)
+    if (!session) return
+    if (input.title) {
+      session.info.title = input.title
+    }
+    if (input.size) {
+      session.process.resize(input.size.cols, input.size.rows)
+    }
+    Bus.publish(Event.Updated, { info: session.info })
+    return session.info
+  }
+
+  export async function remove(id: string) {
+    const session = state().get(id)
+    if (!session) return
+    log.info("removing session", { id })
+    try {
+      session.process.kill()
+    } catch {}
+    for (const ws of session.subscribers) {
+      ws.close()
+    }
+    state().delete(id)
+    Bus.publish(Event.Deleted, { id })
+  }
+
+  export function resize(id: string, cols: number, rows: number) {
+    const session = state().get(id)
+    if (session && session.info.status === "running") {
+      session.process.resize(cols, rows)
+    }
+  }
+
+  export function write(id: string, data: string) {
+    const session = state().get(id)
+    if (session && session.info.status === "running") {
+      session.process.write(data)
+    }
+  }
+
+  export function connect(id: string, ws: WSContext) {
+    const session = state().get(id)
+    if (!session) {
+      ws.close()
+      return
+    }
+    log.info("client connected to session", { id })
+    session.subscribers.add(ws)
+    if (session.buffer) {
+      ws.send(session.buffer)
+      session.buffer = ""
+    }
+    return {
+      onMessage: (message: string | ArrayBuffer) => {
+        session.process.write(String(message))
+      },
+      onClose: () => {
+        log.info("client disconnected from session", { id })
+        session.subscribers.delete(ws)
+      },
+    }
+  }
+}

package/src/ratelimit/index.ts

@@ -0,0 +1,185 @@
+import { Bus } from "@/bus"
+import z from "zod"
+
+export namespace RateLimit {
+  export const WindowInfo = z.object({
+    remaining: z.number(),
+    limit: z.number(),
+    reset: z.string().optional(),
+    window: z.string(), // "minute", "hour", "day", or "unknown"
+  })
+  export type WindowInfo = z.infer<typeof WindowInfo>
+
+  export const Info = z.object({
+    providerID: z.string(),
+    // Legacy fields for backwards compatibility
+    remainingRequests: z.number().optional(),
+    limitRequests: z.number().optional(),
+    remainingTokens: z.number().optional(),
+    limitTokens: z.number().optional(),
+    resetRequests: z.string().optional(),
+    resetTokens: z.string().optional(),
+    updatedAt: z.number().optional(),
+    // All rate limits by window
+    requestLimits: z.array(WindowInfo).optional(),
+    tokenLimits: z.array(WindowInfo).optional(),
+  })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Update: Bus.event(
+      "ratelimit.update",
+      z.object({
+        providerID: z.string(),
+        info: Info,
+      }),
+    ),
+  }
+
+  // Simple global state (not instance-scoped since rate limits are global)
+  const globalState = {
+    data: {} as Record<string, Info>,
+  }
+  const state = () => globalState
+
+  /**
+   * Parse rate limit info from response headers.
+   * Supports common header formats from various providers.
+   * Captures all time windows (minute, hour, day) and finds the most restrictive.
+   */
+  export function parseHeaders(
+    headers: Record<string, string | undefined> | Headers | undefined,
+    providerID: string,
+  ): Info | undefined {
+    if (!headers) return undefined
+
+    // Normalize headers to a simple object
+    const h: Record<string, string | undefined> = {}
+    if (headers instanceof Headers) {
+      headers.forEach((value, key) => {
+        h[key.toLowerCase()] = value
+      })
+    } else {
+      for (const [key, value] of Object.entries(headers)) {
+        h[key.toLowerCase()] = value
+      }
+    }
+
+    const info: Info = { providerID, requestLimits: [], tokenLimits: [] }
+
+    // Helper to parse a window's limits
+    const parseWindow = (
+      type: "requests" | "tokens",
+      window: string,
+      remainingKey: string,
+      limitKey: string,
+      resetKey: string,
+    ) => {
+      const remaining = h[remainingKey]
+      const limit = h[limitKey]
+      const reset = h[resetKey]
+
+      if (remaining !== undefined && limit !== undefined) {
+        const remainingNum = parseInt(remaining, 10)
+        const limitNum = parseInt(limit, 10)
+        // Skip if values aren't valid numbers
+        if (isNaN(remainingNum) || isNaN(limitNum)) return
+        
+        const windowInfo: WindowInfo = {
+          remaining: remainingNum,
+          limit: limitNum,
+          reset,
+          window,
+        }
+        if (type === "requests") {
+          info.requestLimits!.push(windowInfo)
+        } else {
+          info.tokenLimits!.push(windowInfo)
+        }
+      }
+    }
+
+    // Parse all time windows for requests
+    parseWindow("requests", "minute", "x-ratelimit-remaining-requests-minute", "x-ratelimit-limit-requests-minute", "x-ratelimit-reset-requests-minute")
+    parseWindow("requests", "hour", "x-ratelimit-remaining-requests-hour", "x-ratelimit-limit-requests-hour", "x-ratelimit-reset-requests-hour")
+    parseWindow("requests", "day", "x-ratelimit-remaining-requests-day", "x-ratelimit-limit-requests-day", "x-ratelimit-reset-requests-day")
+    parseWindow("requests", "unknown", "x-ratelimit-remaining-requests", "x-ratelimit-limit-requests", "x-ratelimit-reset-requests")
+    parseWindow("requests", "unknown", "ratelimit-remaining-requests", "ratelimit-limit-requests", "ratelimit-reset-requests")
+
+    // Parse all time windows for tokens
+    parseWindow("tokens", "minute", "x-ratelimit-remaining-tokens-minute", "x-ratelimit-limit-tokens-minute", "x-ratelimit-reset-tokens-minute")
+    parseWindow("tokens", "hour", "x-ratelimit-remaining-tokens-hour", "x-ratelimit-limit-tokens-hour", "x-ratelimit-reset-tokens-hour")
+    parseWindow("tokens", "day", "x-ratelimit-remaining-tokens-day", "x-ratelimit-limit-tokens-day", "x-ratelimit-reset-tokens-day")
+    parseWindow("tokens", "unknown", "x-ratelimit-remaining-tokens", "x-ratelimit-limit-tokens", "x-ratelimit-reset-tokens")
+    parseWindow("tokens", "unknown", "ratelimit-remaining-tokens", "ratelimit-limit-tokens", "ratelimit-reset-tokens")
+
+    // Find the most restrictive limits (lowest percentage remaining)
+    const findMostRestrictive = (limits: WindowInfo[]): WindowInfo | undefined => {
+      if (limits.length === 0) return undefined
+      return limits.reduce((most, current) => {
+        const mostPct = most.limit > 0 ? most.remaining / most.limit : 1
+        const currentPct = current.limit > 0 ? current.remaining / current.limit : 1
+        return currentPct < mostPct ? current : most
+      })
+    }
+
+    const mostRestrictiveRequests = findMostRestrictive(info.requestLimits!)
+    const mostRestrictiveTokens = findMostRestrictive(info.tokenLimits!)
+
+    // Set legacy fields from most restrictive limits
+    if (mostRestrictiveRequests) {
+      info.remainingRequests = mostRestrictiveRequests.remaining
+      info.limitRequests = mostRestrictiveRequests.limit
+      info.resetRequests = mostRestrictiveRequests.reset
+    }
+    if (mostRestrictiveTokens) {
+      info.remainingTokens = mostRestrictiveTokens.remaining
+      info.limitTokens = mostRestrictiveTokens.limit
+      info.resetTokens = mostRestrictiveTokens.reset
+    }
+
+    // Only return if we found any rate limit info
+    if (
+      info.remainingRequests !== undefined ||
+      info.remainingTokens !== undefined ||
+      info.limitRequests !== undefined ||
+      info.limitTokens !== undefined
+    ) {
+      return info
+    }
+
+    return undefined
+  }
+
+  export function get(providerID: string): Info | undefined {
+    return state().data[providerID]
+  }
+
+  /**
+   * Store the latest rate limit info from a fetch response.
+   * This is called from the provider's fetch wrapper.
+   */
+  export function setLatest(providerID: string, info: Info): void {
+    const s = state()
+
+    const infoWithTimestamp: Info = {
+      ...info,
+      updatedAt: Date.now(),
+    }
+
+    s.data[providerID] = infoWithTimestamp
+
+    // Publish update event so UI can show progress bar
+    Bus.publish(Event.Update, {
+      providerID,
+      info: infoWithTimestamp,
+    })
+  }
+
+  /**
+   * Get all rate limit info for all providers
+   */
+  export function getAll(): Record<string, Info> {
+    return { ...state().data }
+  }
+}

package/src/server/error.ts

@@ -0,0 +1,36 @@
+import { resolver } from "hono-openapi"
+import z from "zod"
+import { Storage } from "../storage/storage"
+
+export const ERRORS = {
+  400: {
+    description: "Bad request",
+    content: {
+      "application/json": {
+        schema: resolver(
+          z
+            .object({
+              data: z.any(),
+              errors: z.array(z.record(z.string(), z.any())),
+              success: z.literal(false),
+            })
+            .meta({
+              ref: "BadRequestError",
+            }),
+        ),
+      },
+    },
+  },
+  404: {
+    description: "Not found",
+    content: {
+      "application/json": {
+        schema: resolver(Storage.NotFoundError.Schema),
+      },
+    },
+  },
+} as const
+
+export function errors(...codes: number[]) {
+  return Object.fromEntries(codes.map((code) => [code, ERRORS[code as keyof typeof ERRORS]]))
+}

package/src/server/project.ts

@@ -0,0 +1,50 @@
+import { Hono } from "hono"
+import { describeRoute } from "hono-openapi"
+import { resolver } from "hono-openapi"
+import { Instance } from "../project/instance"
+import { Project } from "../project/project"
+
+export const ProjectRoute = new Hono()
+  .get(
+    "/",
+    describeRoute({
+      summary: "List all projects",
+      description: "Get a list of projects that have been opened with OpenCode.",
+      operationId: "project.list",
+      responses: {
+        200: {
+          description: "List of projects",
+          content: {
+            "application/json": {
+              schema: resolver(Project.Info.array()),
+            },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      const projects = await Project.list()
+      return c.json(projects)
+    },
+  )
+  .get(
+    "/current",
+    describeRoute({
+      summary: "Get current project",
+      description: "Retrieve the currently active project that OpenCode is working with.",
+      operationId: "project.current",
+      responses: {
+        200: {
+          description: "Current project information",
+          content: {
+            "application/json": {
+              schema: resolver(Project.Info),
+            },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      return c.json(Instance.project)
+    },
+  )