openchamber/packages/ui/src/sync/bootstrap.ts

import type { OpencodeClient, PermissionRequest, Project, QuestionRequest } from "@opencode-ai/sdk/v2/client"
import { retry } from "./retry"
import type { GlobalState, State } from "./types"

const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)

const requestSignature = (items: Array<{ id: string }> | undefined): string => {
  if (!items || items.length === 0) return ""
  return items
    .map((item) => item.id)
    .sort(cmp)
    .join("|")
}

function groupBySession<T extends { id: string; sessionID: string }>(input: T[]) {
  return input.reduce<Record<string, T[]>>((acc, item) => {
    if (!item?.id || !item.sessionID) return acc
    const list = acc[item.sessionID]
    if (list) list.push(item)
    else acc[item.sessionID] = [item]
    return acc
  }, {})
}

function projectID(directory: string, projects: Project[]) {
  return projects.find(
    (project) => project.worktree === directory || project.sandboxes?.includes(directory),
  )?.id
}

// ---------------------------------------------------------------------------
// Bootstrap global state
// ---------------------------------------------------------------------------

export async function bootstrapGlobal(
  sdk: OpencodeClient,
  set: (patch: Partial<GlobalState>) => void,
) {
  const results = await Promise.allSettled([
    retry(() => sdk.path.get().then((x) => set({ path: x.data! }))),
    retry(() => sdk.global.config.get().then((x) => set({ config: x.data! }))),
    retry(() =>
      sdk.project.list().then((x) => {
        const projects = (x.data ?? [])
          .filter((p): p is Project => !!p?.id)
          .filter((p) => !!p.worktree && !p.worktree.includes("opencode-test"))
          .sort((a, b) => cmp(a.id, b.id))
        set({ projects })
      }),
    ),
    retry(() => sdk.provider.list().then((x) => set({ providers: x.data! }))),
  ])

  const errors = results
    .filter((r): r is PromiseRejectedResult => r.status === "rejected")
    .map((r) => r.reason)
  if (errors.length) {
    console.error("[bootstrap] global bootstrap failed", errors[0])
  }

  // If ALL requests failed, OpenCode is likely down — fetch the OpenChamber
  // health endpoint (outside the readiness gate) to get the actual error reason.
  if (errors.length === results.length) {
    let message = errors[0] instanceof Error ? errors[0].message : String(errors[0])
    try {
      const healthRes = await fetch("/health", { signal: AbortSignal.timeout(4000) })
      if (healthRes.ok) {
        const health = await healthRes.json()
        if (health.lastOpenCodeError) {
          message = health.lastOpenCodeError
        } else if (!health.openCodeRunning) {
          message = "OpenCode process is not running"
        }
      }
    } catch {
      // health endpoint itself unreachable — use the original error
    }
    set({ ready: true, error: { type: "init", message } })
  } else {
    set({ ready: true, error: undefined })
  }
}

// ---------------------------------------------------------------------------
// Bootstrap per-directory state
// ---------------------------------------------------------------------------

export async function bootstrapDirectory(input: {
  directory: string
  sdk: OpencodeClient
  getState: () => State
  set: (patch: Partial<State>) => void
  global: {
    config: Record<string, unknown>
    projects: Project[]
    providers: { all: unknown[]; connected: unknown[]; default: Record<string, unknown> }
  }
  loadSessions: (directory: string) => Promise<void> | void
}) {
  const { directory, sdk, getState, set, global: g } = input
  const state = getState()
  const loading = state.status !== "complete"

  // Seed from global state while we fetch directory-specific data
  const seededProject = projectID(directory, g.projects)
  if (seededProject) set({ project: seededProject })
  if (state.provider.all.length === 0 && g.providers.all.length > 0) {
    set({ provider: g.providers as State["provider"] })
  }
  if (Object.keys(state.config ?? {}).length === 0 && Object.keys(g.config ?? {}).length > 0) {
    set({ config: g.config as State["config"] })
  }
  if (loading) set({ status: "partial" })

  const results = await Promise.allSettled([
    seededProject
      ? Promise.resolve()
      : retry(() => sdk.project.current().then((x) => set({ project: x.data!.id }))),
    retry(() => sdk.provider.list().then((x) => set({ provider: x.data! }))),
    retry(() => sdk.app.agents().then((x) => set({ agent: x.data ?? [] }))),
    retry(() => sdk.config.get().then((x) => set({ config: x.data! }))),
    retry(() =>
      sdk.path.get().then((x) => {
        set({ path: x.data! })
        const next = projectID(x.data?.directory ?? directory, g.projects)
        if (next) set({ project: next })
      }),
    ),
    retry(() => sdk.command.list().then((x) => set({ command: x.data ?? [] }))),
    retry(() => sdk.session.status().then((x) => set({ session_status: x.data! }))),
    input.loadSessions(directory),
    retry(() => sdk.mcp.status().then((x) => set({ mcp: x.data! }))),
    retry(() => sdk.lsp.status().then((x) => set({ lsp: x.data! }))),
    retry(() =>
      sdk.vcs.get().then((x) => {
        const current = getState()
        set({ vcs: x.data ?? current.vcs })
      }),
    ),
    retry(async () => {
      const before = getState()
      const beforeSignatures = new Map(
        Object.entries(before.question ?? {}).map(([sessionID, questions]) => [sessionID, requestSignature(questions)]),
      )
      const x = await sdk.question.list(directory ? { directory } : undefined)
        const grouped = groupBySession(
          (x.data ?? []).filter((q): q is QuestionRequest => !!q?.id && !!q.sessionID),
        )
        const current = getState()
        const merged = { ...current.question }
        for (const [sessionID, questions] of Object.entries(grouped)) {
          merged[sessionID] = questions
            .filter((q) => !!q?.id)
            .sort((a, b) => cmp(a.id, b.id))
        }
        for (const sessionID of beforeSignatures.keys()) {
          if (grouped[sessionID]) continue
          const beforeSignature = beforeSignatures.get(sessionID) ?? ""
          const currentSignature = requestSignature(current.question[sessionID])
          if (currentSignature !== beforeSignature) continue
          delete merged[sessionID]
        }
        set({ question: merged })
    }),
    retry(async () => {
      const before = getState()
      const beforeSignatures = new Map(
        Object.entries(before.permission ?? {}).map(([sessionID, permissions]) => [sessionID, requestSignature(permissions)]),
      )
      const x = await sdk.permission.list(directory ? { directory } : undefined)
        const grouped = groupBySession(
          (x.data ?? []).filter((perm): perm is PermissionRequest => !!perm?.id && !!perm?.sessionID),
        )
        const current = getState()
        const merged = { ...current.permission }
        for (const [sessionID, perms] of Object.entries(grouped)) {
          merged[sessionID] = perms
            .filter((p) => !!p?.id)
            .sort((a, b) => cmp(a.id, b.id))
        }
        for (const sessionID of beforeSignatures.keys()) {
          if (grouped[sessionID]) continue
          const beforeSignature = beforeSignatures.get(sessionID) ?? ""
          const currentSignature = requestSignature(current.permission[sessionID])
          if (currentSignature !== beforeSignature) continue
          delete merged[sessionID]
        }
        set({ permission: merged })
    }),
  ])

  const errors = results
    .filter((r): r is PromiseRejectedResult => r.status === "rejected")
    .map((r) => r.reason)
  if (errors.length) {
    console.error(`[bootstrap] directory bootstrap failed for ${directory}`, errors[0])
    return
  }

  if (loading) set({ status: "complete" })
}