@makefinks/daemon 0.1.0

package/src/hooks/use-app-model.ts

@@ -0,0 +1,123 @@
+import { useMemo, useState } from "react";
+import { AVAILABLE_MODELS, DEFAULT_MODEL_ID } from "../ai/model-config";
+import { mergePricingAverages } from "../utils/openrouter-pricing";
+import { useAppModelPricingLoader } from "./use-app-model-pricing-loader";
+import { useAppOpenRouterModelsLoader } from "./use-app-openrouter-models-loader";
+import { useAppOpenRouterProviderLoader } from "./use-app-openrouter-provider-loader";
+import type { ModelOption } from "../types";
+import type { ProviderMenuItem } from "../components/ProviderMenu";
+import type { OpenRouterInferenceProvider } from "../utils/openrouter-endpoints";
+
+export interface UseAppModelParams {
+	preferencesLoaded: boolean;
+	showProviderMenu: boolean;
+}
+
+export interface UseAppModelReturn {
+	currentModelId: string;
+	setCurrentModelId: React.Dispatch<React.SetStateAction<string>>;
+
+	currentOpenRouterProviderTag: string | undefined;
+	setCurrentOpenRouterProviderTag: React.Dispatch<React.SetStateAction<string | undefined>>;
+
+	modelsWithPricing: ModelOption[];
+	openRouterModels: ModelOption[];
+	openRouterModelsLoading: boolean;
+	openRouterModelsUpdatedAt: number | null;
+
+	providerMenuItems: ProviderMenuItem[];
+
+	refreshOpenRouterModels: () => void;
+}
+
+export function useAppModel(params: UseAppModelParams): UseAppModelReturn {
+	const { preferencesLoaded, showProviderMenu } = params;
+
+	const [currentModelId, setCurrentModelId] = useState(DEFAULT_MODEL_ID);
+	const [currentOpenRouterProviderTag, setCurrentOpenRouterProviderTag] = useState<string | undefined>(
+		undefined
+	);
+	const [modelsWithPricing, setModelsWithPricing] = useState<ModelOption[]>(AVAILABLE_MODELS);
+	const [openRouterModels, setOpenRouterModels] = useState<ModelOption[]>([]);
+	const [openRouterModelsLoading, setOpenRouterModelsLoading] = useState(false);
+	const [openRouterModelsUpdatedAt, setOpenRouterModelsUpdatedAt] = useState<number | null>(null);
+	const [openRouterProviders, setOpenRouterProviders] = useState<OpenRouterInferenceProvider[]>([]);
+
+	useAppModelPricingLoader({
+		preferencesLoaded,
+		setModelsWithPricing,
+	});
+
+	useAppOpenRouterProviderLoader({
+		preferencesLoaded,
+		showProviderMenu,
+		modelId: currentModelId,
+		setProviders: setOpenRouterProviders,
+	});
+
+	const { refresh: refreshOpenRouterModels } = useAppOpenRouterModelsLoader({
+		preferencesLoaded,
+		setModels: setOpenRouterModels,
+		setLoading: setOpenRouterModelsLoading,
+		setUpdatedAt: setOpenRouterModelsUpdatedAt,
+	});
+
+	const providerMenuItems: ProviderMenuItem[] = useMemo(() => {
+		const pricingCandidates = openRouterProviders
+			.map((p) => p.pricing)
+			.filter((p): p is NonNullable<typeof p> => Boolean(p));
+		const avgPricing = pricingCandidates.length > 0 ? mergePricingAverages(pricingCandidates) : undefined;
+
+		const maxContextLength = openRouterProviders.reduce((max, p) => {
+			const value = typeof p.contextLength === "number" ? p.contextLength : 0;
+			return Math.max(max, value);
+		}, 0);
+
+		const anyCaching = openRouterProviders.some((p) => p.supportsCaching);
+
+		const items: ProviderMenuItem[] = [
+			{
+				tag: null,
+				label: "AUTO (OpenRouter routing)",
+				contextLength: maxContextLength || undefined,
+				pricing: avgPricing,
+				supportsCaching: anyCaching || undefined,
+			},
+		];
+
+		const knownProviderTags = new Set<string>();
+		for (const provider of openRouterProviders) {
+			knownProviderTags.add(provider.tag);
+			items.push({
+				tag: provider.tag,
+				label: `${provider.providerName} (${provider.tag})`,
+				contextLength: provider.contextLength,
+				pricing: provider.pricing,
+				supportsCaching: provider.supportsCaching,
+			});
+		}
+
+		if (currentOpenRouterProviderTag && !knownProviderTags.has(currentOpenRouterProviderTag)) {
+			items.splice(1, 0, {
+				tag: currentOpenRouterProviderTag,
+				label: `SAVED (${currentOpenRouterProviderTag})`,
+				supportsCaching: false,
+			});
+		}
+
+		return items;
+	}, [openRouterProviders, currentOpenRouterProviderTag]);
+
+	return {
+		currentModelId,
+		setCurrentModelId,
+		currentOpenRouterProviderTag,
+		setCurrentOpenRouterProviderTag,
+		modelsWithPricing,
+		openRouterModels,
+		openRouterModelsLoading,
+		openRouterModelsUpdatedAt,
+		providerMenuItems,
+		refreshOpenRouterModels,
+	};
+}

package/src/hooks/use-app-openrouter-models-loader.ts

@@ -0,0 +1,44 @@
+import { useCallback, useEffect } from "react";
+import type { ModelOption } from "../types";
+import { getOpenRouterModels } from "../utils/openrouter-models";
+
+export interface UseAppOpenRouterModelsLoaderParams {
+	preferencesLoaded: boolean;
+	setModels: React.Dispatch<React.SetStateAction<ModelOption[]>>;
+	setLoading: React.Dispatch<React.SetStateAction<boolean>>;
+	setUpdatedAt: React.Dispatch<React.SetStateAction<number | null>>;
+}
+
+export interface UseAppOpenRouterModelsLoaderResult {
+	refresh: () => Promise<void>;
+}
+
+export function useAppOpenRouterModelsLoader(
+	params: UseAppOpenRouterModelsLoaderParams
+): UseAppOpenRouterModelsLoaderResult {
+	const { preferencesLoaded, setModels, setLoading, setUpdatedAt } = params;
+
+	const refresh = useCallback(
+		async (forceRefresh = false) => {
+			if (!preferencesLoaded) return;
+			setLoading(true);
+			try {
+				const result = await getOpenRouterModels({ forceRefresh });
+				setModels(result.models);
+				setUpdatedAt(result.timestamp);
+			} finally {
+				setLoading(false);
+			}
+		},
+		[preferencesLoaded, setLoading, setModels, setUpdatedAt]
+	);
+
+	useEffect(() => {
+		if (!preferencesLoaded) return;
+		void refresh(false);
+	}, [preferencesLoaded, refresh]);
+
+	return {
+		refresh: () => refresh(true),
+	};
+}

package/src/hooks/use-app-openrouter-provider-loader.ts

@@ -0,0 +1,35 @@
+import { useEffect } from "react";
+import type { OpenRouterInferenceProvider } from "../utils/openrouter-endpoints";
+import { getOpenRouterModelProviders } from "../utils/openrouter-endpoints";
+
+export interface UseAppOpenRouterProviderLoaderParams {
+	preferencesLoaded: boolean;
+	showProviderMenu: boolean;
+	modelId: string;
+	setProviders: React.Dispatch<React.SetStateAction<OpenRouterInferenceProvider[]>>;
+}
+
+export function useAppOpenRouterProviderLoader(params: UseAppOpenRouterProviderLoaderParams): void {
+	const { preferencesLoaded, showProviderMenu, modelId, setProviders } = params;
+
+	useEffect(() => {
+		if (!preferencesLoaded) return;
+		if (!showProviderMenu) return;
+
+		let cancelled = false;
+
+		(async () => {
+			try {
+				const providers = await getOpenRouterModelProviders(modelId);
+				if (cancelled) return;
+				setProviders(providers);
+			} catch (_err: unknown) {
+				// Silently fail - provider menu will just show no providers.
+			}
+		})();
+
+		return () => {
+			cancelled = true;
+		};
+	}, [preferencesLoaded, showProviderMenu, modelId, setProviders]);
+}

package/src/hooks/use-app-preferences-bootstrap.ts

@@ -0,0 +1,212 @@
+import { useCallback, useEffect, useRef } from "react";
+import { AVAILABLE_MODELS, setOpenRouterProviderTag, setResponseModel } from "../ai/model-config";
+import type {
+	AppPreferences,
+	BashApprovalLevel,
+	OnboardingStep,
+	ReasoningEffort,
+	SpeechSpeed,
+	VoiceInteractionType,
+} from "../types";
+import { loadPreferences, updatePreferences } from "../utils/preferences";
+import { setAudioDevice } from "../voice/audio-recorder";
+
+export interface UseAppPreferencesBootstrapParams {
+	manager: {
+		interactionMode: "text" | "voice";
+		voiceInteractionType: VoiceInteractionType;
+		speechSpeed: SpeechSpeed;
+		reasoningEffort: ReasoningEffort;
+		bashApprovalLevel: BashApprovalLevel;
+		audioDeviceName?: string;
+		outputDeviceName?: string;
+	};
+	setCurrentModelId: (modelId: string) => void;
+	setCurrentOpenRouterProviderTag: (providerTag: string | undefined) => void;
+	setCurrentDevice: (deviceName: string | undefined) => void;
+	setCurrentOutputDevice: (deviceName: string | undefined) => void;
+	setInteractionMode: (mode: "text" | "voice") => void;
+	setVoiceInteractionType: (type: VoiceInteractionType) => void;
+	setSpeechSpeed: (speed: SpeechSpeed) => void;
+	setReasoningEffort: (effort: ReasoningEffort) => void;
+	setBashApprovalLevel: (level: BashApprovalLevel) => void;
+	setShowFullReasoning: (show: boolean) => void;
+	setShowToolOutput: (show: boolean) => void;
+	setLoadedPreferences: (prefs: AppPreferences | null) => void;
+	setOnboardingActive: (active: boolean) => void;
+	setOnboardingStep: (step: OnboardingStep) => void;
+	setPreferencesLoaded: (loaded: boolean) => void;
+}
+
+export interface UseAppPreferencesBootstrapReturn {
+	persistPreferences: (updates: Partial<AppPreferences>) => void;
+}
+
+export function useAppPreferencesBootstrap(
+	params: UseAppPreferencesBootstrapParams
+): UseAppPreferencesBootstrapReturn {
+	const {
+		manager,
+		setCurrentModelId,
+		setCurrentOpenRouterProviderTag,
+		setCurrentDevice,
+		setCurrentOutputDevice,
+		setInteractionMode,
+		setVoiceInteractionType,
+		setSpeechSpeed,
+		setReasoningEffort,
+		setBashApprovalLevel,
+		setShowFullReasoning,
+		setShowToolOutput,
+		setLoadedPreferences,
+		setOnboardingActive,
+		setOnboardingStep,
+		setPreferencesLoaded,
+	} = params;
+
+	const preferencesWriteRef = useRef<Promise<AppPreferences | null>>(Promise.resolve(null));
+
+	const persistPreferences = useCallback((updates: Partial<AppPreferences>) => {
+		preferencesWriteRef.current = preferencesWriteRef.current
+			.catch(() => null)
+			.then(() => updatePreferences(updates))
+			.catch(() => null);
+	}, []);
+
+	useEffect(() => {
+		let cancelled = false;
+
+		(async () => {
+			const prefs = await loadPreferences();
+			if (cancelled) return;
+
+			if (prefs?.openRouterApiKey && !process.env.OPENROUTER_API_KEY) {
+				process.env.OPENROUTER_API_KEY = prefs.openRouterApiKey;
+			}
+			if (prefs?.openAiApiKey && !process.env.OPENAI_API_KEY) {
+				process.env.OPENAI_API_KEY = prefs.openAiApiKey;
+			}
+			if (prefs?.exaApiKey && !process.env.EXA_API_KEY) {
+				process.env.EXA_API_KEY = prefs.exaApiKey;
+			}
+
+			if (prefs?.modelId) {
+				const modelIdx = AVAILABLE_MODELS.findIndex((m) => m.id === prefs.modelId);
+				if (modelIdx >= 0) {
+					setResponseModel(prefs.modelId);
+					setCurrentModelId(prefs.modelId);
+				}
+			}
+
+			if (prefs?.openRouterProviderTag) {
+				setOpenRouterProviderTag(prefs.openRouterProviderTag);
+				setCurrentOpenRouterProviderTag(prefs.openRouterProviderTag);
+			} else {
+				setOpenRouterProviderTag(undefined);
+				setCurrentOpenRouterProviderTag(undefined);
+			}
+
+			if (prefs?.audioDeviceName) {
+				manager.audioDeviceName = prefs.audioDeviceName;
+				setAudioDevice(prefs.audioDeviceName);
+				setCurrentDevice(prefs.audioDeviceName);
+			}
+
+			if (prefs?.audioOutputDeviceName) {
+				manager.outputDeviceName = prefs.audioOutputDeviceName;
+				setCurrentOutputDevice(prefs.audioOutputDeviceName);
+			}
+
+			if (prefs?.interactionMode) {
+				manager.interactionMode = prefs.interactionMode;
+				setInteractionMode(prefs.interactionMode);
+			}
+
+			if (prefs?.voiceInteractionType) {
+				manager.voiceInteractionType = prefs.voiceInteractionType;
+				setVoiceInteractionType(prefs.voiceInteractionType);
+			}
+
+			if (prefs?.speechSpeed) {
+				manager.speechSpeed = prefs.speechSpeed;
+				setSpeechSpeed(prefs.speechSpeed);
+			}
+
+			if (prefs?.reasoningEffort) {
+				manager.reasoningEffort = prefs.reasoningEffort;
+				setReasoningEffort(prefs.reasoningEffort);
+			}
+
+			if (prefs?.bashApprovalLevel) {
+				manager.bashApprovalLevel = prefs.bashApprovalLevel;
+				setBashApprovalLevel(prefs.bashApprovalLevel);
+			}
+
+			if (prefs?.showFullReasoning !== undefined) {
+				setShowFullReasoning(prefs.showFullReasoning);
+			}
+			if (prefs?.showToolOutput !== undefined) {
+				setShowToolOutput(prefs.showToolOutput);
+			}
+
+			const hasOpenRouterKey = Boolean(process.env.OPENROUTER_API_KEY);
+			const hasOpenAiKey = Boolean(process.env.OPENAI_API_KEY);
+			const hasExaKey = Boolean(process.env.EXA_API_KEY);
+			const hasCoreSettings = Boolean(prefs?.audioDeviceName && prefs?.modelId);
+
+			setLoadedPreferences(prefs);
+
+			const isFreshLaunch = prefs === null;
+			const needsOnboarding = !hasOpenRouterKey || !hasOpenAiKey || !hasExaKey;
+
+			if (isFreshLaunch) {
+				setOnboardingStep("intro");
+				setOnboardingActive(true);
+			} else if (needsOnboarding) {
+				let startStep: OnboardingStep = "intro";
+				if (!hasOpenRouterKey) {
+					startStep = "openrouter_key";
+				} else if (!hasOpenAiKey) {
+					startStep = "openai_key";
+				} else if (!hasExaKey) {
+					startStep = "exa_key";
+				}
+				setOnboardingStep(startStep);
+				setOnboardingActive(true);
+			} else if (!prefs?.onboardingCompleted && !hasCoreSettings) {
+				setOnboardingStep("device");
+				setOnboardingActive(true);
+			} else {
+				setOnboardingActive(false);
+				setOnboardingStep("complete");
+			}
+
+			setPreferencesLoaded(true);
+		})();
+
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		manager,
+		setCurrentModelId,
+		setCurrentOpenRouterProviderTag,
+		setCurrentDevice,
+		setCurrentOutputDevice,
+		setInteractionMode,
+		setVoiceInteractionType,
+		setSpeechSpeed,
+		setReasoningEffort,
+		setBashApprovalLevel,
+		setShowFullReasoning,
+		setShowToolOutput,
+		setLoadedPreferences,
+		setOnboardingActive,
+		setOnboardingStep,
+		setPreferencesLoaded,
+	]);
+
+	return {
+		persistPreferences,
+	};
+}

package/src/hooks/use-app-sessions.ts

@@ -0,0 +1,105 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { generateSessionTitle } from "../ai/daemon-ai";
+import { createSession, listSessions, updateSessionTitle } from "../state/session-store";
+import type { SessionInfo } from "../types";
+
+export interface UseAppSessionsParams {
+	showSessionMenu: boolean;
+}
+
+export interface UseAppSessionsReturn {
+	currentSessionId: string | null;
+	setCurrentSessionIdSafe: (nextSessionId: string | null) => void;
+	currentSessionIdRef: React.RefObject<string | null>;
+	ensureSessionId: () => Promise<string>;
+
+	sessions: SessionInfo[];
+	setSessions: React.Dispatch<React.SetStateAction<SessionInfo[]>>;
+
+	sessionCreateRef: React.RefObject<Promise<SessionInfo> | null>;
+
+	sessionMenuItems: Array<SessionInfo & { isNew: boolean }>;
+
+	handleFirstMessage: (targetSessionId: string, message: string) => void;
+}
+
+export function useAppSessions(params: UseAppSessionsParams): UseAppSessionsReturn {
+	const { showSessionMenu } = params;
+
+	const [currentSessionId, setCurrentSessionId] = useState<string | null>(null);
+	const currentSessionIdRef = useRef<string | null>(null);
+	const [sessions, setSessions] = useState<SessionInfo[]>([]);
+	const sessionCreateRef = useRef<Promise<SessionInfo> | null>(null);
+
+	const setCurrentSessionIdSafe = useCallback((nextSessionId: string | null) => {
+		currentSessionIdRef.current = nextSessionId;
+		setCurrentSessionId(nextSessionId);
+	}, []);
+
+	useEffect(() => {
+		currentSessionIdRef.current = currentSessionId;
+	}, [currentSessionId]);
+
+	const ensureSessionId = useCallback(async (): Promise<string> => {
+		if (currentSessionIdRef.current) return currentSessionIdRef.current;
+		if (!sessionCreateRef.current) {
+			sessionCreateRef.current = createSession()
+				.then((session) => {
+					setCurrentSessionIdSafe(session.id);
+					setSessions((prev) => [session, ...prev]);
+					return session;
+				})
+				.finally(() => {
+					sessionCreateRef.current = null;
+				});
+		}
+		const session = await sessionCreateRef.current;
+		currentSessionIdRef.current = session.id;
+		return session.id;
+	}, [setCurrentSessionIdSafe]);
+
+	const sessionMenuItems = useMemo(() => {
+		return sessions.map((session) => ({
+			...session,
+			isNew: false,
+		}));
+	}, [sessions]);
+
+	useEffect(() => {
+		if (!showSessionMenu) return;
+		let cancelled = false;
+
+		(async () => {
+			const list = await listSessions();
+			if (cancelled) return;
+			setSessions(list);
+			const currentIdx = currentSessionIdRef.current
+				? list.findIndex((session) => session.id === currentSessionIdRef.current)
+				: -1;
+		})();
+
+		return () => {
+			cancelled = true;
+		};
+	}, [showSessionMenu]);
+
+	const handleFirstMessage = useCallback((targetSessionId: string, message: string) => {
+		void (async () => {
+			const title = await generateSessionTitle(message);
+			await updateSessionTitle(targetSessionId, title);
+			setSessions((prev) => prev.map((s) => (s.id === targetSessionId ? { ...s, title } : s)));
+		})();
+	}, []);
+
+	return {
+		currentSessionId,
+		setCurrentSessionIdSafe,
+		currentSessionIdRef,
+		ensureSessionId,
+		sessions,
+		setSessions,
+		sessionCreateRef,
+		sessionMenuItems,
+		handleFirstMessage,
+	};
+}

package/src/hooks/use-app-settings.ts

@@ -0,0 +1,62 @@
+import { useState } from "react";
+import { getDaemonManager } from "../state/daemon-state";
+import type { BashApprovalLevel, ReasoningEffort, SpeechSpeed, VoiceInteractionType } from "../types";
+
+export interface UseAppSettingsReturn {
+	interactionMode: "text" | "voice";
+	setInteractionMode: React.Dispatch<React.SetStateAction<"text" | "voice">>;
+
+	voiceInteractionType: VoiceInteractionType;
+	setVoiceInteractionType: React.Dispatch<React.SetStateAction<VoiceInteractionType>>;
+
+	speechSpeed: SpeechSpeed;
+	setSpeechSpeed: React.Dispatch<React.SetStateAction<SpeechSpeed>>;
+
+	reasoningEffort: ReasoningEffort;
+	setReasoningEffort: React.Dispatch<React.SetStateAction<ReasoningEffort>>;
+
+	bashApprovalLevel: BashApprovalLevel;
+	setBashApprovalLevel: React.Dispatch<React.SetStateAction<BashApprovalLevel>>;
+
+	showFullReasoning: boolean;
+	setShowFullReasoning: React.Dispatch<React.SetStateAction<boolean>>;
+
+	showToolOutput: boolean;
+	setShowToolOutput: React.Dispatch<React.SetStateAction<boolean>>;
+
+	canEnableVoiceOutput: boolean;
+}
+
+export function useAppSettings(): UseAppSettingsReturn {
+	const manager = getDaemonManager();
+
+	const [interactionMode, setInteractionMode] = useState(manager.interactionMode);
+	const [voiceInteractionType, setVoiceInteractionType] = useState(manager.voiceInteractionType);
+	const [speechSpeed, setSpeechSpeed] = useState<SpeechSpeed>(manager.speechSpeed);
+	const [reasoningEffort, setReasoningEffort] = useState<ReasoningEffort>(manager.reasoningEffort);
+	const [bashApprovalLevel, setBashApprovalLevel] = useState<BashApprovalLevel>(
+		manager.bashApprovalLevel ?? "dangerous"
+	);
+	const [showFullReasoning, setShowFullReasoning] = useState(true);
+	const [showToolOutput, setShowToolOutput] = useState(false);
+
+	const canEnableVoiceOutput = Boolean(process.env.OPENAI_API_KEY);
+
+	return {
+		interactionMode,
+		setInteractionMode,
+		voiceInteractionType,
+		setVoiceInteractionType,
+		speechSpeed,
+		setSpeechSpeed,
+		reasoningEffort,
+		setReasoningEffort,
+		bashApprovalLevel,
+		setBashApprovalLevel,
+		showFullReasoning,
+		setShowFullReasoning,
+		showToolOutput,
+		setShowToolOutput,
+		canEnableVoiceOutput,
+	};
+}