cerebras-cli 1.0.1 → 1.0.3

package/src/pty/index.ts

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

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

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

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