@pixelzx/genesis 2026.6.6-1 → 2026.6.7

package/dist/realtime-voice-provider-ByH_v5-M.js

@@ -0,0 +1,489 @@
+import { l as normalizeResolvedSecretInputString } from "./types.secrets-BbgGt42I.js";
+import { d as resolveDebugProxySettings, n as captureWsEvent, u as createDebugProxyWebSocketAgent } from "./runtime-g7ZshN2N.js";
+import { n as fetchWithSsrFGuard } from "./fetch-guard-CHbFjcDr.js";
+import { a as createProviderHttpError } from "./provider-http-errors-CHlOQSL-.js";
+import "./secret-input-sz5hyJkX.js";
+import "./proxy-capture-sDeapk6H.js";
+import "./ssrf-runtime-CetK5Qy_.js";
+import "./provider-http-jBjkpqsS.js";
+import { a as resolveOpenAIProviderConfigRecord, i as readRealtimeErrorDetail, o as trimToUndefined, r as captureOpenAIRealtimeWsClose, t as asFiniteNumber } from "./realtime-provider-shared-RvhVjejL.js";
+import { randomUUID } from "node:crypto";
+import WebSocket from "ws";
+//#region extensions/openai/realtime-voice-provider.ts
+const OPENAI_REALTIME_DEFAULT_MODEL = "gpt-realtime-1.5";
+function normalizeProviderConfig(config) {
+	const raw = resolveOpenAIProviderConfigRecord(config);
+	return {
+		apiKey: normalizeResolvedSecretInputString({
+			value: raw?.apiKey,
+			path: "plugins.entries.voice-call.config.realtime.providers.openai.apiKey"
+		}),
+		model: trimToUndefined(raw?.model),
+		voice: trimToUndefined(raw?.voice),
+		temperature: asFiniteNumber(raw?.temperature),
+		vadThreshold: asFiniteNumber(raw?.vadThreshold),
+		silenceDurationMs: asFiniteNumber(raw?.silenceDurationMs),
+		prefixPaddingMs: asFiniteNumber(raw?.prefixPaddingMs),
+		azureEndpoint: trimToUndefined(raw?.azureEndpoint),
+		azureDeployment: trimToUndefined(raw?.azureDeployment),
+		azureApiVersion: trimToUndefined(raw?.azureApiVersion)
+	};
+}
+function base64ToBuffer(b64) {
+	return Buffer.from(b64, "base64");
+}
+var OpenAIRealtimeVoiceBridge = class OpenAIRealtimeVoiceBridge {
+	static {
+		this.DEFAULT_MODEL = OPENAI_REALTIME_DEFAULT_MODEL;
+	}
+	static {
+		this.MAX_RECONNECT_ATTEMPTS = 5;
+	}
+	static {
+		this.BASE_RECONNECT_DELAY_MS = 1e3;
+	}
+	static {
+		this.CONNECT_TIMEOUT_MS = 1e4;
+	}
+	constructor(config) {
+		this.config = config;
+		this.ws = null;
+		this.connected = false;
+		this.sessionConfigured = false;
+		this.intentionallyClosed = false;
+		this.reconnectAttempts = 0;
+		this.pendingAudio = [];
+		this.markQueue = [];
+		this.responseStartTimestamp = null;
+		this.latestMediaTimestamp = 0;
+		this.lastAssistantItemId = null;
+		this.toolCallBuffers = /* @__PURE__ */ new Map();
+		this.flowId = randomUUID();
+		this.sessionReadyFired = false;
+	}
+	async connect() {
+		this.intentionallyClosed = false;
+		this.reconnectAttempts = 0;
+		await this.doConnect();
+	}
+	sendAudio(audio) {
+		if (!this.connected || !this.sessionConfigured || this.ws?.readyState !== WebSocket.OPEN) {
+			if (this.pendingAudio.length < 320) this.pendingAudio.push(audio);
+			return;
+		}
+		this.sendEvent({
+			type: "input_audio_buffer.append",
+			audio: audio.toString("base64")
+		});
+	}
+	setMediaTimestamp(ts) {
+		this.latestMediaTimestamp = ts;
+	}
+	sendUserMessage(text) {
+		this.sendEvent({
+			type: "conversation.item.create",
+			item: {
+				type: "message",
+				role: "user",
+				content: [{
+					type: "input_text",
+					text
+				}]
+			}
+		});
+		this.sendEvent({ type: "response.create" });
+	}
+	triggerGreeting(instructions) {
+		if (!this.isConnected() || !this.ws) return;
+		this.sendEvent({
+			type: "response.create",
+			response: { instructions: instructions ?? this.config.instructions }
+		});
+	}
+	submitToolResult(callId, result) {
+		this.sendEvent({
+			type: "conversation.item.create",
+			item: {
+				type: "function_call_output",
+				call_id: callId,
+				output: JSON.stringify(result)
+			}
+		});
+		this.sendEvent({ type: "response.create" });
+	}
+	acknowledgeMark() {
+		if (this.markQueue.length === 0) return;
+		this.markQueue.shift();
+		if (this.markQueue.length === 0) {
+			this.responseStartTimestamp = null;
+			this.lastAssistantItemId = null;
+		}
+	}
+	close() {
+		this.intentionallyClosed = true;
+		this.connected = false;
+		this.sessionConfigured = false;
+		if (this.ws) {
+			this.ws.close(1e3, "Bridge closed");
+			this.ws = null;
+		}
+	}
+	isConnected() {
+		return this.connected && this.sessionConfigured;
+	}
+	async doConnect() {
+		await new Promise((resolve, reject) => {
+			let connectTimeout;
+			let settled = false;
+			const settleResolve = () => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(connectTimeout);
+				resolve();
+			};
+			const settleReject = (error) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(connectTimeout);
+				reject(error);
+			};
+			const { url, headers } = this.resolveConnectionParams();
+			const proxyAgent = createDebugProxyWebSocketAgent(resolveDebugProxySettings());
+			this.ws = new WebSocket(url, {
+				headers,
+				...proxyAgent ? { agent: proxyAgent } : {}
+			});
+			connectTimeout = setTimeout(() => {
+				if (!this.connected && !this.intentionallyClosed) {
+					this.ws?.terminate();
+					settleReject(/* @__PURE__ */ new Error("OpenAI realtime connection timeout"));
+				}
+			}, OpenAIRealtimeVoiceBridge.CONNECT_TIMEOUT_MS);
+			this.ws.on("open", () => {
+				this.connected = true;
+				this.sessionConfigured = false;
+				this.reconnectAttempts = 0;
+				captureWsEvent({
+					url,
+					direction: "local",
+					kind: "ws-open",
+					flowId: this.flowId,
+					meta: {
+						provider: "openai",
+						capability: "realtime-voice"
+					}
+				});
+				this.sendSessionUpdate();
+				settleResolve();
+			});
+			this.ws.on("message", (data) => {
+				captureWsEvent({
+					url,
+					direction: "inbound",
+					kind: "ws-frame",
+					flowId: this.flowId,
+					payload: data,
+					meta: {
+						provider: "openai",
+						capability: "realtime-voice"
+					}
+				});
+				try {
+					this.handleEvent(JSON.parse(data.toString()));
+				} catch (error) {
+					console.error("[openai] realtime event parse failed:", error);
+				}
+			});
+			this.ws.on("error", (error) => {
+				captureWsEvent({
+					url,
+					direction: "local",
+					kind: "error",
+					flowId: this.flowId,
+					errorText: error instanceof Error ? error.message : String(error),
+					meta: {
+						provider: "openai",
+						capability: "realtime-voice"
+					}
+				});
+				if (!this.connected) settleReject(error instanceof Error ? error : new Error(String(error)));
+				this.config.onError?.(error instanceof Error ? error : new Error(String(error)));
+			});
+			this.ws.on("close", (code, reasonBuffer) => {
+				captureOpenAIRealtimeWsClose({
+					url,
+					flowId: this.flowId,
+					capability: "realtime-voice",
+					code,
+					reasonBuffer
+				});
+				this.connected = false;
+				this.sessionConfigured = false;
+				if (this.intentionallyClosed) {
+					settleResolve();
+					this.config.onClose?.("completed");
+					return;
+				}
+				this.attemptReconnect();
+			});
+		});
+	}
+	resolveConnectionParams() {
+		const cfg = this.config;
+		if (cfg.azureEndpoint && cfg.azureDeployment) return {
+			url: `${cfg.azureEndpoint.replace(/\/$/, "").replace(/^http(s?):/, (_, secure) => `ws${secure}:`)}/openai/realtime?api-version=${cfg.azureApiVersion ?? "2024-10-01-preview"}&deployment=${encodeURIComponent(cfg.azureDeployment)}`,
+			headers: { "api-key": cfg.apiKey }
+		};
+		if (cfg.azureEndpoint) return {
+			url: `${cfg.azureEndpoint.replace(/\/$/, "").replace(/^http(s?):/, (_, secure) => `ws${secure}:`)}/v1/realtime?model=${encodeURIComponent(cfg.model ?? OpenAIRealtimeVoiceBridge.DEFAULT_MODEL)}`,
+			headers: { Authorization: `Bearer ${cfg.apiKey}` }
+		};
+		return {
+			url: `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(cfg.model ?? OpenAIRealtimeVoiceBridge.DEFAULT_MODEL)}`,
+			headers: {
+				Authorization: `Bearer ${cfg.apiKey}`,
+				"OpenAI-Beta": "realtime=v1"
+			}
+		};
+	}
+	async attemptReconnect() {
+		if (this.intentionallyClosed) return;
+		if (this.reconnectAttempts >= OpenAIRealtimeVoiceBridge.MAX_RECONNECT_ATTEMPTS) {
+			this.config.onClose?.("error");
+			return;
+		}
+		this.reconnectAttempts += 1;
+		const delay = OpenAIRealtimeVoiceBridge.BASE_RECONNECT_DELAY_MS * 2 ** (this.reconnectAttempts - 1);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+		if (this.intentionallyClosed) return;
+		try {
+			await this.doConnect();
+		} catch (error) {
+			this.config.onError?.(error instanceof Error ? error : new Error(String(error)));
+			await this.attemptReconnect();
+		}
+	}
+	sendSessionUpdate() {
+		const cfg = this.config;
+		const sessionUpdate = {
+			type: "session.update",
+			session: {
+				modalities: ["text", "audio"],
+				instructions: cfg.instructions,
+				voice: cfg.voice ?? "alloy",
+				input_audio_format: "g711_ulaw",
+				output_audio_format: "g711_ulaw",
+				input_audio_transcription: { model: "whisper-1" },
+				turn_detection: {
+					type: "server_vad",
+					threshold: cfg.vadThreshold ?? .5,
+					prefix_padding_ms: cfg.prefixPaddingMs ?? 300,
+					silence_duration_ms: cfg.silenceDurationMs ?? 500,
+					create_response: true
+				},
+				temperature: cfg.temperature ?? .8,
+				...cfg.tools && cfg.tools.length > 0 ? {
+					tools: cfg.tools,
+					tool_choice: "auto"
+				} : {}
+			}
+		};
+		this.sendEvent(sessionUpdate);
+	}
+	handleEvent(event) {
+		switch (event.type) {
+			case "session.created": return;
+			case "session.updated":
+				this.sessionConfigured = true;
+				for (const chunk of this.pendingAudio.splice(0)) this.sendAudio(chunk);
+				if (!this.sessionReadyFired) {
+					this.sessionReadyFired = true;
+					this.config.onReady?.();
+				}
+				return;
+			case "response.audio.delta": {
+				if (!event.delta) return;
+				const audio = base64ToBuffer(event.delta);
+				this.config.onAudio(audio);
+				if (this.responseStartTimestamp === null) this.responseStartTimestamp = this.latestMediaTimestamp;
+				if (event.item_id) this.lastAssistantItemId = event.item_id;
+				this.sendMark();
+				return;
+			}
+			case "input_audio_buffer.speech_started":
+				this.handleBargeIn();
+				return;
+			case "response.audio_transcript.delta":
+				if (event.delta) this.config.onTranscript?.("assistant", event.delta, false);
+				return;
+			case "response.audio_transcript.done":
+				if (event.transcript) this.config.onTranscript?.("assistant", event.transcript, true);
+				return;
+			case "conversation.item.input_audio_transcription.completed":
+				if (event.transcript) this.config.onTranscript?.("user", event.transcript, true);
+				return;
+			case "conversation.item.input_audio_transcription.delta":
+				if (event.delta) this.config.onTranscript?.("user", event.delta, false);
+				return;
+			case "response.function_call_arguments.delta": {
+				const key = event.item_id ?? "unknown";
+				const existing = this.toolCallBuffers.get(key);
+				if (existing && event.delta) existing.args += event.delta;
+				else if (event.item_id) this.toolCallBuffers.set(event.item_id, {
+					name: event.name ?? "",
+					callId: event.call_id ?? "",
+					args: event.delta ?? ""
+				});
+				return;
+			}
+			case "response.function_call_arguments.done": {
+				const key = event.item_id ?? "unknown";
+				const buffered = this.toolCallBuffers.get(key);
+				if (this.config.onToolCall) {
+					const rawArgs = buffered?.args || event.arguments || "{}";
+					let args = {};
+					try {
+						args = JSON.parse(rawArgs);
+					} catch {}
+					this.config.onToolCall({
+						itemId: key,
+						callId: buffered?.callId || event.call_id || "",
+						name: buffered?.name || event.name || "",
+						args
+					});
+				}
+				this.toolCallBuffers.delete(key);
+				return;
+			}
+			case "error": {
+				const detail = readRealtimeErrorDetail(event.error);
+				this.config.onError?.(new Error(detail));
+				return;
+			}
+			default: return;
+		}
+	}
+	handleBargeIn() {
+		if (this.markQueue.length > 0 && this.responseStartTimestamp !== null) {
+			const elapsedMs = this.latestMediaTimestamp - this.responseStartTimestamp;
+			if (this.lastAssistantItemId) this.sendEvent({
+				type: "conversation.item.truncate",
+				item_id: this.lastAssistantItemId,
+				content_index: 0,
+				audio_end_ms: Math.max(0, elapsedMs)
+			});
+			this.config.onClearAudio();
+			this.markQueue = [];
+			this.lastAssistantItemId = null;
+			this.responseStartTimestamp = null;
+			return;
+		}
+		this.config.onClearAudio();
+	}
+	sendMark() {
+		const markName = `audio-${Date.now()}`;
+		this.markQueue.push(markName);
+		this.config.onMark?.(markName);
+	}
+	sendEvent(event) {
+		if (this.ws?.readyState === WebSocket.OPEN) {
+			const payload = JSON.stringify(event);
+			captureWsEvent({
+				url: this.resolveConnectionParams().url,
+				direction: "outbound",
+				kind: "ws-frame",
+				flowId: this.flowId,
+				payload,
+				meta: {
+					provider: "openai",
+					capability: "realtime-voice"
+				}
+			});
+			this.ws.send(payload);
+		}
+	}
+};
+function readStringField(value, key) {
+	if (!value || typeof value !== "object") return;
+	const raw = value[key];
+	return typeof raw === "string" && raw.trim() ? raw.trim() : void 0;
+}
+async function createOpenAIRealtimeBrowserSession(req) {
+	const config = normalizeProviderConfig(req.providerConfig);
+	const apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+	if (!apiKey) throw new Error("OpenAI API key missing");
+	if (config.azureEndpoint || config.azureDeployment) throw new Error("OpenAI Realtime browser sessions do not support Azure endpoints yet");
+	const model = req.model ?? config.model ?? OPENAI_REALTIME_DEFAULT_MODEL;
+	const voice = req.voice ?? config.voice ?? "alloy";
+	const session = {
+		type: "realtime",
+		model,
+		instructions: req.instructions,
+		audio: { output: { voice } }
+	};
+	if (req.tools && req.tools.length > 0) {
+		session.tools = req.tools;
+		session.tool_choice = "auto";
+	}
+	const { response, release } = await fetchWithSsrFGuard({
+		url: "https://api.openai.com/v1/realtime/client_secrets",
+		init: {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ session })
+		},
+		auditContext: "openai-realtime-browser-session"
+	});
+	const payload = await (async () => {
+		try {
+			if (!response.ok) throw await createProviderHttpError(response, "OpenAI Realtime browser session failed");
+			return await response.json();
+		} finally {
+			await release();
+		}
+	})();
+	const nestedSecret = payload && typeof payload === "object" ? payload.client_secret : void 0;
+	const clientSecret = readStringField(payload, "value") ?? readStringField(nestedSecret, "value");
+	if (!clientSecret) throw new Error("OpenAI Realtime browser session did not return a client secret");
+	const expiresAt = payload && typeof payload === "object" ? payload.expires_at : void 0;
+	return {
+		provider: "openai",
+		clientSecret,
+		model,
+		voice,
+		...typeof expiresAt === "number" ? { expiresAt } : {}
+	};
+}
+function buildOpenAIRealtimeVoiceProvider() {
+	return {
+		id: "openai",
+		label: "OpenAI Realtime Voice",
+		autoSelectOrder: 10,
+		resolveConfig: ({ rawConfig }) => normalizeProviderConfig(rawConfig),
+		isConfigured: ({ providerConfig }) => Boolean(normalizeProviderConfig(providerConfig).apiKey || process.env.OPENAI_API_KEY),
+		createBridge: (req) => {
+			const config = normalizeProviderConfig(req.providerConfig);
+			const apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+			if (!apiKey) throw new Error("OpenAI API key missing");
+			return new OpenAIRealtimeVoiceBridge({
+				...req,
+				apiKey,
+				model: config.model,
+				voice: config.voice,
+				temperature: config.temperature,
+				vadThreshold: config.vadThreshold,
+				silenceDurationMs: config.silenceDurationMs,
+				prefixPaddingMs: config.prefixPaddingMs,
+				azureEndpoint: config.azureEndpoint,
+				azureDeployment: config.azureDeployment,
+				azureApiVersion: config.azureApiVersion
+			});
+		},
+		createBrowserSession: createOpenAIRealtimeBrowserSession
+	};
+}
+//#endregion
+export { buildOpenAIRealtimeVoiceProvider as t };

package/dist/record-shared-DVnkFx9W.js

@@ -0,0 +1,10 @@
+import { t as hasNonEmptyString$1 } from "./string-coerce-DPP_aYVc.js";
+import "./text-runtime-Dd2bva2m.js";
+//#region extensions/browser/src/record-shared.ts
+const hasNonEmptyString = hasNonEmptyString$1;
+function normalizeString(value) {
+	if (typeof value === "string") return value.trim() || void 0;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+}
+//#endregion
+export { normalizeString as n, hasNonEmptyString as t };

package/dist/register-service-commands-BXfMmQsa.js

@@ -0,0 +1,71 @@
+import { n as inheritOptionFromParent } from "./command-options-BAeBeFgJ.js";
+//#region src/cli/daemon-cli/register-service-commands.ts
+let daemonInstallModulePromise;
+let daemonLifecycleModulePromise;
+let daemonStatusModulePromise;
+function loadDaemonInstallModule() {
+	daemonInstallModulePromise ??= import("./install.runtime-2KxUKV9q.js");
+	return daemonInstallModulePromise;
+}
+function loadDaemonLifecycleModule() {
+	daemonLifecycleModulePromise ??= import("./lifecycle.runtime-CMl4KKk8.js");
+	return daemonLifecycleModulePromise;
+}
+function loadDaemonStatusModule() {
+	daemonStatusModulePromise ??= import("./status.runtime-JhkaEpRc.js");
+	return daemonStatusModulePromise;
+}
+function resolveInstallOptions(cmdOpts, command) {
+	const parentForce = inheritOptionFromParent(command, "force");
+	const parentPort = inheritOptionFromParent(command, "port");
+	const parentToken = inheritOptionFromParent(command, "token");
+	return {
+		...cmdOpts,
+		force: Boolean(cmdOpts.force || parentForce),
+		port: cmdOpts.port ?? parentPort,
+		token: cmdOpts.token ?? parentToken
+	};
+}
+function resolveRpcOptions(cmdOpts, command) {
+	const parentToken = inheritOptionFromParent(command, "token");
+	const parentPassword = inheritOptionFromParent(command, "password");
+	return {
+		...cmdOpts,
+		token: cmdOpts.token ?? parentToken,
+		password: cmdOpts.password ?? parentPassword
+	};
+}
+function addGatewayServiceCommands(parent, opts) {
+	parent.command("status").description(opts?.statusDescription ?? "Show gateway service status + probe connectivity/capability").option("--url <url>", "Gateway WebSocket URL (defaults to config/remote/local)").option("--token <token>", "Gateway token (if required)").option("--password <password>", "Gateway password (password auth)").option("--timeout <ms>", "Timeout in ms", "10000").option("--no-probe", "Skip RPC probe").option("--require-rpc", "Exit non-zero when the RPC probe fails", false).option("--deep", "Scan system-level services", false).option("--json", "Output JSON", false).action(async (cmdOpts, command) => {
+		const { runDaemonStatus } = await loadDaemonStatusModule();
+		await runDaemonStatus({
+			rpc: resolveRpcOptions(cmdOpts, command),
+			probe: Boolean(cmdOpts.probe),
+			requireRpc: Boolean(cmdOpts.requireRpc),
+			deep: Boolean(cmdOpts.deep),
+			json: Boolean(cmdOpts.json)
+		});
+	});
+	parent.command("install").description("Install the Gateway service (launchd/systemd/schtasks)").option("--port <port>", "Gateway port").option("--runtime <runtime>", "Daemon runtime (node|bun). Default: node").option("--token <token>", "Gateway token (token auth)").option("--force", "Reinstall/overwrite if already installed", false).option("--json", "Output JSON", false).action(async (cmdOpts, command) => {
+		const { runDaemonInstall } = await loadDaemonInstallModule();
+		await runDaemonInstall(resolveInstallOptions(cmdOpts, command));
+	});
+	parent.command("uninstall").description("Uninstall the Gateway service (launchd/systemd/schtasks)").option("--json", "Output JSON", false).action(async (cmdOpts) => {
+		const { runDaemonUninstall } = await loadDaemonLifecycleModule();
+		await runDaemonUninstall(cmdOpts);
+	});
+	parent.command("start").description("Start the Gateway service (launchd/systemd/schtasks)").option("--json", "Output JSON", false).action(async (cmdOpts) => {
+		const { runDaemonStart } = await loadDaemonLifecycleModule();
+		await runDaemonStart(cmdOpts);
+	});
+	parent.command("stop").description("Stop the Gateway service (launchd/systemd/schtasks)").option("--json", "Output JSON", false).action(async (cmdOpts) => {
+		const { runDaemonStop } = await loadDaemonLifecycleModule();
+		await runDaemonStop(cmdOpts);
+	});
+	parent.command("restart").description("Restart the Gateway service (launchd/systemd/schtasks)").option("--json", "Output JSON", false).action(async (cmdOpts) => {
+		const { runDaemonRestart } = await loadDaemonLifecycleModule();
+		await runDaemonRestart(cmdOpts);
+	});
+}
+//#endregion
+export { addGatewayServiceCommands as t };