Skip to content

armgit / Handy

Public Imported from GitHub
0

A free, open source, and extensible speech-to-text application that works completely offline.

10.6 KB
Raw Blame
import { create } from "zustand";
import { subscribeWithSelector } from "zustand/middleware";
import { produce } from "immer";
import { listen } from "@tauri-apps/api/event";
import { commands, type ModelInfo } from "@/bindings";
import i18n from "@/i18n";
import { notify, useNoticeStore } from "@/stores/noticeStore";

const downloadNoticeKey = (modelId: string) => `model-download:${modelId}`;

export interface DownloadProgress {
  model_id: string;
  downloaded: number;
  total: number;
  percentage: number;
  /** Measured by the backend over this transfer only; null until known. */
  bytes_per_sec: number | null;
}

// Using Record instead of Set/Map for Immer compatibility
interface ModelsStore {
  models: ModelInfo[];
  currentModel: string;
  downloadingModels: Record<string, true>;
  verifyingModels: Record<string, true>;
  downloadProgress: Record<string, DownloadProgress>;
  loading: boolean;
  error: string | null;
  initialized: boolean;
  isRescanning: boolean;

  // Actions
  initialize: () => Promise<void>;
  loadModels: () => Promise<void>;
  loadCurrentModel: () => Promise<void>;
  rescanLocalModels: () => Promise<void>;
  selectModel: (modelId: string) => Promise<boolean>;
  downloadModel: (modelId: string) => Promise<boolean>;
  cancelDownload: (modelId: string) => Promise<boolean>;
  deleteModel: (modelId: string) => Promise<boolean>;
  getModelInfo: (modelId: string) => ModelInfo | undefined;
  isModelDownloading: (modelId: string) => boolean;
  isModelVerifying: (modelId: string) => boolean;
  getDownloadProgress: (modelId: string) => DownloadProgress | undefined;

  // Internal setters
  setModels: (models: ModelInfo[]) => void;
  setCurrentModel: (modelId: string) => void;
  setError: (error: string | null) => void;
  setLoading: (loading: boolean) => void;
}

export const useModelStore = create<ModelsStore>()(
  subscribeWithSelector((set, get) => ({
    models: [],
    currentModel: "",
    downloadingModels: {},
    verifyingModels: {},
    downloadProgress: {},
    loading: true,
    error: null,
    initialized: false,
    isRescanning: false,

    // Internal setters
    setModels: (models) => set({ models }),
    setCurrentModel: (currentModel) => set({ currentModel }),
    setError: (error) => set({ error }),
    setLoading: (loading) => set({ loading }),

    loadModels: async () => {
      try {
        const result = await commands.getAvailableModels();
        if (result.status === "ok") {
          set({ models: result.data, error: null });

          // Sync downloading state from backend
          set(
            produce((state) => {
              const backendDownloading: Record<string, true> = {};
              result.data
                .filter((m) => m.is_downloading)
                .forEach((m) => {
                  backendDownloading[m.id] = true;
                });

              // Merge: keep frontend state if downloading, add backend state
              Object.keys(backendDownloading).forEach((id) => {
                state.downloadingModels[id] = true;
              });

              // Remove models that backend says are NOT downloading AND
              // frontend doesn't have progress for (completed/cancelled)
              Object.keys(state.downloadingModels).forEach((id) => {
                if (!backendDownloading[id] && !state.downloadProgress[id]) {
                  delete state.downloadingModels[id];
                }
              });
            }),
          );
        } else {
          set({ error: `Failed to load models: ${result.error}` });
        }
      } catch (err) {
        set({ error: `Failed to load models: ${err}` });
      } finally {
        set({ loading: false });
      }
    },

    loadCurrentModel: async () => {
      try {
        const result = await commands.getCurrentModel();
        if (result.status === "ok") {
          set({ currentModel: result.data });
        }
      } catch (err) {
        console.error("Failed to load current model:", err);
      }
    },

    rescanLocalModels: async () => {
      set({ isRescanning: true });
      try {
        const result = await commands.rescanLocalModels();
        if (result.status !== "ok") {
          set({ error: `Failed to rescan models: ${result.error}` });
        }
        // On success the backend emits `models-updated`, which reloads the list
        // via the listener registered in initialize().
      } catch (err) {
        set({ error: `Failed to rescan models: ${err}` });
      } finally {
        set({ isRescanning: false });
      }
    },

    selectModel: async (modelId: string) => {
      try {
        set({ error: null });
        const result = await commands.setActiveModel(modelId);
        if (result.status === "ok") {
          set({ currentModel: modelId });
          return true;
        } else {
          set({ error: `Failed to switch to model: ${result.error}` });
          return false;
        }
      } catch (err) {
        set({ error: `Failed to switch to model: ${err}` });
        return false;
      }
    },

    downloadModel: async (modelId: string) => {
      try {
        useNoticeStore.getState().clearLocal(downloadNoticeKey(modelId));
        set({ error: null });
        set(
          produce((state) => {
            state.downloadingModels[modelId] = true;
            state.downloadProgress[modelId] = {
              model_id: modelId,
              downloaded: 0,
              total: 0,
              percentage: 0,
            };
          }),
        );
        const result = await commands.downloadModel(modelId);
        if (result.status !== "ok") {
          // Fallback cleanup in case the model-download-failed event was not received
          // (e.g. listener not yet registered). The event handler is a no-op if it
          // arrives after this cleanup since deleting missing keys is safe.
          set(
            produce((state) => {
              delete state.downloadingModels[modelId];
              delete state.downloadProgress[modelId];
            }),
          );
        }
        return result.status === "ok";
      } catch {
        // model-download-failed event won't fire for JS exceptions (e.g. IPC error),
        // so clean up state here to avoid a stuck progress spinner.
        set(
          produce((state) => {
            delete state.downloadingModels[modelId];
            delete state.downloadProgress[modelId];
          }),
        );
        return false;
      }
    },

    cancelDownload: async (modelId: string) => {
      try {
        set({ error: null });
        const result = await commands.cancelDownload(modelId);
        if (result.status === "ok") {
          set(
            produce((state) => {
              delete state.downloadingModels[modelId];
              delete state.downloadProgress[modelId];
            }),
          );

          // Reload models to sync with backend state
          await get().loadModels();
          return true;
        } else {
          set({ error: `Failed to cancel download: ${result.error}` });
          return false;
        }
      } catch (err) {
        set({ error: `Failed to cancel download: ${err}` });
        return false;
      }
    },

    deleteModel: async (modelId: string) => {
      try {
        set({ error: null });
        const result = await commands.deleteModel(modelId);
        if (result.status === "ok") {
          await get().loadModels();
          await get().loadCurrentModel();
          return true;
        } else {
          set({ error: `Failed to delete model: ${result.error}` });
          return false;
        }
      } catch (err) {
        set({ error: `Failed to delete model: ${err}` });
        return false;
      }
    },

    getModelInfo: (modelId: string) => {
      return get().models.find((model) => model.id === modelId);
    },

    isModelDownloading: (modelId: string) => {
      return modelId in get().downloadingModels;
    },

    isModelVerifying: (modelId: string) => {
      return modelId in get().verifyingModels;
    },

    getDownloadProgress: (modelId: string) => {
      return get().downloadProgress[modelId];
    },

    initialize: async () => {
      if (get().initialized) return;

      const { loadModels, loadCurrentModel } = get();

      // Load initial data
      await Promise.all([loadModels(), loadCurrentModel()]);

      // Set up event listeners
      listen<DownloadProgress>("model-download-progress", (event) => {
        const progress = event.payload;
        set(
          produce((state) => {
            state.downloadProgress[progress.model_id] = progress;
          }),
        );
      });

      listen<string>("model-download-complete", (event) => {
        const modelId = event.payload;
        set(
          produce((state) => {
            delete state.downloadingModels[modelId];
            delete state.verifyingModels[modelId];
            delete state.downloadProgress[modelId];
          }),
        );
        get().loadModels();
      });

      listen<{ model_id: string; error: string }>(
        "model-download-failed",
        (event) => {
          const { model_id: modelId, error } = event.payload;
          set(
            produce((state) => {
              delete state.downloadingModels[modelId];
              delete state.verifyingModels[modelId];
              delete state.downloadProgress[modelId];
              state.error = error;
            }),
          );
          notify({
            title: i18n.t("errors.modelDownloadFailed"),
            detail: error,
            key: downloadNoticeKey(modelId),
          });
        },
      );

      listen<string>("model-verification-started", (event) => {
        const modelId = event.payload;
        set(
          produce((state) => {
            state.verifyingModels[modelId] = true;
          }),
        );
      });

      listen<string>("model-verification-completed", (event) => {
        const modelId = event.payload;
        set(
          produce((state) => {
            delete state.verifyingModels[modelId];
          }),
        );
      });

      listen<string>("model-download-cancelled", (event) => {
        const modelId = event.payload;
        set(
          produce((state) => {
            delete state.downloadingModels[modelId];
            delete state.verifyingModels[modelId];
            delete state.downloadProgress[modelId];
          }),
        );
      });

      listen<string>("model-deleted", () => {
        get().loadModels();
        get().loadCurrentModel();
      });

      listen("model-state-changed", () => {
        get().loadModels();
        get().loadCurrentModel();
      });

      listen("models-updated", () => {
        get().loadModels();
        get().loadCurrentModel();
      });

      set({ initialized: true });
    },
  })),
);