Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

3.8 KB
Raw Blame
import { useCallback, useEffect, useRef, useState } from 'react';

import type { DependenciesResult, DependencyItem, DependencyReadOptions } from '@/context/ApiContext';
import { isApiFetchDeadlineAbort } from '@/lib/apiFetch';
import { dependenciesNeedAutomaticRefresh } from './SettingsDependenciesPage.logic';

// Coupled rows use one inspection, including its failure evidence.
export const DEPENDENCY_CHECK_GROUPS = [
  ['askill'],
  ['avault'],
  ['show-runtime', 'node'],
  ['model-hub-engine'],
  ['tmux'],
] as const;

export type DependencyCheck = {
  data: DependencyItem | null;
  checking: boolean;
  error: 'failed' | 'timeout' | null;
  reconciling?: boolean;
  reconcilingDependencies?: ReadonlySet<string>;
};

type ReadDependencies = (options?: DependencyReadOptions) => Promise<DependenciesResult>;

export function useDependencyChecks(read: ReadDependencies) {
  const [checks, setChecks] = useState<Record<string, DependencyCheck>>(() => Object.fromEntries(
    DEPENDENCY_CHECK_GROUPS.flatMap((ids) => ids.map((id) => [
      id, { data: null, checking: true, error: null },
    ])),
  ));
  const requests = useRef(new Map<string, AbortController>());
  const [loginSessionState, setLoginSessionState] = useState<DependenciesResult['login_session_state']>(undefined);
  const timers = useRef(new Map<string, ReturnType<typeof setTimeout>>());

  useEffect(() => {
    const active = requests.current;
    const scheduled = timers.current;
    return () => {
      for (const request of active.values()) request.abort();
      active.clear();
      for (const timer of scheduled.values()) clearTimeout(timer);
      scheduled.clear();
    };
  }, []);

  const refresh = useCallback(async (dependencyId?: string, allowInitialRetry = true) => {
    const groups = DEPENDENCY_CHECK_GROUPS.filter((ids) => (
      dependencyId === undefined || ids.some((id) => id === dependencyId)
    ));
    await Promise.all(groups.map(async (ids) => {
      const key = ids[0];
      requests.current.get(key)?.abort();
      clearTimeout(timers.current.get(key));
      timers.current.delete(key);
      const controller = new AbortController();
      requests.current.set(key, controller);
      const update = (change: (previous: DependencyCheck, id: string) => DependencyCheck) => {
        setChecks((previous) => {
          if (requests.current.get(key) !== controller || controller.signal.aborted) return previous;
          return { ...previous, ...Object.fromEntries(ids.map((id) => [id, change(previous[id], id)])) };
        });
      };
      update((previous) => ({ ...previous, checking: true }));
      try {
        const result = await read({ ids, signal: controller.signal });
        if (!result.ok || !Array.isArray(result.deps) || ids.some((id) => !result.deps.some((dep) => dep.id === id))) {
          throw new Error('Incomplete dependency inspection');
        }
        setLoginSessionState(result.login_session_state);
        const byId = new Map(result.deps.map((dep) => [dep.id, dep]));
        update((_previous, id) => ({
          data: byId.get(id)!, checking: false, error: null,
          reconciling: result.reconciling,
          reconcilingDependencies: result.reconciling_dependencies
            ? new Set(result.reconciling_dependencies) : undefined,
        }));
        if (requests.current.get(key) === controller && !controller.signal.aborted
          && dependenciesNeedAutomaticRefresh(result, allowInitialRetry)) {
          timers.current.set(key, setTimeout(() => void refresh(key, false), 1_500));
        }
      } catch (error) {
        update((previous) => ({
          ...previous,
          checking: false,
          error: isApiFetchDeadlineAbort(error) ? 'timeout' : 'failed',
        }));
      }
    }));
  }, [read]);

  return { checks, refresh, checking: Object.values(checks).some((check) => check.checking), loginSessionState };
}