Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
7.0 KB
Raw Blame
/** @jsxImportSource react */
import {
  createContext,
  useCallback,
  use,
  useEffect,
  useMemo,
  useRef,
  useState,
  type ReactNode,
} from "react";

import { MODEL_PREF_KEY, THINKING_PREF_KEY } from "../../app/constants";
import { coerceReleaseChannel } from "../../app/lib/release-channels";
import type { ModelRef, ReleaseChannel, SettingsTab, View } from "../../app/types";
import {
  DEFAULT_DESKTOP_NOTIFICATION_PREFERENCE,
  isDesktopNotificationPreference,
  type DesktopNotificationPreference,
} from "./desktop-notification-preferences";
import { LOCAL_PREFERENCES_KEY } from "./local-preferences-storage";
import {
  readStoredDefaultModel,
  storedDefaultModelChangedEvent,
  writeStoredDefaultModel,
} from "./model-config";

export type LocalUIState = {
  view: View;
  tab: SettingsTab;
};

export type LocalPreferences = {
  showThinking: boolean;
  modelVariant: string | null;
  defaultModel: ModelRef | null;
  /**
   * Name of the opencode agent used for new prompts (null = the server's
   * default, usually "build"). Persisted so a reload does not silently
   * fall back to the default agent (#2101).
   */
  selectedAgent: string | null;
  /**
   * Release channel the desktop app is subscribed to. Defaults to
   * "stable". Alpha is only honored on macOS; the updater helper falls
   * back to stable elsewhere.
   */
  releaseChannel: ReleaseChannel;
  featureFlags: {
    microsandboxCreateSandbox: boolean;
    workspaceRunMode: boolean;
  };
  /**
   * Set to true after the user completes the welcome/onboarding flow
   * (creates or connects their first workspace). When false and the
   * workspace list is empty, the app redirects to /welcome.
   */
  hasCompletedOnboarding: boolean;
  /**
   * Native OS notifications from the desktop app. Off by default so upgrading
   * users are not surprised by system popups.
   */
  desktopNotifications: DesktopNotificationPreference;
};

type LocalContextValue = {
  ui: LocalUIState;
  setUi: (updater: (previous: LocalUIState) => LocalUIState) => void;
  prefs: LocalPreferences;
  setPrefs: (updater: (previous: LocalPreferences) => LocalPreferences) => void;
  ready: boolean;
};

const LocalContext = createContext<LocalContextValue | undefined>(undefined);

const UI_STORAGE_KEY = "omnirush.ui";
export const DEFAULT_SHOW_THINKING = true;

const INITIAL_UI: LocalUIState = { view: "settings", tab: "general" };
const INITIAL_PREFS: LocalPreferences = {
  showThinking: DEFAULT_SHOW_THINKING,
  modelVariant: null,
  defaultModel: null,
  selectedAgent: null,
  releaseChannel: "stable",
  featureFlags: { microsandboxCreateSandbox: true, workspaceRunMode: false },
  hasCompletedOnboarding: false,
  desktopNotifications: DEFAULT_DESKTOP_NOTIFICATION_PREFERENCE,
};

function readPersisted<T>(key: string, fallback: T): T {
  if (typeof window === "undefined") return fallback;
  try {
    const raw = window.localStorage.getItem(key);
    if (!raw) return fallback;
    const parsed = JSON.parse(raw) as unknown;
    if (parsed && typeof parsed === "object") {
      return { ...fallback, ...(parsed as Record<string, unknown>) } as T;
    }
    return fallback;
  } catch {
    return fallback;
  }
}

function writePersisted(key: string, value: unknown) {
  if (typeof window === "undefined") return;
  try {
    window.localStorage.setItem(key, JSON.stringify(value));
  } catch {
    // ignore quota errors
  }
}

type LocalProviderProps = {
  children: ReactNode;
};

export function LocalProvider({ children }: LocalProviderProps) {
  const [ui, setUiRaw] = useState<LocalUIState>(() =>
    readPersisted(UI_STORAGE_KEY, INITIAL_UI),
  );
  const [prefs, setPrefsRaw] = useState<LocalPreferences>(() => {
    const persisted = readPersisted(LOCAL_PREFERENCES_KEY, INITIAL_PREFS);
    persisted.desktopNotifications = isDesktopNotificationPreference(persisted.desktopNotifications)
      ? persisted.desktopNotifications
      : DEFAULT_DESKTOP_NOTIFICATION_PREFERENCE;
    try {
      if (window.localStorage.getItem(MODEL_PREF_KEY) !== null) {
        return { ...persisted, defaultModel: readStoredDefaultModel() };
      }
    } catch {
      // Retain the preferences migration when storage is unavailable.
    }
    if (persisted.defaultModel) return persisted;
    return {
      ...persisted,
      defaultModel: readStoredDefaultModel(),
    };
  });
  const prefsRef = useRef(prefs);
  const setPrefs = useCallback(
    (updater: (previous: LocalPreferences) => LocalPreferences) => {
      const previous = prefsRef.current;
      const next = updater(previous);
      prefsRef.current = next;
      setPrefsRaw(next);
      if (next.defaultModel && (
        next.defaultModel.providerID !== previous.defaultModel?.providerID ||
        next.defaultModel.modelID !== previous.defaultModel?.modelID
      )) writeStoredDefaultModel(next.defaultModel);
    },
    [],
  );
  const ready = true;
  const migratedThinkingRef = useRef(false);

  useEffect(() => {
    writePersisted(UI_STORAGE_KEY, ui);
  }, [ui]);

  useEffect(() => {
    writePersisted(LOCAL_PREFERENCES_KEY, prefs);
  }, [prefs]);

  useEffect(() => {
    const updateDefaultModel = () => {
      const model = readStoredDefaultModel();
      setPrefs((previous) => {
        if (
          previous.defaultModel?.providerID === model.providerID &&
          previous.defaultModel.modelID === model.modelID
        ) {
          return previous;
        }

        return {
          ...previous,
          defaultModel: model,
          modelVariant: null,
        };
      });
    };

    window.addEventListener(storedDefaultModelChangedEvent, updateDefaultModel);
    try {
      if (window.localStorage.getItem(MODEL_PREF_KEY) === null && prefsRef.current.defaultModel) {
        writeStoredDefaultModel(prefsRef.current.defaultModel);
      }
    } catch {
      // Storage may be unavailable.
    }
    updateDefaultModel();
    return () => window.removeEventListener(storedDefaultModelChangedEvent, updateDefaultModel);
  }, [setPrefs]);

  useEffect(() => {
    if (typeof window === "undefined") return;
    if (migratedThinkingRef.current) return;
    migratedThinkingRef.current = true;

    const raw = window.localStorage.getItem(THINKING_PREF_KEY);
    if (raw == null) return;

    try {
      const parsed = JSON.parse(raw);
      if (typeof parsed === "boolean") {
        setPrefs((previous) => ({ ...previous, showThinking: parsed }));
      }
    } catch {
      // ignore invalid legacy values
    }

    try {
      window.localStorage.removeItem(THINKING_PREF_KEY);
    } catch {
      // ignore
    }
  }, [setPrefs]);

  const setUi = useCallback(
    (updater: (previous: LocalUIState) => LocalUIState) => {
      setUiRaw(updater);
    },
    [],
  );

  const value = useMemo<LocalContextValue>(
    () => ({ ui, setUi, prefs, setPrefs, ready }),
    [prefs, ready, setPrefs, setUi, ui],
  );

  return <LocalContext.Provider value={value}>{children}</LocalContext.Provider>;
}

export function useLocal(): LocalContextValue {
  const context = use(LocalContext);
  if (!context) {
    throw new Error("Local context is missing");
  }
  return context;
}