@openpalm/ui 0.12.52 → 0.13.0-beta.1

package/build/server/chunks/_server.ts-CYY3W2qh.js

@@ -0,0 +1,715 @@
+import { aE as readStackEnv, c as annotateAddonProfileAvailability, a5 as getAddonProfiles, a4 as getAddonProfileSelection, b as addonProfileId, bc as writeVoiceVars, am as listEnabledAddonIds, F as composeStop, n as buildComposeOptions, a_ as setAddonProfileSelection, aZ as setAddonEnabled, a3 as getAddonProfileAvailability, Y as dockerHasNvidiaRuntime, U as detectRootlessDocker, $ as execFileNoThrow, a$ as stackDirFor, e as applyStack } from './src-CS2sSYOR.js';
+import { g as getState } from './state-BRh7vs9j.js';
+import { d as getRequestId, l as requireCapability, r as requireAdmin, k as jsonResponse, e as errorResponse } from './helpers-7BvhniSt.js';
+import { w as withSerialQueue } from './serial-queue-D9FEpYVv.js';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { connect } from 'node:net';
+import './provider-constants-1s1k8kbj.js';
+import './chunk-CLZ62Ad-.js';
+import 'node:module';
+import 'node:child_process';
+import 'buffer';
+import 'node:url';
+import 'node:os';
+import 'node:crypto';
+import 'events';
+import 'fs';
+import 'node:events';
+import 'node:stream';
+import 'node:string_decoder';
+import 'path';
+import 'assert';
+import 'zlib';
+import 'node:assert';
+import 'node:fs/promises';
+import './endpoints-CU3ehglV.js';
+import './features-DLGlNjZX.js';
+
+//#region src/lib/server/voice-errors.ts
+/**
+* Translate raw docker / compose stderr into operator-actionable copy.
+*
+* Lives in $lib/server so the route can import it without violating
+* SvelteKit's +server.ts export rules (handlers + `_`-prefixed only).
+*
+* Pattern matches are intentionally case-insensitive and tolerant of
+* compose-CLI prefix decoration. Order matters: more specific patterns
+* first.
+*/
+function translateDockerError(stderr) {
+	const raw = (stderr ?? "").trim();
+	if (!raw) return "Docker reported an unknown error (no stderr).";
+	if (/spawn .*docker.*ENOENT|no such file or directory.*docker|docker:\s*command not found/i.test(raw)) return "Docker isn't installed on this host. Install Docker Engine or Docker Desktop, then retry.";
+	if (/pull access denied|manifest unknown|repository does not exist|not found: manifest unknown/i.test(raw)) return "The voice image for this profile isn't published yet. Try the CPU profile.";
+	if (/failed to resolve reference|dial tcp.*lookup .+docker\.io|i\/o timeout.*registry|connection refused.*registry/i.test(raw)) return "Can't reach Docker Hub. Check your internet connection, corporate firewall, or configure a registry mirror.";
+	if (/no space left on device|insufficient.*disk space|ENOSPC|write.*disk full/i.test(raw)) return "Out of disk space. Free space and try again, or run `docker image prune -a` to reclaim unused images.";
+	if (/port is already allocated|bind.*address already in use|address already in use|failed to bind host port/i.test(raw)) return "Port 8880 is already in use on this host. Free it or change the host port (set OP_VOICE_PORT_HOST).";
+	if (/unknown[^\n]*runtime[^\n]*nvidia|runtime\s+"nvidia"\s+not\s+found|nvidia.*runtime.*not[^a-z]+(found|registered)/i.test(raw)) return "The NVIDIA Docker runtime isn't registered on this machine. Try the CPU profile, or install nvidia-container-toolkit.";
+	if (/invoking the NVIDIA Container Runtime Hook/i.test(raw)) return "Docker is in CDI mode but no CDI spec is registered. Try the CPU profile.";
+	return raw.length > 300 ? `${raw.slice(0, 297)}…` : raw;
+}
+//#endregion
+//#region src/lib/server/voice/bring-up.ts
+/**
+* Voice addon bring-up engine — the Docker/compose infrastructure behind
+* PUT /admin/voice. Extracted from the route so the HTTP handler stays a
+* thin request-validation + delegation layer (mirrors the
+* lib/server/endpoints.ts ↔ admin/endpoints/+server.ts split).
+*
+* Responsibilities:
+*   - Docker image inspection + resolution (dockerImagePresent / resolveServiceImage)
+*   - UI-local host probes (TCP port, container health) — the rootless /
+*     nvidia-runtime host-fact probes live in lib (control-plane/voice-host-probes.ts)
+*     beside hardware-detect.ts, since they inspect the host, not addon/UI state.
+*   - Fallback-overlay SELECTION only: voice.compose.cdi.yml and
+*     voice.compose.rootless.yml ship as static files in the skeleton's
+*     managed system/stack/ tree (packages/skeleton/system/stack/) — nothing
+*     here generates compose YAML.
+*   - The in-memory background-job registry (activeJobs)
+*   - The engageVoiceAddon orchestration that the route delegates to; the
+*     actual compose-up + health-wait lifecycle (runBringUp) is a thin
+*     shim over `@openpalm/lib`'s single `applyStack` driver (plan 2.2) —
+*     this file keeps only job registry + progress-step rendering, plus the
+*     "warming" re-probe and voice-specific error-copy translation that
+*     applyStack's generic result doesn't carry.
+*
+* Everything here is server-only (uses node:child_process / node:net /
+* node:fs) and returns plain data — the route maps the results to HTTP
+* responses.
+*/
+var VOICE_ADDON = "voice";
+var VOICE_PROBE_TIMEOUT_MS = 18e4;
+var PORT_PROBE_TIMEOUT_MS = 750;
+var JOB_RETAIN_MS = 5 * 6e4;
+var activeJobs = /* @__PURE__ */ new Map();
+function setJob(addon, patch) {
+	const existing = activeJobs.get(addon);
+	const next = existing ? {
+		...existing,
+		...patch
+	} : {
+		state: "pulling",
+		steps: [],
+		startedAt: Date.now(),
+		...patch
+	};
+	activeJobs.set(addon, next);
+	return next;
+}
+function getActiveJob(addon) {
+	const job = activeJobs.get(addon);
+	if (!job) return void 0;
+	if (Date.now() - (job.finishedAt ?? job.startedAt) > JOB_RETAIN_MS) {
+		activeJobs.delete(addon);
+		return;
+	}
+	return job;
+}
+/**
+* Pick the best profile for this host. Prefers the first available GPU
+* profile (anything that isn't the canonical CPU profile) so operators with NVIDIA/AMD hardware
+* get the accelerated variant auto-selected. Falls back to the labelled
+* default, then first available, then first profile.
+*/
+function resolveDefaultProfile(profiles) {
+	if (profiles.length === 0) return null;
+	const availableGpu = profiles.find((p) => p.id !== addonProfileId("voice", "cpu") && p.available !== false);
+	if (availableGpu) return availableGpu.id;
+	const labelledDefault = profiles.find((p) => p.default);
+	if (labelledDefault && labelledDefault.available !== false) return labelledDefault.id;
+	const firstAvailable = profiles.find((p) => p.available !== false);
+	if (firstAvailable) return firstAvailable.id;
+	return profiles[0].id;
+}
+function voiceHostPort() {
+	const raw = process.env.OP_VOICE_PORT_HOST?.trim();
+	const n = raw ? Number(raw) : NaN;
+	return Number.isFinite(n) && n > 0 ? n : 8880;
+}
+function openpalmVoiceBaseURL() {
+	return `http://127.0.0.1:${voiceHostPort()}`;
+}
+/**
+* True when the local docker daemon already has the named image cached.
+* `docker image inspect` exits 0 only when the image is present locally.
+*/
+async function dockerImagePresent(imageRef) {
+	if (!imageRef) return true;
+	return (await execFileNoThrow("docker", [
+		"image",
+		"inspect",
+		imageRef
+	], 5e3)).ok;
+}
+/**
+* Heuristic: image tags that include `-cu121` / `-rocm6` / `-cpu` are the
+* multi-GB voice images. Show the "this may take a few minutes" toast for
+* first pulls so the operator knows the upcoming compose-up isn't stuck.
+*/
+function isLargeImageTag(imageRef) {
+	return /(-cu\d+|-rocm\d+|-cpu)(\s|$|@|\b)/i.test(imageRef);
+}
+function resolveProjectName() {
+	return process.env.OP_PROJECT_NAME?.trim() || process.env.COMPOSE_PROJECT_NAME?.trim() || "openpalm";
+}
+/**
+* Read the resolved image for a service from the merged compose config.
+* Best-effort — returns "" on any failure so callers can skip the pre-pull
+* check rather than blocking save.
+*/
+async function resolveServiceImage(composeFiles, service) {
+	const args = ["compose"];
+	for (const f of composeFiles) args.push("-f", f);
+	args.push("--project-name", resolveProjectName(), "config", "--format", "json");
+	const res = await execFileNoThrow("docker", args, 15e3);
+	if (!res.ok) return "";
+	try {
+		return JSON.parse(res.stdout).services?.[service]?.image ?? "";
+	} catch {
+		return "";
+	}
+}
+/**
+* Probe a TCP port on 127.0.0.1. Resolves true when the connect succeeds
+* within PORT_PROBE_TIMEOUT_MS — meaning something is already listening.
+*/
+function isPortListening(port) {
+	return new Promise((resolve) => {
+		const socket = connect({
+			host: "127.0.0.1",
+			port
+		});
+		let done = false;
+		const finish = (listening) => {
+			if (done) return;
+			done = true;
+			try {
+				socket.destroy();
+			} catch {}
+			resolve(listening);
+		};
+		socket.setTimeout(PORT_PROBE_TIMEOUT_MS, () => finish(false));
+		socket.once("connect", () => finish(true));
+		socket.once("error", () => finish(false));
+	});
+}
+/**
+* True when a docker container whose name matches openpalm-voice* is
+* already running and presumably owns the host port. Used by the port
+* pre-flight to avoid false positives when our own voice container is
+* the listener.
+*/
+async function ourVoiceContainerRunning() {
+	const res = await execFileNoThrow("docker", [
+		"ps",
+		"--filter",
+		"name=openpalm-voice",
+		"--format",
+		"{{.Names}}"
+	], 5e3);
+	if (!res.ok) return false;
+	return res.stdout.trim().length > 0;
+}
+/**
+* Read the Docker healthcheck state of a container.
+* Returns "starting" while compose's start_period grace window is in
+* effect; "healthy" / "unhealthy" / "none" / "" otherwise.
+*/
+async function readContainerHealthStatus(containerNamePrefix) {
+	const name = (await execFileNoThrow("docker", [
+		"ps",
+		"--filter",
+		`name=${containerNamePrefix}`,
+		"--format",
+		"{{.Names}}"
+	], 5e3)).stdout.split("\n").map((s) => s.trim()).find(Boolean);
+	if (!name) return "";
+	return (await execFileNoThrow("docker", [
+		"inspect",
+		name,
+		"--format",
+		"{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}"
+	], 5e3)).stdout.trim();
+}
+/** Path of the static CDI overlay, or null when the managed tree isn't seeded yet. */
+function voiceCdiOverlayPath(homeDir) {
+	const overlayPath = join(stackDirFor(homeDir), "voice.compose.cdi.yml");
+	return existsSync(overlayPath) ? overlayPath : null;
+}
+/** Path of the static rootless overlay, or null when the managed tree isn't seeded yet. */
+function voiceRootlessOverlayPath(homeDir) {
+	const overlayPath = join(stackDirFor(homeDir), "voice.compose.rootless.yml");
+	return existsSync(overlayPath) ? overlayPath : null;
+}
+/**
+* Stops services from OTHER profiles, then routes the actual compose-up +
+* health-wait through `@openpalm/lib`'s single {@link applyStack} driver
+* (plan 2.2) — this function no longer runs its own composeUp or /health
+* poll. `applyStack`'s health-wait reads the SAME docker HEALTHCHECK every
+* voice compose service already declares (`curl .../health` inside the
+* container, `start_period: 180s`), so it observes exactly what the removed
+* manual HTTP poll observed, just via `docker inspect` instead of a
+* host-side fetch loop.
+*
+* Returns the terminal state. Pushed `steps` get mutated in place so the
+* caller (sync or background) can read progress as it happens.
+*/
+async function runBringUp(input) {
+	const { state, services, activeProfile, extraFiles, availableProfiles, steps } = input;
+	let composeOk;
+	let composeErr;
+	let healthy = false;
+	try {
+		const otherProfileServices = availableProfiles.filter((p) => p.id !== activeProfile).flatMap((p) => p.services).filter((svc) => !services.includes(svc));
+		if (otherProfileServices.length > 0) try {
+			await composeStop(otherProfileServices, buildComposeOptions(state));
+		} catch (e) {
+			console.warn("[voice] composeStop other profiles failed:", e);
+		}
+		const baseOpts = buildComposeOptions(state);
+		const result = await applyStack({
+			kind: "services",
+			services
+		}, {
+			files: [...baseOpts.files, ...extraFiles],
+			envFiles: baseOpts.envFiles,
+			profiles: activeProfile ? [activeProfile] : baseOpts.profiles
+		}, void 0, { healthTimeoutMs: VOICE_PROBE_TIMEOUT_MS });
+		if (result.upFailed) {
+			composeOk = false;
+			composeErr = translateDockerError(result.rawStderr || result.error || "compose up failed");
+		} else {
+			composeOk = true;
+			healthy = result.ok;
+		}
+	} catch (e) {
+		composeOk = false;
+		composeErr = translateDockerError(e instanceof Error ? e.message : String(e));
+	}
+	steps.push({
+		step: "compose-up",
+		ok: composeOk,
+		...composeErr ? { detail: composeErr.slice(0, 500) } : {}
+	});
+	if (!composeOk) return {
+		composeOk,
+		composeErr,
+		healthy: false,
+		warming: false,
+		steps
+	};
+	let warming = false;
+	if (!healthy) try {
+		if (await readContainerHealthStatus("openpalm-voice") === "starting") warming = true;
+	} catch {}
+	steps.push({
+		step: "healthy",
+		ok: healthy || warming,
+		...healthy ? {} : warming ? { detail: "still warming up — refresh in a moment" } : { detail: `did not become healthy within ${VOICE_PROBE_TIMEOUT_MS / 1e3}s` }
+	});
+	return {
+		composeOk,
+		healthy,
+		warming,
+		steps
+	};
+}
+/**
+* Background variant: runs runBringUp and persists state transitions
+* into the activeJobs map. Returns nothing — the UI polls GET
+* /admin/voice to observe completion.
+*/
+async function runBringUpJob(input) {
+	const steps = [...input.baseSteps];
+	try {
+		setJob(VOICE_ADDON, {
+			state: "starting",
+			steps
+		});
+		const outcome = await runBringUp({
+			...input,
+			steps
+		});
+		if (!outcome.composeOk) {
+			setJob(VOICE_ADDON, {
+				state: "error",
+				steps: outcome.steps,
+				error: `Voice addon failed to start: ${outcome.composeErr ?? "unknown error"}`,
+				finishedAt: Date.now()
+			});
+			return;
+		}
+		setJob(VOICE_ADDON, {
+			state: outcome.healthy ? "healthy" : outcome.warming ? "starting" : "error",
+			steps: outcome.steps,
+			...outcome.healthy || outcome.warming ? { error: void 0 } : { error: "Voice addon is starting but did not become healthy in time." },
+			finishedAt: Date.now()
+		});
+	} catch (e) {
+		setJob(VOICE_ADDON, {
+			state: "error",
+			steps,
+			error: e instanceof Error ? e.message : String(e),
+			finishedAt: Date.now()
+		});
+	}
+}
+/**
+* The full PUT /admin/voice bring-up lifecycle after request validation:
+* auto-stop when disengaging, else resolve profile → enable addon →
+* port pre-flight → image inspect → host fallback overlays → background
+* short-circuit or synchronous compose-up + /health poll.
+*/
+async function engageVoiceAddon(input) {
+	const { state, wantsVoiceAddon, requestedProfile } = input;
+	if (!wantsVoiceAddon) {
+		if (listEnabledAddonIds(state.homeDir).includes("voice")) try {
+			const voiceServiceNames = getAddonProfiles(state.homeDir, VOICE_ADDON).flatMap((p) => p.services);
+			const unique = Array.from(new Set(voiceServiceNames));
+			if (unique.length > 0) await composeStop(unique, buildComposeOptions(state));
+		} catch (e) {
+			console.warn("[voice] composeStop on disengage failed:", e);
+		}
+		return { status: "disengaged" };
+	}
+	const availableProfiles = await annotateAddonProfileAvailability(getAddonProfiles(state.homeDir, VOICE_ADDON));
+	let activeProfile = null;
+	if (requestedProfile) {
+		if (!availableProfiles.some((p) => p.id === requestedProfile)) return {
+			status: "invalid_profile",
+			message: `Unknown voice profile "${requestedProfile}". Available: ${availableProfiles.map((p) => p.id).join(", ") || "(none)"}`
+		};
+		activeProfile = requestedProfile;
+		setAddonProfileSelection(state.homeDir, VOICE_ADDON, activeProfile);
+	} else activeProfile = getAddonProfileSelection(state.homeDir, "voice") ?? resolveDefaultProfile(availableProfiles);
+	const wasAlreadyEnabled = listEnabledAddonIds(state.homeDir).includes(VOICE_ADDON);
+	const steps = [];
+	if (!wasAlreadyEnabled) try {
+		setAddonEnabled(state.homeDir, VOICE_ADDON, true, state);
+		steps.push({
+			step: "enable",
+			ok: true
+		});
+	} catch (e) {
+		const detail = e instanceof Error ? e.message : String(e);
+		steps.push({
+			step: "enable",
+			ok: false,
+			detail
+		});
+		return {
+			status: "error",
+			wasAlreadyEnabled,
+			steps,
+			error: `Could not enable voice addon: ${detail}`
+		};
+	}
+	else steps.push({
+		step: "enable",
+		ok: true,
+		detail: "already enabled"
+	});
+	const hostPort = voiceHostPort();
+	const inVitest = !!process.env.VITEST;
+	if (inVitest ? false : await isPortListening(hostPort)) {
+		if (!await ourVoiceContainerRunning()) {
+			const msg = translateDockerError(`Bind for 127.0.0.1:${hostPort} failed: port is already allocated`);
+			steps.push({
+				step: "port-check",
+				ok: false,
+				detail: msg
+			});
+			return {
+				status: "error",
+				wasAlreadyEnabled,
+				steps,
+				error: msg
+			};
+		}
+		steps.push({
+			step: "port-check",
+			ok: true,
+			detail: "our container is the listener"
+		});
+	} else steps.push({
+		step: "port-check",
+		ok: true
+	});
+	const profileServices = activeProfile ? availableProfiles.find((p) => p.id === activeProfile)?.services ?? [] : [];
+	const services = profileServices.length > 0 ? profileServices : [VOICE_ADDON];
+	const composeFilesBase = buildComposeOptions(state).files;
+	const primaryService = services[0];
+	let backgroundPull = false;
+	if (primaryService && !inVitest) {
+		const imageRef = await resolveServiceImage(composeFilesBase, primaryService);
+		if (imageRef && isLargeImageTag(imageRef)) {
+			if (!await dockerImagePresent(imageRef)) {
+				backgroundPull = true;
+				steps.push({
+					step: "pulling",
+					ok: true,
+					detail: "first-time download — several minutes for several GB"
+				});
+			}
+		}
+	}
+	const extraFiles = [];
+	const cdiFallbackSupported = process.platform !== "win32";
+	if (activeProfile === addonProfileId("voice", "cuda") && !inVitest && cdiFallbackSupported) {
+		const runtimeMissing = (await getAddonProfileAvailability({ id: addonProfileId("voice", "cuda") })).available === false || !await dockerHasNvidiaRuntime();
+		const cdiSpecPresent = existsSync("/etc/cdi/nvidia.yaml");
+		if (runtimeMissing && cdiSpecPresent) {
+			const overlay = voiceCdiOverlayPath(state.homeDir);
+			if (overlay) {
+				extraFiles.push(overlay);
+				steps.push({
+					step: "cdi-fallback",
+					ok: true,
+					detail: "using CDI device reservation"
+				});
+			}
+		}
+	}
+	if (!inVitest) try {
+		if (await detectRootlessDocker()) {
+			const overlay = voiceRootlessOverlayPath(state.homeDir);
+			if (overlay) {
+				extraFiles.push(overlay);
+				steps.push({
+					step: "rootless-fallback",
+					ok: true,
+					detail: "dropping user: directive for rootless Docker"
+				});
+			}
+		}
+	} catch (e) {
+		console.warn("[voice] rootless detection failed:", e);
+	}
+	if (backgroundPull) {
+		setJob(VOICE_ADDON, {
+			state: "pulling",
+			steps: [...steps],
+			startedAt: Date.now(),
+			profile: activeProfile ?? void 0,
+			finishedAt: void 0,
+			error: void 0
+		});
+		runBringUpJob({
+			state,
+			services,
+			activeProfile,
+			extraFiles,
+			availableProfiles,
+			baseSteps: [...steps]
+		});
+		return {
+			status: "background",
+			wasAlreadyEnabled,
+			steps,
+			message: "Voice image is downloading in the background (~2–8 GB). Poll GET /admin/voice for progress; UI auto-refreshes."
+		};
+	}
+	const outcome = await runBringUp({
+		state,
+		services,
+		activeProfile,
+		extraFiles,
+		availableProfiles,
+		steps
+	});
+	if (!outcome.composeOk) return {
+		status: "error",
+		wasAlreadyEnabled,
+		steps: outcome.steps,
+		error: `Voice addon failed to start: ${outcome.composeErr ?? "unknown error"}`
+	};
+	return {
+		status: "final",
+		wasAlreadyEnabled,
+		steps: outcome.steps,
+		healthy: outcome.healthy,
+		warming: outcome.warming
+	};
+}
+//#endregion
+//#region src/routes/api/host/voice/+server.ts
+var REACHABILITY_TIMEOUT_MS = 1500;
+async function probeReachable(baseURL) {
+	if (!baseURL) return false;
+	const url = `${baseURL.replace(/\/+$/, "")}/v1/models`;
+	try {
+		return (await fetch(url, {
+			method: "GET",
+			signal: AbortSignal.timeout(REACHABILITY_TIMEOUT_MS)
+		})).status < 500;
+	} catch {
+		return false;
+	}
+}
+var GET = async (event) => {
+	const requestId = getRequestId(event);
+	const capabilityError = requireCapability(event, "host:stack:read", requestId);
+	if (capabilityError) return capabilityError;
+	const authError = requireAdmin(event, requestId);
+	if (authError) return authError;
+	const state = getState();
+	const env = readStackEnv(state.homeDir);
+	const ttsBaseURL = env.OP_TTS_BASE_URL ?? "";
+	const sttBaseURL = env.OP_STT_BASE_URL ?? "";
+	const profiles = await annotateAddonProfileAvailability(getAddonProfiles(state.homeDir, VOICE_ADDON));
+	const selectedProfile = getAddonProfileSelection(state.homeDir, "voice") ?? resolveDefaultProfile(profiles);
+	const [sttReachable, ttsReachable] = await Promise.all([probeReachable(sttBaseURL), probeReachable(ttsBaseURL)]);
+	return jsonResponse(200, {
+		tts: {
+			enabled: true,
+			engine: env.OP_TTS_ENGINE ?? "",
+			provider: env.OP_TTS_PROVIDER ?? "",
+			baseURL: ttsBaseURL,
+			model: env.OP_TTS_MODEL ?? "",
+			voice: env.OP_TTS_VOICE ?? ""
+		},
+		stt: {
+			enabled: true,
+			engine: env.OP_STT_ENGINE ?? "",
+			provider: env.OP_STT_PROVIDER ?? "",
+			baseURL: sttBaseURL,
+			model: env.OP_STT_MODEL ?? "",
+			language: env.OP_STT_LANGUAGE ?? ""
+		},
+		availability: {
+			stt: {
+				remoteConfigured: Boolean(sttBaseURL),
+				remoteReachable: sttReachable
+			},
+			tts: {
+				remoteConfigured: Boolean(ttsBaseURL),
+				remoteReachable: ttsReachable
+			}
+		},
+		addon: {
+			profiles,
+			selectedProfile,
+			...getActiveJob("voice") ? { activeJob: getActiveJob(VOICE_ADDON) } : {}
+		}
+	}, requestId);
+};
+function readSection(raw, kind) {
+	if (!raw || typeof raw !== "object") return null;
+	const section = {
+		enabled: raw.enabled !== false,
+		engine: typeof raw.engine === "string" ? raw.engine : void 0,
+		provider: typeof raw.provider === "string" ? raw.provider : void 0,
+		baseURL: typeof raw.baseURL === "string" ? raw.baseURL : void 0,
+		model: typeof raw.model === "string" ? raw.model : void 0
+	};
+	if (kind === "tts" && typeof raw.voice === "string") section.voice = raw.voice;
+	if (kind === "stt" && typeof raw.language === "string") section.language = raw.language;
+	return section;
+}
+var OPENPALM_VOICE_TTS_MODEL = "kokoro";
+var OPENPALM_VOICE_STT_MODEL = "whisper-1";
+var OPENPALM_VOICE_DEFAULT_VOICE = "bf_isabella";
+/**
+* For `engine === 'openpalm-voice'`, fill in baseURL/model with the addon's
+* preset values when the user didn't provide them. This is the auto-config
+* that makes "select OpenPalm Voice → Save" Just Work as long as the addon
+* is enabled. The user can still override (e.g. point at a different
+* voice host on the LAN).
+*/
+function applyOpenPalmVoicePreset(section, kind) {
+	if (section.engine !== "openpalm-voice") return;
+	if (!section.baseURL?.trim()) section.baseURL = openpalmVoiceBaseURL();
+	if (!section.model?.trim()) section.model = kind === "tts" ? OPENPALM_VOICE_TTS_MODEL : OPENPALM_VOICE_STT_MODEL;
+	if (kind === "tts" && !section.voice?.trim()) section.voice = OPENPALM_VOICE_DEFAULT_VOICE;
+}
+function validateSection(section, kind) {
+	if (!section?.engine) return null;
+	if (section.engine === "browser" || section.engine === "browser-stt" || section.engine === "browser-tts") return null;
+	if (section.engine.startsWith("skip-")) return null;
+	if (!section.baseURL?.trim()) return `Remote ${kind.toUpperCase()} requires an endpoint URL.`;
+	return null;
+}
+var PUT = (event) => {
+	return withSerialQueue("admin:voice:put", () => handlePut(event));
+};
+async function handlePut(event) {
+	const requestId = getRequestId(event);
+	const capabilityError = requireCapability(event, "host:stack:write", requestId);
+	if (capabilityError) return capabilityError;
+	const authError = requireAdmin(event, requestId);
+	if (authError) return authError;
+	const state = getState();
+	let body;
+	try {
+		body = await event.request.json();
+	} catch {
+		return errorResponse(400, "Bad Request", "Invalid JSON body", {}, requestId);
+	}
+	if (!body || typeof body !== "object") return errorResponse(400, "Bad Request", "Body must be an object", {}, requestId);
+	const b = body;
+	const ttsSection = readSection(b.tts, "tts");
+	const sttSection = readSection(b.stt, "stt");
+	if (ttsSection) applyOpenPalmVoicePreset(ttsSection, "tts");
+	if (sttSection) applyOpenPalmVoicePreset(sttSection, "stt");
+	const ttsErr = validateSection(ttsSection, "tts");
+	if (ttsErr) return errorResponse(400, "invalid_tts", ttsErr, {}, requestId);
+	const sttErr = validateSection(sttSection, "stt");
+	if (sttErr) return errorResponse(400, "invalid_stt", sttErr, {}, requestId);
+	const config = {};
+	if (ttsSection) config.tts = {
+		enabled: ttsSection.enabled,
+		engine: ttsSection.engine,
+		provider: ttsSection.provider,
+		baseURL: ttsSection.baseURL,
+		model: ttsSection.model,
+		voice: ttsSection.voice
+	};
+	if (sttSection) config.stt = {
+		enabled: sttSection.enabled,
+		engine: sttSection.engine,
+		provider: sttSection.provider,
+		baseURL: sttSection.baseURL,
+		model: sttSection.model,
+		language: sttSection.language
+	};
+	writeVoiceVars(config, state.homeDir);
+	const result = await engageVoiceAddon({
+		state,
+		wantsVoiceAddon: ttsSection?.engine === "openpalm-voice" || sttSection?.engine === "openpalm-voice",
+		requestedProfile: typeof b.profile === "string" ? b.profile.trim() : ""
+	});
+	switch (result.status) {
+		case "disengaged": return jsonResponse(200, { ok: true }, requestId);
+		case "invalid_profile": return errorResponse(400, "invalid_profile", result.message, {}, requestId);
+		case "error": return jsonResponse(502, {
+			ok: false,
+			voiceAddon: {
+				wasAlreadyEnabled: result.wasAlreadyEnabled,
+				steps: result.steps,
+				error: result.error
+			}
+		}, requestId);
+		case "background": return jsonResponse(202, {
+			ok: true,
+			voiceAddon: {
+				wasAlreadyEnabled: result.wasAlreadyEnabled,
+				status: "pulling",
+				steps: result.steps,
+				message: result.message
+			}
+		}, requestId);
+		case "final": return jsonResponse(result.healthy || result.warming ? 200 : 502, {
+			ok: result.healthy || result.warming,
+			voiceAddon: {
+				wasAlreadyEnabled: result.wasAlreadyEnabled,
+				steps: result.steps,
+				...result.warming ? { warming: true } : {},
+				...result.healthy || result.warming ? {} : { error: "Voice addon is starting but did not become healthy in time." }
+			}
+		}, requestId);
+	}
+}
+
+export { GET, PUT };
+//# sourceMappingURL=_server.ts-CYY3W2qh.js.map