bonecode 1.0.0

package/src/engine/share/session.ts

@@ -0,0 +1,61 @@
+import { Session } from "@/session/session"
+import { SessionID } from "@/session/schema"
+import { SyncEvent } from "@/sync"
+import { Effect, Layer, Scope, Context } from "effect"
+import { Config } from "@/config/config"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import * as ShareNext from "./share-next"
+
+export interface Interface {
+  readonly create: (input?: Session.CreateInput) => Effect.Effect<Session.Info>
+  readonly share: (sessionID: SessionID) => Effect.Effect<{ url: string }, unknown>
+  readonly unshare: (sessionID: SessionID) => Effect.Effect<void, unknown>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/SessionShare") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const cfg = yield* Config.Service
+    const session = yield* Session.Service
+    const shareNext = yield* ShareNext.Service
+    const scope = yield* Scope.Scope
+    const sync = yield* SyncEvent.Service
+    const flags = yield* RuntimeFlags.Service
+
+    const share = Effect.fn("SessionShare.share")(function* (sessionID: SessionID) {
+      const conf = yield* cfg.get()
+      if (conf.share === "disabled") throw new Error("Sharing is disabled in configuration")
+      const result = yield* shareNext.create(sessionID)
+      yield* sync.run(Session.Event.Updated, { sessionID, info: { share: { url: result.url } } })
+      return result
+    })
+
+    const unshare = Effect.fn("SessionShare.unshare")(function* (sessionID: SessionID) {
+      yield* shareNext.remove(sessionID)
+      yield* sync.run(Session.Event.Updated, { sessionID, info: { share: { url: null } } })
+    })
+
+    const create = Effect.fn("SessionShare.create")(function* (input?: Session.CreateInput) {
+      const result = yield* session.create(input)
+      if (result.parentID) return result
+      const conf = yield* cfg.get()
+      if (!(flags.autoShare || conf.share === "auto")) return result
+      yield* share(result.id).pipe(Effect.ignore, Effect.forkIn(scope))
+      return result
+    })
+
+    return Service.of({ create, share, unshare })
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(ShareNext.defaultLayer),
+  Layer.provide(Session.defaultLayer),
+  Layer.provide(Config.defaultLayer),
+  Layer.provide(SyncEvent.defaultLayer),
+  Layer.provide(RuntimeFlags.defaultLayer),
+)
+
+export * as SessionShare from "./session"

package/src/engine/share/share-next.ts

@@ -0,0 +1,376 @@
+import type * as SDK from "@opencode-ai/sdk/v2"
+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 { Bus } from "@/bus"
+import { InstanceState } from "@/effect/instance-state"
+import { Provider } from "@/provider/provider"
+import { ModelID, ProviderID } from "@/provider/schema"
+import { Session } from "@/session/session"
+import { MessageV2 } from "@/session/message-v2"
+import type { SessionID } from "@/session/schema"
+import { Database } from "@/storage/db"
+import { eq } from "drizzle-orm"
+import { Config } from "@/config/config"
+import * as Log from "@opencode-ai/core/util/log"
+import { SessionShareTable } from "./share.sql"
+
+const log = Log.create({ service: "share-next" })
+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") {}
+
+const db = <T>(fn: (d: Parameters<typeof Database.use>[0] extends (trx: infer D) => any ? D : never) => T) =>
+  Effect.sync(() => Database.use(fn))
+
+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 bus = yield* Bus.Service
+    const cfg = yield* Config.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[]): Effect.Effect<void> {
+      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 { type: string }>(
+          def: D,
+          fn: (evt: { properties: any }) => Effect.Effect<void, unknown>,
+        ) =>
+          bus.subscribe(def as never).pipe(
+            Stream.runForEach((evt) =>
+              fn(evt).pipe(
+                Effect.catchCause((cause) =>
+                  Effect.sync(() => {
+                    log.error("share subscriber failed", { type: def.type, cause })
+                  }),
+                ),
+              ),
+            ),
+            Effect.forkScoped,
+          )
+
+        yield* watch(Session.Event.Updated, (evt) =>
+          Effect.gen(function* () {
+            const info = evt.properties.info
+            yield* sync(info.id, [{ type: "session", data: info }])
+          }),
+        )
+        yield* watch(MessageV2.Event.Updated, (evt) =>
+          Effect.gen(function* () {
+            const info = evt.properties.info
+            yield* sync(info.sessionID, [{ type: "message", data: info }])
+            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, (evt) =>
+          sync(evt.properties.part.sessionID, [{ type: "part", data: evt.properties.part }]),
+        )
+        yield* watch(Session.Event.Diff, (evt) =>
+          sync(evt.properties.sessionID, [{ type: "session_diff", data: evt.properties.diff }]),
+        )
+        yield* watch(Session.Event.Deleted, (evt) => remove(evt.properties.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((db) =>
+        db.select().from(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).get(),
+      )
+      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(ProviderID.make(item.providerID), ModelID.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((db) =>
+        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(),
+      )
+      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((db) => db.delete(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).run())
+      s.shared.delete(sessionID)
+      s.queue.delete(sessionID)
+    })
+
+    return Service.of({ init, url, request, create, remove })
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(Bus.layer),
+  Layer.provide(Account.defaultLayer),
+  Layer.provide(Config.defaultLayer),
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(Provider.defaultLayer),
+  Layer.provide(Session.defaultLayer),
+)
+
+export * as ShareNext from "./share-next"

package/src/engine/share/share.sql.ts

@@ -0,0 +1,13 @@
+import { sqliteTable, text } from "drizzle-orm/sqlite-core"
+import { SessionTable } from "../session/session.sql"
+import { Timestamps } from "../storage/schema.sql"
+
+export const SessionShareTable = sqliteTable("session_share", {
+  session_id: text()
+    .primaryKey()
+    .references(() => SessionTable.id, { onDelete: "cascade" }),
+  id: text().notNull(),
+  secret: text().notNull(),
+  url: text().notNull(),
+  ...Timestamps,
+})

package/src/engine/shell/shell/shell.ts

@@ -0,0 +1,215 @@
+import { Flag } from "@opencode-ai/core/flag/flag"
+import { lazy } from "@/util/lazy"
+import { Filesystem } from "@/util/filesystem"
+import { which } from "@/util/which"
+import path from "path"
+import { spawn, type ChildProcess } from "child_process"
+import { setTimeout as sleep } from "node:timers/promises"
+
+const SIGKILL_TIMEOUT_MS = 200
+const META: Record<string, { deny?: boolean; login?: boolean; posix?: boolean; ps?: boolean }> = {
+  bash: { login: true, posix: true },
+  dash: { login: true, posix: true },
+  fish: { deny: true, login: true },
+  ksh: { login: true, posix: true },
+  nu: { deny: true },
+  powershell: { ps: true },
+  pwsh: { ps: true },
+  sh: { login: true, posix: true },
+  zsh: { login: true, posix: true },
+}
+
+export type Item = {
+  path: string
+  name: string
+  acceptable: boolean
+}
+
+export async function killTree(proc: ChildProcess, opts?: { exited?: () => boolean }): Promise<void> {
+  const pid = proc.pid
+  if (!pid || opts?.exited?.()) return
+
+  if (process.platform === "win32") {
+    await new Promise<void>((resolve) => {
+      const killer = spawn("taskkill", ["/pid", String(pid), "/f", "/t"], {
+        stdio: "ignore",
+        windowsHide: true,
+      })
+      killer.once("exit", () => resolve())
+      killer.once("error", () => resolve())
+    })
+    return
+  }
+
+  try {
+    process.kill(-pid, "SIGTERM")
+    await sleep(SIGKILL_TIMEOUT_MS)
+    if (!opts?.exited?.()) {
+      process.kill(-pid, "SIGKILL")
+    }
+  } catch (_e) {
+    proc.kill("SIGTERM")
+    await sleep(SIGKILL_TIMEOUT_MS)
+    if (!opts?.exited?.()) {
+      proc.kill("SIGKILL")
+    }
+  }
+}
+
+function full(file: string) {
+  if (process.platform !== "win32") return file
+  const shell = Filesystem.windowsPath(file)
+  if (path.win32.dirname(shell) !== ".") {
+    if (shell.startsWith("/") && name(shell) === "bash") return gitbash() || shell
+    return shell
+  }
+  if (name(shell) === "bash") return gitbash() || which(shell) || shell
+  return which(shell) || shell
+}
+
+function meta(file: string) {
+  return META[name(file)]
+}
+
+function ok(file: string) {
+  return meta(file)?.deny !== true
+}
+
+function rooted(file: string) {
+  return path.isAbsolute(Filesystem.windowsPath(file))
+}
+
+function resolve(file: string) {
+  const shell = full(file)
+  if (rooted(shell)) {
+    if (Filesystem.stat(shell)?.isFile()) return shell
+    return
+  }
+  return which(shell) ?? undefined
+}
+
+function win() {
+  return Array.from(
+    new Set(
+      [which("pwsh"), which("powershell"), gitbash(), process.env.COMSPEC || "cmd.exe"]
+        .filter((item): item is string => Boolean(item))
+        .map(full),
+    ),
+  )
+}
+
+async function unix() {
+  const text = await Filesystem.readText("/etc/shells").catch(() => "")
+  if (text) return Array.from(new Set(text.split("\n").filter((line) => line.trim() && !line.startsWith("#"))))
+  return ["/bin/bash", "/bin/zsh", "/bin/sh"]
+}
+
+function select(file: string | undefined, opts?: { acceptable?: boolean }) {
+  if (file && (!opts?.acceptable || ok(file))) {
+    const shell = resolve(file)
+    if (shell) return shell
+  }
+  if (process.platform === "win32") return win()[0]!
+  return fallback()
+}
+
+export function gitbash() {
+  if (process.platform !== "win32") return
+  if (Flag.OPENCODE_GIT_BASH_PATH) return Flag.OPENCODE_GIT_BASH_PATH
+  const git = which("git")
+  if (!git) return
+  const file = path.join(git, "..", "..", "bin", "bash.exe")
+  if (Filesystem.stat(file)?.size) return file
+}
+
+function fallback() {
+  if (process.platform === "darwin") return "/bin/zsh"
+  const bash = which("bash")
+  if (bash) return bash
+  return "/bin/sh"
+}
+
+export function name(file: string) {
+  if (process.platform === "win32") return path.win32.parse(Filesystem.windowsPath(file)).name.toLowerCase()
+  return path.basename(file).toLowerCase()
+}
+
+export function login(file: string) {
+  return meta(file)?.login === true
+}
+
+export function posix(file: string) {
+  return meta(file)?.posix === true
+}
+
+export function ps(file: string) {
+  return meta(file)?.ps === true
+}
+
+function info(file: string): Item {
+  const item = full(file)
+  const n = name(item)
+  return {
+    path: item,
+    name: resolve(n) ? n : item,
+    acceptable: ok(item),
+  }
+}
+
+export function args(file: string, command: string, cwd: string) {
+  const n = name(file)
+  if (n === "nu" || n === "fish") return ["-c", command]
+  if (n === "zsh") {
+    return [
+      "-l",
+      "-c",
+      `
+        [[ -f ~/.zshenv ]] && source ~/.zshenv >/dev/null 2>&1 || true
+        [[ -f "\${ZDOTDIR:-$HOME}/.zshrc" ]] && source "\${ZDOTDIR:-$HOME}/.zshrc" >/dev/null 2>&1 || true
+        cd -- "$1"
+        eval ${JSON.stringify(command)}
+      `,
+      "opencode",
+      cwd,
+    ]
+  }
+  if (n === "bash") {
+    return [
+      "-l",
+      "-c",
+      `
+        shopt -s expand_aliases
+        [[ -f ~/.bashrc ]] && source ~/.bashrc >/dev/null 2>&1 || true
+        cd -- "$1"
+        eval ${JSON.stringify(command)}
+      `,
+      "opencode",
+      cwd,
+    ]
+  }
+  if (n === "cmd") return ["/c", command]
+  if (ps(file)) return ["-NoProfile", "-Command", command]
+  return ["-c", command]
+}
+
+const defaultPreferred = lazy(() => select(process.env.SHELL))
+const defaultAcceptable = lazy(() => select(process.env.SHELL, { acceptable: true }))
+
+export function preferred(configShell?: string) {
+  if (configShell) return select(configShell)
+  return defaultPreferred()
+}
+preferred.reset = () => defaultPreferred.reset()
+
+export function acceptable(configShell?: string) {
+  if (configShell) return select(configShell, { acceptable: true })
+  return defaultAcceptable()
+}
+acceptable.reset = () => defaultAcceptable.reset()
+
+export async function list(): Promise<Item[]> {
+  const shells = process.platform === "win32" ? win() : await unix()
+  return shells.filter((s) => resolve(s)).map(info)
+}
+
+export * as Shell from "./shell"