@sleepy-ai/cli 0.1.5 → 0.1.7

package/src/server/middleware.ts

@@ -1,94 +0,0 @@
-import { Provider } from "../provider"
-import { NamedError } from "@sleepy-ai/shared/util/error"
-import { NotFoundError } from "../storage"
-import { Session } from "../session"
-import type { ContentfulStatusCode } from "hono/utils/http-status"
-import type { ErrorHandler, MiddlewareHandler } from "hono"
-import { HTTPException } from "hono/http-exception"
-import { Log } from "../util"
-import { Flag } from "@/flag/flag"
-import { basicAuth } from "hono/basic-auth"
-import { cors } from "hono/cors"
-import { compress } from "hono/compress"
-import { isPtyConnectPath, PTY_CONNECT_TICKET_QUERY } from "./pty-ticket"
-
-const log = Log.create({ service: "server" })
-
-export const ErrorMiddleware: ErrorHandler = (err, c) => {
-  log.error("failed", {
-    error: err,
-  })
-  if (err instanceof NamedError) {
-    let status: ContentfulStatusCode
-    if (err instanceof NotFoundError) status = 404
-    else if (err instanceof Provider.ModelNotFoundError) status = 400
-    else if (err.name === "ProviderAuthValidationFailed") status = 400
-    else if (err.name.startsWith("Worktree")) status = 400
-    else status = 500
-    return c.json(err.toObject(), { status })
-  }
-  if (err instanceof Session.BusyError) {
-    return c.json(new NamedError.Unknown({ message: err.message }).toObject(), { status: 409 })
-  }
-  if (err instanceof HTTPException) return err.getResponse()
-  const message = err instanceof Error ? err.message : "Internal Server Error"
-  return c.json(new NamedError.Unknown({ message }).toObject(), {
-    status: 500,
-  })
-}
-
-export const AuthMiddleware: MiddlewareHandler = (c, next) => {
-  if (c.req.method === "OPTIONS") return next()
-  const password = Flag.SLEEPYCODE_SERVER_PASSWORD
-  if (!password) return next()
-
-  // PTY websocket connect with a ticket skips basic auth; the handler validates the ticket.
-  const path = new URL(c.req.url).pathname
-  if (isPtyConnectPath(path) && c.req.query(PTY_CONNECT_TICKET_QUERY)) return next()
-
-  const username = Flag.SLEEPYCODE_SERVER_USERNAME ?? "sleepycode"
-
-  return basicAuth({ username, password })(c, next)
-}
-
-export const LoggerMiddleware: MiddlewareHandler = async (c, next) => {
-  const skip = c.req.path === "/log"
-  if (!skip) {
-    log.info("request", {
-      method: c.req.method,
-      path: c.req.path,
-    })
-  }
-  const timer = log.time("request", {
-    method: c.req.method,
-    path: c.req.path,
-  })
-  await next()
-  if (!skip) timer.stop()
-}
-
-export function CorsMiddleware(opts?: { cors?: string[] }): MiddlewareHandler {
-  return cors({
-    maxAge: 86_400,
-    origin(input) {
-      if (!input) return
-
-      if (input.startsWith("http://localhost:")) return input
-      if (input.startsWith("http://127.0.0.1:")) return input
-      if (input === "tauri://localhost" || input === "http://tauri.localhost" || input === "https://tauri.localhost")
-        return input
-
-      if (/^https:\/\/([a-z0-9-]+\.)*opencode\.ai$/.test(input)) return input
-      if (opts?.cors?.includes(input)) return input
-    },
-  })
-}
-
-const zipped = compress()
-export const CompressionMiddleware: MiddlewareHandler = (c, next) => {
-  const path = c.req.path
-  const method = c.req.method
-  if (path === "/event" || path === "/global/event") return next()
-  if (method === "POST" && /\/session\/[^/]+\/(message|prompt_async)$/.test(path)) return next()
-  return zipped(c, next)
-}

package/src/server/projectors.ts

@@ -1,28 +0,0 @@
-import z from "zod"
-import sessionProjectors from "../session/projectors"
-import { SyncEvent } from "@/sync"
-import { Session } from "@/session"
-import { SessionTable } from "@/session/session.sql"
-import { Database, eq } from "@/storage"
-
-export function initProjectors() {
-  SyncEvent.init({
-    projectors: sessionProjectors,
-    convertEvent: (type, data) => {
-      if (type === "session.updated") {
-        const id = (data as z.infer<typeof Session.Event.Updated.schema>).sessionID
-        const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
-
-        if (!row) return data
-
-        return {
-          sessionID: id,
-          info: Session.fromRow(row),
-        }
-      }
-      return data
-    },
-  })
-}
-
-initProjectors()

package/src/server/proxy.ts

@@ -1,171 +0,0 @@
-import { Hono } from "hono"
-import type { UpgradeWebSocket } from "hono/ws"
-import { Log } from "@/util"
-import * as Fence from "./fence"
-import type { WorkspaceID } from "@/control-plane/schema"
-import { Workspace } from "@/control-plane/workspace"
-
-const hop = new Set([
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "proxy-connection",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade",
-  "host",
-])
-
-type Msg = string | ArrayBuffer | Uint8Array
-
-function headers(req: Request, extra?: HeadersInit) {
-  const out = new Headers(req.headers)
-  for (const key of hop) out.delete(key)
-  out.delete("accept-encoding")
-  out.delete("x-sleepycode-directory")
-  out.delete("x-sleepycode-workspace")
-  if (!extra) return out
-  for (const [key, value] of new Headers(extra).entries()) {
-    out.set(key, value)
-  }
-  return out
-}
-
-function protocols(req: Request) {
-  const value = req.headers.get("sec-websocket-protocol")
-  if (!value) return []
-  return value
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean)
-}
-
-function socket(url: string | URL) {
-  const next = new URL(url)
-  if (next.protocol === "http:") next.protocol = "ws:"
-  if (next.protocol === "https:") next.protocol = "wss:"
-  return next.toString()
-}
-
-function send(ws: { send(data: string | ArrayBuffer | Uint8Array): void }, data: any) {
-  if (data instanceof Blob) {
-    return data.arrayBuffer().then((x) => ws.send(x))
-  }
-  return ws.send(data)
-}
-
-const app = (upgrade: UpgradeWebSocket) =>
-  new Hono().get(
-    "/__workspace_ws",
-    upgrade((c) => {
-      const url = c.req.header("x-sleepycode-proxy-url")
-      const queue: Msg[] = []
-      let remote: WebSocket | undefined
-      return {
-        onOpen(_, ws) {
-          if (!url) {
-            ws.close(1011, "missing proxy target")
-            return
-          }
-          remote = new WebSocket(url, protocols(c.req.raw))
-          remote.binaryType = "arraybuffer"
-          remote.onopen = () => {
-            for (const item of queue) remote?.send(item)
-            queue.length = 0
-          }
-          remote.onmessage = (event) => {
-            void send(ws, event.data)
-          }
-          remote.onerror = () => {
-            ws.close(1011, "proxy error")
-          }
-          remote.onclose = (event) => {
-            ws.close(event.code, event.reason)
-          }
-        },
-        onMessage(event) {
-          const data = event.data
-          if (typeof data !== "string" && !(data instanceof Uint8Array) && !(data instanceof ArrayBuffer)) return
-          if (remote?.readyState === WebSocket.OPEN) {
-            remote.send(data)
-            return
-          }
-          queue.push(data)
-        },
-        onClose(event) {
-          remote?.close(event.code, event.reason)
-        },
-      }
-    }),
-  )
-
-const log = Log.Default.clone().tag("service", "server-proxy")
-
-export async function http(url: string | URL, extra: HeadersInit | undefined, req: Request, workspaceID: WorkspaceID) {
-  if (!Workspace.isSyncing(workspaceID)) {
-    return new Response(`broken sync connection for workspace: ${workspaceID}`, {
-      status: 503,
-      headers: {
-        "content-type": "text/plain; charset=utf-8",
-      },
-    })
-  }
-
-  return fetch(
-    new Request(url, {
-      method: req.method,
-      headers: headers(req, extra),
-      body: req.method === "GET" || req.method === "HEAD" ? undefined : req.body,
-      redirect: "manual",
-      signal: req.signal,
-    }),
-  ).then((res) => {
-    const sync = Fence.parse(res.headers)
-    const next = new Headers(res.headers)
-    next.delete("content-encoding")
-    next.delete("content-length")
-
-    const done = sync ? Fence.wait(workspaceID, sync, req.signal) : Promise.resolve()
-
-    return done.then(async () => {
-      return new Response(res.body, {
-        status: res.status,
-        statusText: res.statusText,
-        headers: next,
-      })
-    })
-  })
-}
-
-export function websocket(
-  upgrade: UpgradeWebSocket,
-  target: string | URL,
-  extra: HeadersInit | undefined,
-  req: Request,
-  env: unknown,
-) {
-  const proxy = new URL(req.url)
-  proxy.pathname = "/__workspace_ws"
-  proxy.search = ""
-  const next = new Headers(req.headers)
-  next.set("x-sleepycode-proxy-url", socket(target))
-  for (const [key, value] of new Headers(extra).entries()) {
-    next.set(key, value)
-  }
-  log.info("proxy websocket", {
-    request: req.url,
-    target: String(target),
-  })
-  return app(upgrade).fetch(
-    new Request(proxy, {
-      method: req.method,
-      headers: next,
-      signal: req.signal,
-    }),
-    env as never,
-  )
-}
-
-export * as ServerProxy from "./proxy"

package/src/server/pty-ticket.ts

@@ -1,42 +0,0 @@
-import { randomUUID } from "crypto"
-
-export const PTY_CONNECT_TICKET_QUERY = "ticket"
-export const PTY_CONNECT_TOKEN_HEADER = "x-sleepycode-ticket"
-export const PTY_CONNECT_TOKEN_HEADER_VALUE = "1"
-
-const PTY_CONNECT_PATH = /^\/pty\/[^/]+\/connect$/
-
-const DEFAULT_TTL_MS = 60_000
-
-type TicketRecord = {
-  ptyID: string
-  expiresAt: number
-}
-
-const store = new Map<string, TicketRecord>()
-
-function gc() {
-  const now = Date.now()
-  for (const [key, record] of store) {
-    if (record.expiresAt <= now) store.delete(key)
-  }
-}
-
-export function isPtyConnectPath(pathname: string) {
-  return PTY_CONNECT_PATH.test(pathname)
-}
-
-export function issue(ptyID: string, ttl = DEFAULT_TTL_MS): { ticket: string; expires_in: number } {
-  gc()
-  const ticket = randomUUID()
-  store.set(ticket, { ptyID, expiresAt: Date.now() + ttl })
-  return { ticket, expires_in: Math.round(ttl / 1000) }
-}
-
-export function consume(ticket: string, ptyID: string): boolean {
-  const record = store.get(ticket)
-  if (!record) return false
-  store.delete(ticket)
-  if (record.expiresAt <= Date.now()) return false
-  return record.ptyID === ptyID
-}

package/src/server/rate-limit.ts

@@ -1,38 +0,0 @@
-import type { MiddlewareHandler } from "hono"
-
-const windows = new Map<string, { count: number; resetAt: number }>()
-
-let lastSweep = Date.now()
-const SWEEP_INTERVAL = 60_000
-
-function sweep() {
-  const now = Date.now()
-  if (now - lastSweep < SWEEP_INTERVAL) return
-  lastSweep = now
-  for (const [key, entry] of windows) {
-    if (now >= entry.resetAt) windows.delete(key)
-  }
-}
-
-export function RateLimitMiddleware(opts: {
-  windowMs: number
-  max: number
-  keyPrefix?: string
-}): MiddlewareHandler {
-  return async (c, next) => {
-    sweep()
-    const key = (opts.keyPrefix ?? c.req.path) + ":" + (c.req.header("x-forwarded-for") ?? "local")
-    const now = Date.now()
-    let entry = windows.get(key)
-    if (!entry || now >= entry.resetAt) {
-      entry = { count: 0, resetAt: now + opts.windowMs }
-      windows.set(key, entry)
-    }
-    entry.count++
-    if (entry.count > opts.max) {
-      c.header("Retry-After", String(Math.ceil((entry.resetAt - now) / 1000)))
-      return c.json({ error: "Too many requests" }, 429)
-    }
-    return next()
-  }
-}

package/src/server/routes/control/index.ts

@@ -1,160 +0,0 @@
-import { Auth } from "@/auth"
-import { AppRuntime } from "@/effect/app-runtime"
-import { Log } from "@/util"
-import { Effect } from "effect"
-import { ProviderID } from "@/provider/schema"
-import { Hono } from "hono"
-import { describeRoute, resolver, validator, openAPIRouteHandler } from "hono-openapi"
-import z from "zod"
-import { errors } from "../../error"
-
-export function ControlPlaneRoutes(): Hono {
-  const app = new Hono()
-  return app
-    .put(
-      "/auth/:providerID",
-      describeRoute({
-        summary: "Set auth credentials",
-        description: "Set authentication credentials",
-        operationId: "auth.set",
-        responses: {
-          200: {
-            description: "Successfully set authentication credentials",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "param",
-        z.object({
-          providerID: ProviderID.zod,
-        }),
-      ),
-      validator("json", Auth.Info.zod),
-      async (c) => {
-        const providerID = c.req.valid("param").providerID
-        const info = c.req.valid("json")
-        await AppRuntime.runPromise(
-          Effect.gen(function* () {
-            const auth = yield* Auth.Service
-            yield* auth.set(providerID, info)
-          }),
-        )
-        return c.json(true)
-      },
-    )
-    .delete(
-      "/auth/:providerID",
-      describeRoute({
-        summary: "Remove auth credentials",
-        description: "Remove authentication credentials",
-        operationId: "auth.remove",
-        responses: {
-          200: {
-            description: "Successfully removed authentication credentials",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "param",
-        z.object({
-          providerID: ProviderID.zod,
-        }),
-      ),
-      async (c) => {
-        const providerID = c.req.valid("param").providerID
-        await AppRuntime.runPromise(
-          Effect.gen(function* () {
-            const auth = yield* Auth.Service
-            yield* auth.remove(providerID)
-          }),
-        )
-        return c.json(true)
-      },
-    )
-    .get(
-      "/doc",
-      openAPIRouteHandler(app, {
-        documentation: {
-          info: {
-            title: "opencode",
-            version: "0.0.3",
-            description: "opencode api",
-          },
-          openapi: "3.1.1",
-        },
-      }),
-    )
-    .use(
-      validator(
-        "query",
-        z.object({
-          directory: z.string().optional(),
-          workspace: z.string().optional(),
-        }),
-      ),
-    )
-    .post(
-      "/log",
-      describeRoute({
-        summary: "Write log",
-        description: "Write a log entry to the server logs with specified level and metadata.",
-        operationId: "app.log",
-        responses: {
-          200: {
-            description: "Log entry written successfully",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "json",
-        z.object({
-          service: z.string().meta({ description: "Service name for the log entry" }),
-          level: z.enum(["debug", "info", "error", "warn"]).meta({ description: "Log level" }),
-          message: z.string().meta({ description: "Log message" }),
-          extra: z
-            .record(z.string(), z.any())
-            .optional()
-            .meta({ description: "Additional metadata for the log entry" }),
-        }),
-      ),
-      async (c) => {
-        const { service, level, message, extra } = c.req.valid("json")
-        const logger = Log.create({ service })
-
-        switch (level) {
-          case "debug":
-            logger.debug(message, extra)
-            break
-          case "info":
-            logger.info(message, extra)
-            break
-          case "error":
-            logger.error(message, extra)
-            break
-          case "warn":
-            logger.warn(message, extra)
-            break
-        }
-
-        return c.json(true)
-      },
-    )
-}