onlycode 1.18.0 → 1.20.0

package/src/server/shared/tui-control.ts

@@ -1,28 +0,0 @@
-import { AsyncQueue } from "@/util/queue"
-import { Schema } from "effect"
-
-export const TuiRequest = Schema.Struct({
-  path: Schema.String,
-  body: Schema.Unknown,
-})
-
-export type TuiRequest = Schema.Schema.Type<typeof TuiRequest>
-
-const request = new AsyncQueue<TuiRequest>()
-const response = new AsyncQueue<unknown>()
-
-export function nextTuiRequest() {
-  return request.next()
-}
-
-export function submitTuiRequest(body: TuiRequest) {
-  request.push(body)
-}
-
-export function submitTuiResponse(body: unknown) {
-  response.push(body)
-}
-
-export function nextTuiResponse() {
-  return response.next()
-}

package/src/server/shared/ui.ts

@@ -1,108 +0,0 @@
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import { Effect, Stream } from "effect"
-import { HttpBody, HttpClient, HttpClientRequest, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
-import { createHash } from "node:crypto"
-import { ProxyUtil } from "../proxy-util"
-
-let embeddedUIPromise: Promise<Record<string, string> | null> | undefined
-
-export const UI_UPSTREAM = new URL("https://app.ai.huamp.com")
-
-export const csp = (hash = "") =>
-  `default-src 'self'; script-src 'self' 'wasm-unsafe-eval'${hash ? ` 'sha256-${hash}'` : ""}; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src * data:`
-export const DEFAULT_CSP = csp()
-
-export function themePreloadHash(body: string) {
-  return body.match(/<script\b(?![^>]*\bsrc\s*=)[^>]*\bid=(['"])oc-theme-preload-script\1[^>]*>([\s\S]*?)<\/script>/i)
-}
-
-export function cspForHtml(body: string) {
-  const match = themePreloadHash(body)
-  return csp(match ? createHash("sha256").update(match[2]).digest("base64") : "")
-}
-
-function requestBody(request: HttpServerRequest.HttpServerRequest) {
-  if (request.method === "GET" || request.method === "HEAD") return HttpBody.empty
-  const len = request.headers["content-length"]
-  return HttpBody.stream(request.stream, request.headers["content-type"], len === undefined ? undefined : Number(len))
-}
-
-function proxyResponseHeaders(headers: Record<string, string>) {
-  const result = new Headers(headers)
-  // FetchHttpClient exposes decoded response bodies, so forwarding upstream
-  // transfer metadata makes browsers decode already-decoded assets again.
-  result.delete("content-encoding")
-  result.delete("content-length")
-  result.delete("transfer-encoding")
-  return result
-}
-
-export function upstreamURL(path: string) {
-  return new URL(path, UI_UPSTREAM).toString()
-}
-
-export function embeddedUI(disableEmbeddedWebUi: boolean) {
-  if (disableEmbeddedWebUi) return Promise.resolve(null)
-  return (embeddedUIPromise ??=
-    // @ts-expect-error - generated file at build time
-    import("opencode-web-ui.gen.ts").then((module) => module.default as Record<string, string>).catch(() => null))
-}
-
-function notFound() {
-  return HttpServerResponse.jsonUnsafe({ error: "Not Found" }, { status: 404 })
-}
-
-function embeddedUIResponse(file: string, body: Uint8Array) {
-  const mime = FSUtil.mimeType(file)
-  const headers = new Headers({ "content-type": mime })
-  if (mime.startsWith("text/html")) {
-    headers.set("content-security-policy", cspForHtml(new TextDecoder().decode(body)))
-  }
-  return HttpServerResponse.raw(body, { headers })
-}
-
-export function serveEmbeddedUIEffect(
-  requestPath: string,
-  fs: FSUtil.Interface,
-  embeddedWebUI: Record<string, string>,
-) {
-  const file = embeddedWebUI[requestPath.replace(/^\//, "")] ?? embeddedWebUI["index.html"] ?? null
-  if (!file) return Effect.succeed(notFound())
-
-  return fs.readFile(file).pipe(
-    Effect.map((body) => embeddedUIResponse(file, body)),
-    Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(notFound())),
-  )
-}
-
-export function serveUIEffect(
-  request: HttpServerRequest.HttpServerRequest,
-  services: { fs: FSUtil.Interface; client: HttpClient.HttpClient; disableEmbeddedWebUi: boolean },
-) {
-  return Effect.gen(function* () {
-    const embeddedWebUI = yield* Effect.promise(() => embeddedUI(services.disableEmbeddedWebUi))
-    const path = new URL(request.url, "http://localhost").pathname
-
-    if (embeddedWebUI) return yield* serveEmbeddedUIEffect(path, services.fs, embeddedWebUI)
-
-    const response = yield* services.client.execute(
-      HttpClientRequest.make(request.method)(upstreamURL(path), {
-        headers: ProxyUtil.headers(request.headers, { host: UI_UPSTREAM.host }),
-        body: requestBody(request),
-      }),
-    )
-    const headers = proxyResponseHeaders(response.headers)
-
-    if (response.headers["content-type"]?.includes("text/html")) {
-      const body = yield* response.text
-      headers.set("Content-Security-Policy", cspForHtml(body))
-      return HttpServerResponse.text(body, { status: response.status, headers })
-    }
-
-    headers.set("Content-Security-Policy", csp())
-    return HttpServerResponse.stream(response.stream.pipe(Stream.catchCause(() => Stream.empty)), {
-      status: response.status,
-      headers,
-    })
-  })
-}

package/src/server/shared/workspace-routing.ts

@@ -1,38 +0,0 @@
-import { SessionID } from "@/session/schema"
-
-type Rule = { method?: string; path: string; exact?: boolean; action: "local" | "forward" }
-
-const RULES: Array<Rule> = [
-  { path: "/experimental/workspace", action: "local" },
-  { path: "/session/status", action: "forward" },
-  { method: "GET", path: "/session", action: "local" },
-]
-
-export function isLocalWorkspaceRoute(method: string, path: string) {
-  for (const rule of RULES) {
-    if (rule.method && rule.method !== method) continue
-    const match = rule.exact ? path === rule.path : path === rule.path || path.startsWith(rule.path + "/")
-    if (match) return rule.action === "local"
-  }
-  return false
-}
-
-export function getWorkspaceRouteSessionID(url: URL) {
-  if (url.pathname === "/session/status") return null
-
-  const id =
-    url.pathname.match(/^\/session\/([^/]+)(?:\/|$)/)?.[1] ??
-    url.pathname.match(/^\/experimental\/session\/([^/]+)\/background$/)?.[1]
-  if (!id) return null
-
-  return SessionID.make(id)
-}
-
-export function workspaceProxyURL(target: string | URL, requestURL: URL) {
-  const proxyURL = new URL(target)
-  proxyURL.pathname = `${proxyURL.pathname.replace(/\/$/, "")}${requestURL.pathname}`
-  proxyURL.search = requestURL.search
-  proxyURL.hash = requestURL.hash
-  proxyURL.searchParams.delete("workspace")
-  return proxyURL
-}

package/src/server/tui-event.ts

@@ -1,53 +0,0 @@
-import { SessionID } from "@/session/schema"
-import { PositiveInt } from "@opencode-ai/core/schema"
-import { EventV2 } from "@opencode-ai/core/event"
-import { Effect, Schema } from "effect"
-
-const DEFAULT_TOAST_DURATION = 5000
-
-export const TuiEvent = {
-  PromptAppend: EventV2.define({ type: "tui.prompt.append", schema: { text: Schema.String } }),
-  CommandExecute: EventV2.define({
-    type: "tui.command.execute",
-    schema: {
-      command: Schema.Union([
-        Schema.Literals([
-          "session.list",
-          "session.new",
-          "session.share",
-          "session.interrupt",
-          "session.compact",
-          "session.page.up",
-          "session.page.down",
-          "session.line.up",
-          "session.line.down",
-          "session.half.page.up",
-          "session.half.page.down",
-          "session.first",
-          "session.last",
-          "prompt.clear",
-          "prompt.submit",
-          "agent.cycle",
-        ]),
-        Schema.String,
-      ]),
-    },
-  }),
-  ToastShow: EventV2.define({
-    type: "tui.toast.show",
-    schema: {
-      title: Schema.optional(Schema.String),
-      message: Schema.String,
-      variant: Schema.Literals(["info", "success", "warning", "error"]),
-      duration: PositiveInt.pipe(Schema.withDecodingDefault(Effect.succeed(DEFAULT_TOAST_DURATION))).annotate({
-        description: "Duration in milliseconds",
-      }),
-    },
-  }),
-  SessionSelect: EventV2.define({
-    type: "tui.session.select",
-    schema: {
-      sessionID: SessionID.annotate({ description: "Session ID to navigate to" }),
-    },
-  }),
-}