@farhanic017/octocode 3.5.0

package/src/server/shared/ui.ts

@@ -0,0 +1,108 @@
+import { FSUtil } from "@octocode-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.octocode.ai")
+
+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("octocode-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

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

@@ -0,0 +1,53 @@
+import { SessionID } from "@/session/schema"
+import { PositiveInt } from "@octocode-ai/core/schema"
+import { EventV2 } from "@octocode-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" }),
+    },
+  }),
+}

package/src/share/share-next.ts

@@ -0,0 +1,379 @@
+import type * as SDK from "@octocode-ai/sdk/v2"
+import { serviceUse } from "@octocode-ai/core/effect/service-use"
+import { Effect, Exit, Layer, Option, Schema, Scope, Context, Stream } from "effect"
+import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { Account } from "@/account/account"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { InstanceState } from "@/effect/instance-state"
+import { Provider } from "@/provider/provider"
+
+import { Session } from "@/session/session"
+import { MessageV2 } from "@/session/message-v2"
+import type { SessionID } from "@/session/schema"
+import { Database } from "@octocode-ai/core/database/database"
+import { eq } from "drizzle-orm"
+import { Config } from "@/config/config"
+import * as Log from "@octocode-ai/core/util/log"
+import { SessionShareTable } from "@octocode-ai/core/share/sql"
+import { ProviderV2 } from "@octocode-ai/core/provider"
+import { ModelV2 } from "@octocode-ai/core/model"
+import { EventV2 } from "@octocode-ai/core/event"
+
+const log = Log.create({ service: "share-next" })
+const disabled = process.env["OCTOCODE_DISABLE_SHARE"] === "true" || process.env["OCTOCODE_DISABLE_SHARE"] === "1"
+
+export type Api = {
+  create: string
+  sync: (shareID: string) => string
+  remove: (shareID: string) => string
+  data: (shareID: string) => string
+}
+
+export type Req = {
+  headers: Record<string, string>
+  api: Api
+  baseUrl: string
+}
+
+const ShareSchema = Schema.Struct({
+  id: Schema.String,
+  url: Schema.String,
+  secret: Schema.String,
+})
+export type Share = typeof ShareSchema.Type
+
+type State = {
+  queue: Map<SessionID, Map<string, Data>>
+  scope: Scope.Closeable
+  shared: Map<SessionID, Share | null>
+}
+
+type Data =
+  | {
+      type: "session"
+      data: SDK.Session
+    }
+  | {
+      type: "message"
+      data: SDK.Message
+    }
+  | {
+      type: "part"
+      data: SDK.Part
+    }
+  | {
+      type: "session_diff"
+      data: SDK.SnapshotFileDiff[]
+    }
+  | {
+      type: "model"
+      data: SDK.Model[]
+    }
+
+export interface Interface {
+  readonly init: () => Effect.Effect<void, unknown>
+  readonly url: () => Effect.Effect<string, unknown>
+  readonly request: () => Effect.Effect<Req, unknown>
+  readonly create: (sessionID: SessionID) => Effect.Effect<Share, unknown>
+  readonly remove: (sessionID: SessionID) => Effect.Effect<void, unknown>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@octocode/ShareNext") {}
+
+export const use = serviceUse(Service)
+
+function api(resource: string): Api {
+  return {
+    create: `/api/${resource}`,
+    sync: (shareID) => `/api/${resource}/${shareID}/sync`,
+    remove: (shareID) => `/api/${resource}/${shareID}`,
+    data: (shareID) => `/api/${resource}/${shareID}/data`,
+  }
+}
+
+const legacyApi = api("share")
+const consoleApi = api("shares")
+
+function key(item: Data) {
+  switch (item.type) {
+    case "session":
+      return "session"
+    case "message":
+      return `message/${item.data.id}`
+    case "part":
+      return `part/${item.data.messageID}/${item.data.id}`
+    case "session_diff":
+      return "session_diff"
+    case "model":
+      return "model"
+  }
+}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const account = yield* Account.Service
+    const events = yield* EventV2Bridge.Service
+    const cfg = yield* Config.Service
+    const { db } = yield* Database.Service
+    const http = yield* HttpClient.HttpClient
+    const httpOk = HttpClient.filterStatusOk(http)
+    const provider = yield* Provider.Service
+    const session = yield* Session.Service
+
+    function sync(sessionID: SessionID, data: Data[]) {
+      return Effect.gen(function* () {
+        if (disabled) return
+        const share = yield* getCached(sessionID)
+        if (!share) return
+
+        const s = yield* InstanceState.get(state)
+        const existing = s.queue.get(sessionID)
+        if (existing) {
+          for (const item of data) {
+            existing.set(key(item), item)
+          }
+          return
+        }
+
+        const next = new Map(data.map((item) => [key(item), item]))
+        s.queue.set(sessionID, next)
+        yield* flush(sessionID).pipe(
+          Effect.delay(1000),
+          Effect.catchCause((cause) =>
+            Effect.sync(() => {
+              log.error("share flush failed", { sessionID, cause })
+            }),
+          ),
+          Effect.forkIn(s.scope),
+        )
+      })
+    }
+
+    const state: InstanceState.InstanceState<State> = yield* InstanceState.make<State>(
+      Effect.fn("ShareNext.state")(function* (_ctx) {
+        const cache: State = { queue: new Map(), scope: yield* Scope.make(), shared: new Map() }
+
+        yield* Effect.addFinalizer(() =>
+          Scope.close(cache.scope, Exit.void).pipe(
+            Effect.andThen(
+              Effect.sync(() => {
+                cache.queue.clear()
+                cache.shared.clear()
+              }),
+            ),
+          ),
+        )
+
+        if (disabled) return cache
+
+        const watch = <D extends EventV2.Definition>(
+          def: D,
+          fn: (data: EventV2.Data<D>) => Effect.Effect<void, unknown>,
+        ) =>
+          events.listen((event) => {
+            if (event.type !== def.type || event.location?.directory !== _ctx.directory) return Effect.void
+            return fn(event.data as EventV2.Data<D>).pipe(
+              Effect.catchCause((cause) =>
+                Effect.sync(() => log.error("share subscriber failed", { type: def.type, cause })),
+              ),
+            )
+          })
+
+        yield* watch(Session.Event.Updated, (data) =>
+          Effect.gen(function* () {
+            const info = data.info
+            yield* sync(info.id, [{ type: "session", data: structuredClone(info) as SDK.Session }])
+          }),
+        )
+        yield* watch(MessageV2.Event.Updated, (data) =>
+          Effect.gen(function* () {
+            const info = data.info
+            yield* sync(info.sessionID, [{ type: "message", data: structuredClone(info) as SDK.Message }])
+            if (info.role !== "user") return
+            const model = yield* provider.getModel(info.model.providerID, info.model.modelID)
+            yield* sync(info.sessionID, [{ type: "model", data: [model] }])
+          }),
+        )
+        yield* watch(MessageV2.Event.PartUpdated, (data) =>
+          sync(data.part.sessionID, [{ type: "part", data: structuredClone(data.part) as SDK.Part }]),
+        )
+        yield* watch(Session.Event.Diff, (data) =>
+          sync(data.sessionID, [{ type: "session_diff", data: structuredClone(data.diff) as SDK.SnapshotFileDiff[] }]),
+        )
+        yield* watch(Session.Event.Deleted, (data) => remove(data.sessionID))
+
+        return cache
+      }),
+    )
+
+    const request = Effect.fn("ShareNext.request")(function* () {
+      const headers: Record<string, string> = {}
+      const active = yield* account.active()
+      if (Option.isNone(active) || !active.value.active_org_id) {
+        const baseUrl = (yield* cfg.get()).enterprise?.url ?? "https://opncd.ai"
+        return { headers, api: legacyApi, baseUrl } satisfies Req
+      }
+
+      const token = yield* account.token(active.value.id)
+      if (Option.isNone(token)) {
+        throw new Error("No active account token available for sharing")
+      }
+
+      headers.authorization = `Bearer ${token.value}`
+      headers["x-org-id"] = active.value.active_org_id
+      return { headers, api: consoleApi, baseUrl: active.value.url } satisfies Req
+    })
+
+    const get = Effect.fnUntraced(function* (sessionID: SessionID) {
+      const row = yield* db
+        .select()
+        .from(SessionShareTable)
+        .where(eq(SessionShareTable.session_id, sessionID))
+        .get()
+        .pipe(Effect.orDie)
+      if (!row) return
+      return { id: row.id, secret: row.secret, url: row.url } satisfies Share
+    })
+
+    const getCached = Effect.fnUntraced(function* (sessionID: SessionID) {
+      const s = yield* InstanceState.get(state)
+      if (s.shared.has(sessionID)) {
+        const cached = s.shared.get(sessionID)
+        return cached === null ? undefined : cached
+      }
+
+      const share = yield* get(sessionID)
+      s.shared.set(sessionID, share ?? null)
+      return share
+    })
+
+    const flush = Effect.fn("ShareNext.flush")(function* (sessionID: SessionID) {
+      if (disabled) return
+      const s = yield* InstanceState.get(state)
+      const queued = s.queue.get(sessionID)
+      if (!queued) return
+
+      s.queue.delete(sessionID)
+
+      const share = yield* getCached(sessionID)
+      if (!share) return
+
+      const req = yield* request()
+      const res = yield* HttpClientRequest.post(`${req.baseUrl}${req.api.sync(share.id)}`).pipe(
+        HttpClientRequest.setHeaders(req.headers),
+        HttpClientRequest.bodyJson({ secret: share.secret, data: Array.from(queued.values()) }),
+        Effect.flatMap((r) => http.execute(r)),
+      )
+
+      if (res.status >= 400) {
+        log.warn("failed to sync share", { sessionID, shareID: share.id, status: res.status })
+      }
+    })
+
+    const full = Effect.fn("ShareNext.full")(function* (sessionID: SessionID) {
+      log.info("full sync", { sessionID })
+      const info = yield* session.get(sessionID)
+      const diffs = yield* session.diff(sessionID)
+      const messages = yield* session.messages({ sessionID })
+      const models = yield* Effect.forEach(
+        Array.from(
+          new Map(
+            messages
+              .filter((msg) => msg.info.role === "user")
+              .map((msg) => (msg.info as SDK.UserMessage).model)
+              .map((item) => [`${item.providerID}/${item.modelID}`, item] as const),
+          ).values(),
+        ),
+        (item) => provider.getModel(ProviderV2.ID.make(item.providerID), ModelV2.ID.make(item.modelID)),
+        { concurrency: 8 },
+      )
+
+      yield* sync(sessionID, [
+        { type: "session", data: info },
+        ...messages.map((item) => ({ type: "message" as const, data: item.info })),
+        ...messages.flatMap((item) => item.parts.map((part) => ({ type: "part" as const, data: part }))),
+        { type: "session_diff", data: diffs },
+        { type: "model", data: models },
+      ])
+    })
+
+    const init = Effect.fn("ShareNext.init")(function* () {
+      if (disabled) return
+      yield* InstanceState.get(state)
+    })
+
+    const url = Effect.fn("ShareNext.url")(function* () {
+      return (yield* request()).baseUrl
+    })
+
+    const create = Effect.fn("ShareNext.create")(function* (sessionID: SessionID) {
+      if (disabled) return { id: "", url: "", secret: "" }
+      log.info("creating share", { sessionID })
+      const req = yield* request()
+      const result = yield* HttpClientRequest.post(`${req.baseUrl}${req.api.create}`).pipe(
+        HttpClientRequest.setHeaders(req.headers),
+        HttpClientRequest.bodyJson({ sessionID }),
+        Effect.flatMap((r) => httpOk.execute(r)),
+        Effect.flatMap(HttpClientResponse.schemaBodyJson(ShareSchema)),
+      )
+      yield* db
+        .insert(SessionShareTable)
+        .values({ session_id: sessionID, id: result.id, secret: result.secret, url: result.url })
+        .onConflictDoUpdate({
+          target: SessionShareTable.session_id,
+          set: { id: result.id, secret: result.secret, url: result.url },
+        })
+        .run()
+        .pipe(Effect.orDie)
+      const s = yield* InstanceState.get(state)
+      s.shared.set(sessionID, result)
+      yield* full(sessionID).pipe(
+        Effect.catchCause((cause) =>
+          Effect.sync(() => {
+            log.error("share full sync failed", { sessionID, cause })
+          }),
+        ),
+        Effect.forkIn(s.scope),
+      )
+      return result
+    })
+
+    const remove = Effect.fn("ShareNext.remove")(function* (sessionID: SessionID) {
+      if (disabled) return
+      log.info("removing share", { sessionID })
+      const s = yield* InstanceState.get(state)
+      const share = yield* getCached(sessionID)
+      if (!share) {
+        s.shared.delete(sessionID)
+        s.queue.delete(sessionID)
+        return
+      }
+
+      const req = yield* request()
+      yield* HttpClientRequest.delete(`${req.baseUrl}${req.api.remove(share.id)}`).pipe(
+        HttpClientRequest.setHeaders(req.headers),
+        HttpClientRequest.bodyJson({ secret: share.secret }),
+        Effect.flatMap((r) => httpOk.execute(r)),
+      )
+
+      yield* db.delete(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).run().pipe(Effect.orDie)
+      s.shared.delete(sessionID)
+      s.queue.delete(sessionID)
+    })
+
+    return Service.of({ init, url, request, create, remove })
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(EventV2Bridge.defaultLayer),
+  Layer.provide(Account.defaultLayer),
+  Layer.provide(Config.defaultLayer),
+  Layer.provide(Database.defaultLayer),
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(Provider.defaultLayer),
+  Layer.provide(Session.defaultLayer),
+)
+
+export * as ShareNext from "./share-next"