soraacode 0.2.0 → 0.2.2

package/src/share/share-next.ts

@@ -1,371 +0,0 @@
-import { LayerNode } from "@soraacode/core/effect/layer-node"
-import { httpClient } from "@soraacode/core/effect/app-node-platform"
-import type * as SDK from "@soraacode/sdk/v2"
-import { serviceUse } from "@soraacode/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 "@soraacode/core/database/database"
-import { eq } from "drizzle-orm"
-import { Config } from "@/config/config"
-import { SessionShareTable } from "@soraacode/core/share/sql"
-import { ProviderV2 } from "@soraacode/core/provider"
-import { ModelV2 } from "@soraacode/core/model"
-import { EventV2 } from "@soraacode/core/event"
-
-const disabled = process.env["OPENCODE_DISABLE_SHARE"] === "true" || process.env["OPENCODE_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>()("@opencode/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"
-  }
-}
-
-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.logError("share flush failed", { sessionID: sessionID, cause: 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.logError("share subscriber failed", { type: def.type, cause: 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) {
-        yield* Effect.logWarning("failed to sync share", {
-          sessionID: sessionID,
-          shareID: share.id,
-          status: res.status,
-        })
-      }
-    })
-
-    const full = Effect.fn("ShareNext.full")(function* (sessionID: SessionID) {
-      yield* Effect.logInfo("full sync", { sessionID: 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: "" }
-      yield* Effect.logInfo("creating share", { sessionID: 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.logError("share full sync failed", { sessionID: sessionID, cause: cause })),
-        Effect.forkIn(s.scope),
-      )
-      return result
-    })
-
-    const remove = Effect.fn("ShareNext.remove")(function* (sessionID: SessionID) {
-      if (disabled) return
-      yield* Effect.logInfo("removing share", { sessionID: 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 node = LayerNode.make({
-  service: Service,
-  layer: layer,
-  deps: [Account.node, EventV2Bridge.node, Config.node, Database.node, httpClient, Provider.node, Session.node],
-})
-
-export * as ShareNext from "./share-next"

package/src/skill/discovery.ts

@@ -1,140 +0,0 @@
-import { LayerNode } from "@soraacode/core/effect/layer-node"
-import { httpClient, path } from "@soraacode/core/effect/app-node-platform"
-import { NodePath } from "@effect/platform-node"
-import { Effect, Layer, Path, Schema, Context } from "effect"
-import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { withTransientReadRetry } from "@/util/effect-http-client"
-import { FSUtil } from "@soraacode/core/fs-util"
-import { Global } from "@soraacode/core/global"
-
-const skillConcurrency = 4
-const fileConcurrency = 8
-
-class IndexSkill extends Schema.Class<IndexSkill>("IndexSkill")({
-  name: Schema.String,
-  files: Schema.Array(Schema.String),
-  version: Schema.optional(Schema.String),
-}) {}
-
-class Index extends Schema.Class<Index>("Index")({
-  skills: Schema.Array(IndexSkill),
-}) {}
-
-export interface Interface {
-  readonly pull: (url: string) => Effect.Effect<string[]>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SkillDiscovery") {}
-
-const layer: Layer.Layer<Service, never, FSUtil.Service | Path.Path | HttpClient.HttpClient> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    const path = yield* Path.Path
-    const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))
-    const cache = path.join(Global.Path.cache, "skills")
-
-    const download = Effect.fn("Discovery.download")(function* (url: string, dest: string) {
-      if (yield* fs.exists(dest).pipe(Effect.orDie)) return true
-
-      return yield* HttpClientRequest.get(url).pipe(
-        http.execute,
-        Effect.flatMap((res) => res.arrayBuffer),
-        Effect.flatMap((body) => fs.writeWithDirs(dest, new Uint8Array(body))),
-        Effect.as(true),
-        Effect.catch((err) => Effect.logError("failed to download", { url: url, error: err }).pipe(Effect.as(false))),
-      )
-    })
-
-    const pull = Effect.fn("Discovery.pull")(function* (url: string) {
-      const base = url.endsWith("/") ? url : `${url}/`
-      const index = new URL("index.json", base).href
-      const host = base.slice(0, -1)
-
-      yield* Effect.logInfo("fetching index", { url: index })
-
-      const data = yield* HttpClientRequest.get(index).pipe(
-        HttpClientRequest.acceptJson,
-        http.execute,
-        Effect.flatMap(HttpClientResponse.schemaBodyJson(Index)),
-        Effect.catch((err) =>
-          Effect.logError("failed to fetch index", { url: index, error: err }).pipe(Effect.as(null)),
-        ),
-      )
-
-      if (!data) return []
-
-      const missing = data.skills.filter((skill) => !skill.files.includes("SKILL.md"))
-      yield* Effect.forEach(
-        missing,
-        (skill) => Effect.logWarning("skill entry missing SKILL.md", { url: index, skill: skill.name }),
-        { discard: true },
-      )
-      const list = data.skills.filter((skill) => skill.files.includes("SKILL.md"))
-
-      const dirs = yield* Effect.forEach(
-        list,
-        (skill) =>
-          Effect.gen(function* () {
-            const root = path.join(cache, skill.name)
-            const versionFile = path.join(root, ".opencode-version")
-            const version = skill.version
-            const current =
-              version === undefined
-                ? undefined
-                : yield* fs.readFileStringSafe(versionFile).pipe(Effect.catch(() => Effect.succeed(undefined)))
-
-            if (version === undefined || current === version) {
-              yield* Effect.forEach(
-                skill.files,
-                (file) => download(new URL(file, `${host}/${skill.name}/`).href, path.join(root, file)),
-                { concurrency: fileConcurrency, discard: true },
-              )
-            } else {
-              const token = crypto.randomUUID()
-              const staging = `${root}.tmp-${token}`
-              const backup = `${root}.old-${token}`
-              yield* Effect.gen(function* () {
-                const downloaded = yield* Effect.forEach(
-                  skill.files,
-                  (file) => download(new URL(file, `${host}/${skill.name}/`).href, path.join(staging, file)),
-                  { concurrency: fileConcurrency },
-                )
-                if (!downloaded.every(Boolean)) return
-                if (!(yield* fs.exists(path.join(staging, "SKILL.md")).pipe(Effect.orDie))) return
-                yield* fs.writeFileString(path.join(staging, ".opencode-version"), version)
-                yield* Effect.uninterruptible(
-                  Effect.gen(function* () {
-                    const cached = yield* fs.exists(root).pipe(Effect.orDie)
-                    if (cached) yield* fs.rename(root, backup)
-                    yield* fs.rename(staging, root).pipe(
-                      Effect.catch((error) =>
-                        Effect.gen(function* () {
-                          if (cached) yield* fs.rename(backup, root).pipe(Effect.ignore)
-                          return yield* Effect.fail(error)
-                        }),
-                      ),
-                    )
-                    if (cached) yield* fs.remove(backup, { recursive: true, force: true }).pipe(Effect.ignore)
-                  }),
-                )
-              }).pipe(
-                Effect.catch((error) => Effect.logError("failed to refresh skill", { skill: skill.name, error })),
-                Effect.ensuring(fs.remove(staging, { recursive: true, force: true }).pipe(Effect.ignore)),
-              )
-            }
-            return (yield* fs.exists(path.join(root, "SKILL.md")).pipe(Effect.orDie)) ? root : null
-          }),
-        { concurrency: skillConcurrency },
-      )
-
-      return dirs.filter((dir): dir is string => dir !== null)
-    })
-
-    return Service.of({ pull })
-  }),
-)
-
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [FSUtil.node, path, httpClient] })
-
-export * as Discovery from "./discovery"