Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
10.6 KB
Raw Blame
/** @jsxImportSource react */
import {
  createContext,
  useCallback,
  use,
  useEffect,
  useMemo,
  useRef,
  useState,
  type ReactNode,
} from "react";
import type {
  Config,
  Event,
  GlobalHealthResponse,
  LspStatus,
  Message,
  Part,
  Project,
  ProviderAuthResponse,
  ProviderListResponse,
  Session,
  VcsInfo,
} from "@opencode-ai/sdk/v2/client";

import { t } from "../../i18n";
import { unwrap } from "../../app/lib/opencode";
import type { McpStatusMap, TodoItem } from "../../app/types";
import { safeStringify } from "../../app/utils";
import { filterProviderList } from "../../app/utils/providers";
import { getReactQueryClient } from "../infra/query-client";
import { ensureProviderListQuery } from "../infra/provider-list-query";

import { useGlobalSDK } from "./global-sdk-provider";

export type WorkspaceState = {
  status: "idle" | "loading" | "partial" | "ready";
  session: Session[];
  session_status: Record<string, string>;
  message: Record<string, Message[]>;
  part: Record<string, Part[]>;
  todo: Record<string, TodoItem[]>;
};

type ProjectMeta = {
  name?: string;
  icon?: Project["icon"];
};

export type GlobalState = {
  ready: boolean;
  error?: string;
  serverVersion?: string;
  config: Config;
  provider: ProviderListResponse;
  providerAuth: ProviderAuthResponse;
  mcp: Record<string, McpStatusMap>;
  lsp: Record<string, LspStatus[]>;
  project: Project[];
  projectMeta: Record<string, ProjectMeta>;
  vcs: Record<string, VcsInfo | null>;
};

type GlobalSyncContextValue = {
  data: GlobalState;
  setData: (updater: (previous: GlobalState) => GlobalState) => void;
  refresh: () => Promise<void>;
  refreshDirectory: (directory: string) => Promise<void>;
  getWorkspace: (directory: string) => WorkspaceState;
  setWorkspace: (
    directory: string,
    updater: (previous: WorkspaceState) => WorkspaceState,
  ) => void;
};

const GlobalSyncContext = createContext<GlobalSyncContextValue | undefined>(
  undefined,
);

const DEFAULT_PROVIDER: ProviderListResponse = {
  all: [],
  connected: [],
  default: {},
};

const INITIAL_GLOBAL_STATE: GlobalState = {
  ready: false,
  error: undefined,
  serverVersion: undefined,
  config: {},
  provider: DEFAULT_PROVIDER,
  providerAuth: {},
  mcp: {},
  lsp: {},
  project: [],
  projectMeta: {},
  vcs: {},
};

const createWorkspaceState = (): WorkspaceState => ({
  status: "idle",
  session: [],
  session_status: {},
  message: {},
  part: {},
  todo: {},
});

const keyFor = (directory: string) => directory || "global";

type GlobalSyncProviderProps = {
  children: ReactNode;
};

export function GlobalSyncProvider({ children }: GlobalSyncProviderProps) {
  const globalSDK = useGlobalSDK();
  const [state, setState] = useState<GlobalState>(INITIAL_GLOBAL_STATE);
  const workspacesRef = useRef(new Map<string, WorkspaceState>());
  const subscriptionsRef = useRef(new Map<string, () => void>());
  const latestStateRef = useRef<GlobalState>(state);
  latestStateRef.current = state;

  const setField = useCallback(
    <K extends keyof GlobalState>(key: K, value: GlobalState[K]) => {
      setState((previous) => ({ ...previous, [key]: value }));
    },
    [],
  );

  const setError = useCallback((error: unknown) => {
    const message =
      error instanceof Error ? error.message : safeStringify(error);
    setState((previous) => ({
      ...previous,
      error: message || t("app.unknown_error"),
    }));
  }, []);

  const setProjectMetaForProjects = useCallback((projects: Project[]) => {
    const next: Record<string, ProjectMeta> = {};
    for (const project of projects) {
      if (!project?.worktree) continue;
      next[project.worktree] = {
        name: project.name,
        icon: project.icon,
      };
    }
    setField("projectMeta", next);
  }, [setField]);

  const refreshConfig = useCallback(async () => {
    const result = unwrap(await globalSDK.client.config.get());
    setField("config", result);
  }, [globalSDK.client, setField]);

  const refreshProviders = useCallback(async () => {
    let disabledProviders =
      latestStateRef.current.config.disabled_providers ?? [];
    try {
      const config = unwrap(await globalSDK.client.config.get());
      disabledProviders = Array.isArray(config.disabled_providers)
        ? config.disabled_providers
        : [];
    } catch {
      // ignore config read failures
    }
    try {
      const result = filterProviderList(
        await ensureProviderListQuery(getReactQueryClient(), {
          client: globalSDK.client,
        }),
        disabledProviders,
      );
      setField("provider", result);
    } catch {
      setField("provider", { all: [], connected: [], default: {} });
    }
  }, [globalSDK.client, setField]);

  const refreshProviderAuth = useCallback(async () => {
    try {
      const result = await globalSDK.client.provider.auth();
      setField("providerAuth", result.data ?? {});
    } catch {
      setField("providerAuth", {});
    }
  }, [globalSDK.client, setField]);

  const refreshMcp = useCallback(
    async (directory?: string) => {
      const result = unwrap(
        await globalSDK.client.mcp.status({ directory }),
      ) as McpStatusMap;
      setState((previous) => ({
        ...previous,
        mcp: { ...previous.mcp, [keyFor(directory ?? "")]: result },
      }));
    },
    [globalSDK.client],
  );

  const refreshLsp = useCallback(
    async (directory?: string) => {
      const result = unwrap(
        await globalSDK.client.lsp.status({ directory }),
      ) as LspStatus[];
      setState((previous) => ({
        ...previous,
        lsp: { ...previous.lsp, [keyFor(directory ?? "")]: result },
      }));
    },
    [globalSDK.client],
  );

  const refreshVcs = useCallback(
    async (directory: string) => {
      try {
        const result = unwrap(
          await globalSDK.client.vcs.get({ directory }),
        ) as VcsInfo;
        setState((previous) => ({
          ...previous,
          vcs: { ...previous.vcs, [keyFor(directory)]: result ?? null },
        }));
      } catch {
        setState((previous) => ({
          ...previous,
          vcs: { ...previous.vcs, [keyFor(directory)]: null },
        }));
      }
    },
    [globalSDK.client],
  );

  const refreshProjects = useCallback(async () => {
    const projects = unwrap(
      await globalSDK.client.project.list(),
    ) as Project[];
    setField("project", projects);
    setProjectMetaForProjects(projects);
    await Promise.allSettled(
      projects.flatMap((project) => {
        const worktree = project.worktree;
        return typeof worktree === "string" && worktree.length > 0 ? [refreshVcs(worktree)] : [];
      }),
    );
  }, [globalSDK.client, refreshVcs, setField, setProjectMetaForProjects]);

  const refreshDirectory = useCallback(
    async (directory: string) => {
      if (!directory) return;
      await Promise.allSettled([
        refreshMcp(directory),
        refreshLsp(directory),
        refreshVcs(directory),
      ]);
    },
    [refreshLsp, refreshMcp, refreshVcs],
  );

  const refresh = useCallback(async () => {
    setState((previous) => ({ ...previous, ready: false, error: undefined }));
    try {
      const health = unwrap(
        await globalSDK.client.global.health(),
      ) as GlobalHealthResponse;
      if (!health?.healthy) {
        setField("error", "Server reported unhealthy status.");
        return;
      }
      const previousVersion = latestStateRef.current.serverVersion;
      if (previousVersion && health.version !== previousVersion) {
        setState((previous) => ({
          ...previous,
          mcp: {},
          lsp: {},
          project: [],
          projectMeta: {},
          vcs: {},
        }));
      }
      setField("serverVersion", health.version);
    } catch (error) {
      setError(error);
      return;
    }

    const results = await Promise.allSettled([
      refreshConfig(),
      refreshProviders(),
      refreshProviderAuth(),
      refreshMcp(),
      refreshLsp(),
      refreshProjects(),
    ]);

    for (const result of results) {
      if (result.status === "rejected") {
        setError(result.reason);
      }
    }

    setField("ready", true);
  }, [
    globalSDK.client,
    refreshConfig,
    refreshLsp,
    refreshMcp,
    refreshProjects,
    refreshProviderAuth,
    refreshProviders,
    setError,
    setField,
  ]);

  useEffect(() => {
    if (!globalSDK.url) return;
    void refresh();
  }, [globalSDK.url, refresh]);

  // Listen for directory-scoped change events and refresh the matching slices.
  useEffect(() => {
    const globalKey = keyFor("");
    if (subscriptionsRef.current.has(globalKey)) return;
    const unsubscribe = globalSDK.event.on(globalKey, (payload: Event) => {
      if (payload.type === "lsp.updated") void refreshLsp();
      if (payload.type === "mcp.tools.changed") void refreshMcp();
    });
    subscriptionsRef.current.set(globalKey, unsubscribe);
    return () => {
      subscriptionsRef.current.delete(globalKey);
      unsubscribe();
    };
  }, [globalSDK.event, refreshLsp, refreshMcp]);

  const getWorkspace = useCallback((directory: string) => {
    const key = keyFor(directory);
    const existing = workspacesRef.current.get(key);
    if (existing) return existing;
    const next = createWorkspaceState();
    workspacesRef.current.set(key, next);
    void refreshDirectory(directory);
    if (!subscriptionsRef.current.has(key)) {
      const unsubscribe = globalSDK.event.on(key, (payload: Event) => {
        if (payload.type === "lsp.updated") void refreshLsp(directory);
        if (payload.type === "mcp.tools.changed") void refreshMcp(directory);
      });
      subscriptionsRef.current.set(key, unsubscribe);
    }
    return next;
  }, [globalSDK.event, refreshDirectory, refreshLsp, refreshMcp]);

  const setWorkspace = useCallback(
    (
      directory: string,
      updater: (previous: WorkspaceState) => WorkspaceState,
    ) => {
      const key = keyFor(directory);
      const current =
        workspacesRef.current.get(key) ?? createWorkspaceState();
      const next = updater(current);
      workspacesRef.current.set(key, next);
    },
    [],
  );

  const value = useMemo<GlobalSyncContextValue>(
    () => ({
      data: state,
      setData: (updater) => setState(updater),
      refresh,
      refreshDirectory,
      getWorkspace,
      setWorkspace,
    }),
    [getWorkspace, refresh, refreshDirectory, setWorkspace, state],
  );

  return (
    <GlobalSyncContext.Provider value={value}>
      {children}
    </GlobalSyncContext.Provider>
  );
}

export function useGlobalSync(): GlobalSyncContextValue {
  const context = use(GlobalSyncContext);
  if (!context) {
    throw new Error("Global sync context is missing");
  }
  return context;
}