@openclaw/facetime 0.0.0 → 2026.9.7

package/dist/doctor-contract-api.js

@@ -0,0 +1,271 @@
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+//#region packages/normalization-core/src/record-coerce.ts
+/** Type guard for non-array object records at browser-safe boundaries. */
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Returns a non-array record or null. */
+function asNullableRecord(value) {
+	return isRecord(value) ? value : null;
+}
+//#endregion
+//#region src/config/channel-config-normalization.ts
+/** Applies one channel-specific doctor migration to every object-shaped account. */
+function normalizeChannelAccounts(params) {
+	const rawAccounts = asNullableRecord(params.entry.accounts);
+	if (!rawAccounts) return {
+		entry: params.entry,
+		changed: false
+	};
+	let changed = false;
+	const accounts = { ...rawAccounts };
+	for (const [accountId, value] of Object.entries(rawAccounts)) {
+		const account = asNullableRecord(value);
+		if (!account) continue;
+		const normalized = params.normalizeAccount({
+			account,
+			accountId,
+			pathPrefix: `${params.pathPrefix}.accounts.${accountId}`,
+			changes: params.changes
+		});
+		if (normalized.changed) {
+			accounts[accountId] = normalized.entry;
+			changed = true;
+		}
+	}
+	return changed ? {
+		entry: {
+			...params.entry,
+			accounts
+		},
+		changed: true
+	} : {
+		entry: params.entry,
+		changed: false
+	};
+}
+/** Applies the same channel-specific doctor migration at root and account scope. */
+function normalizeChannelConfigEntries(params) {
+	const changes = params.changes ?? [];
+	const channels = params.cfg.channels;
+	const entry = asNullableRecord(channels?.[params.channelId]);
+	if (!entry) return {
+		config: params.cfg,
+		changes
+	};
+	const channelPath = `channels.${params.channelId}`;
+	const root = params.normalizeEntry({
+		entry,
+		pathPrefix: channelPath,
+		changes
+	});
+	const accounts = normalizeChannelAccounts({
+		entry: root.entry,
+		pathPrefix: channelPath,
+		changes,
+		normalizeAccount: (accountParams) => params.normalizeEntry({
+			entry: accountParams.account,
+			accountId: accountParams.accountId,
+			pathPrefix: accountParams.pathPrefix,
+			changes: accountParams.changes
+		})
+	});
+	if (!root.changed && !accounts.changed) return {
+		config: params.cfg,
+		changes
+	};
+	return {
+		config: {
+			...params.cfg,
+			channels: {
+				...channels,
+				[params.channelId]: accounts.entry
+			}
+		},
+		changes
+	};
+}
+//#endregion
+//#region src/plugin-sdk/legacy-webhook-listener-migration.ts
+/** Preserve explicitly configured webhook listeners while moving ingress onto Gateway routes. */
+function createLegacyWebhookListenerDoctorContract(params) {
+	const portKey = params.portKey ?? "webhookPort";
+	const hostKey = params.hostKey === void 0 ? "webhookHost" : params.hostKey;
+	const source = (entry) => params.webhookKey ? asNullableRecord(entry[params.webhookKey]) : entry;
+	const hasLegacy = (value) => {
+		const entry = asNullableRecord(value);
+		const listener = entry && source(entry);
+		return Boolean(listener && (Object.hasOwn(listener, portKey) || hostKey && Object.hasOwn(listener, hostKey)));
+	};
+	const prefix = `channels.${params.channelKey}`;
+	return {
+		legacyConfigRules: [{
+			path: ["channels", params.channelKey],
+			message: `${prefix} webhook listeners moved to Gateway routes. Run "openclaw doctor --fix" to preserve explicitly configured listener settings as legacyWebhook.`,
+			match: (value) => {
+				const accounts = asNullableRecord(asNullableRecord(value)?.accounts);
+				return hasLegacy(value) || Object.values(accounts ?? {}).some(hasLegacy);
+			}
+		}],
+		normalizeCompatibilityConfig: ({ cfg }) => {
+			const root = asNullableRecord(asNullableRecord(cfg.channels)?.[params.channelKey]);
+			const inherited = root && source(root);
+			const canonicalRoot = asNullableRecord(root?.legacyWebhook);
+			return normalizeChannelConfigEntries({
+				cfg,
+				channelId: params.channelKey,
+				normalizeEntry: ({ entry, accountId, pathPrefix, changes }) => {
+					const listener = source(entry);
+					if (!listener || !hasLegacy(entry)) return {
+						entry,
+						changed: false
+					};
+					const next = { ...entry };
+					const port = Object.hasOwn(listener, portKey) ? listener[portKey] : (accountId ? canonicalRoot?.port ?? inherited?.[portKey] : void 0) ?? params.defaultPort;
+					const inheritedHost = accountId ? canonicalRoot ? canonicalRoot.host : (hostKey ? inherited?.[hostKey] : void 0) ?? params.defaultHost : params.defaultHost;
+					const host = hostKey ? listener[hostKey] ?? inheritedHost : inheritedHost;
+					const legacyPath = [pathPrefix, params.webhookKey].filter(Boolean).join(".");
+					if (Object.hasOwn(entry, "legacyWebhook")) changes.push(`Removed ${legacyPath} legacy listener keys; ${pathPrefix}.legacyWebhook is already configured.`);
+					else if (accountId && root?.legacyWebhook === false) changes.push(`Removed ${legacyPath} legacy listener keys; ${prefix}.legacyWebhook: false keeps this account's inherited listener disabled.`);
+					else {
+						next.legacyWebhook = {
+							port,
+							...host !== void 0 ? { host } : {}
+						};
+						changes.push(`Moved ${legacyPath} listener settings to ${pathPrefix}.legacyWebhook. Point the external callback or reverse proxy at the Gateway port and webhook path, verify delivery, then set legacyWebhook: false to disable legacy forwarding.`);
+					}
+					const updated = params.webhookKey ? { ...listener } : next;
+					delete updated[portKey];
+					if (hostKey) delete updated[hostKey];
+					if (params.webhookKey) {
+						if (Object.keys(updated).length) next[params.webhookKey] = updated;
+						else delete next[params.webhookKey];
+					}
+					return {
+						entry: next,
+						changed: true
+					};
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region \0openclaw:bundled-sdk:openclaw/plugin-sdk/runtime-doctor-migrations
+var runtime_doctor_migrations_exports = /* @__PURE__ */ __exportAll({ createLegacyWebhookListenerDoctorContract: () => createLegacyWebhookListenerDoctorContract });
+import * as import_openclaw_plugin_sdk_runtime_doctor_migrations from "openclaw/plugin-sdk/runtime-doctor-migrations";
+__reExport(runtime_doctor_migrations_exports, import_openclaw_plugin_sdk_runtime_doctor_migrations);
+//#endregion
+//#region extensions/facetime/doctor-contract-api.ts
+const CONFIG_PATH = [
+	"plugins",
+	"entries",
+	"facetime",
+	"config"
+];
+const RETIRED_CONFIG_KEYS = ["helperHost", "helperPort"];
+const legacyConfigRules = [
+	{
+		path: [...CONFIG_PATH, "whitelistHandles"],
+		message: "plugins.entries.facetime.config.whitelistHandles is legacy; use ownerHandles. Run \"openclaw doctor --fix\"."
+	},
+	...RETIRED_CONFIG_KEYS.map((key) => ({
+		path: [...CONFIG_PATH, key],
+		message: `${[...CONFIG_PATH, key].join(".")} is retired; FaceTime now uses its local authenticated helper endpoint. Run "openclaw doctor --fix".`
+	})),
+	{
+		path: [
+			...CONFIG_PATH,
+			"realtime",
+			"brain"
+		],
+		message: "plugins.entries.facetime.config.realtime.brain is retired; FaceTime always consults the configured agent. Run \"openclaw doctor --fix\"."
+	}
+];
+function normalizeLegacyOwnerHandles(value) {
+	if (!Array.isArray(value)) return null;
+	return value.map((entry) => normalizeOptionalString(entry)).filter((entry) => Boolean(entry));
+}
+/** Moves or removes retired prototype keys so runtime sees only the canonical config shape. */
+function normalizeCompatibilityConfig({ cfg }) {
+	const entry = (0, runtime_doctor_migrations_exports.asObjectRecord)(cfg.plugins?.entries?.facetime);
+	const pluginConfig = (0, runtime_doctor_migrations_exports.asObjectRecord)(entry?.config);
+	if (!pluginConfig) return {
+		config: cfg,
+		changes: []
+	};
+	const hasLegacyOwnerHandles = Object.hasOwn(pluginConfig, "whitelistHandles");
+	const retiredKeys = RETIRED_CONFIG_KEYS.filter((key) => Object.hasOwn(pluginConfig, key));
+	const realtime = (0, runtime_doctor_migrations_exports.asObjectRecord)(pluginConfig.realtime);
+	const hasRetiredBrain = Boolean(realtime && Object.hasOwn(realtime, "brain"));
+	if (!hasLegacyOwnerHandles && retiredKeys.length === 0 && !hasRetiredBrain) return {
+		config: cfg,
+		changes: []
+	};
+	const nextConfig = structuredClone(cfg);
+	const nextEntry = (0, runtime_doctor_migrations_exports.asObjectRecord)(nextConfig.plugins?.entries?.facetime);
+	const nextPluginConfig = (0, runtime_doctor_migrations_exports.asObjectRecord)(nextEntry?.config);
+	if (!nextPluginConfig) return {
+		config: cfg,
+		changes: []
+	};
+	const changes = [];
+	if (hasLegacyOwnerHandles) {
+		const sourcePath = [...CONFIG_PATH, "whitelistHandles"].join(".");
+		const targetPath = [...CONFIG_PATH, "ownerHandles"].join(".");
+		if (Object.hasOwn(nextPluginConfig, "ownerHandles")) changes.push(`Removed ${sourcePath}; ${targetPath} is authoritative.`);
+		else {
+			const handles = normalizeLegacyOwnerHandles(nextPluginConfig.whitelistHandles);
+			if (handles) {
+				nextPluginConfig.ownerHandles = handles;
+				changes.push(`Moved ${sourcePath} to ${targetPath}.`);
+			} else changes.push(`Removed invalid ${sourcePath}; configure ${targetPath}.`);
+		}
+		delete nextPluginConfig.whitelistHandles;
+	}
+	for (const key of retiredKeys) {
+		delete nextPluginConfig[key];
+		changes.push(`Removed retired ${[...CONFIG_PATH, key].join(".")}.`);
+	}
+	const nextRealtime = (0, runtime_doctor_migrations_exports.asObjectRecord)(nextPluginConfig.realtime);
+	if (hasRetiredBrain && nextRealtime) {
+		delete nextRealtime.brain;
+		changes.push(`Removed retired ${[
+			...CONFIG_PATH,
+			"realtime",
+			"brain"
+		].join(".")}.`);
+	}
+	return {
+		config: nextConfig,
+		changes
+	};
+}
+//#endregion
+export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/index.js

@@ -0,0 +1,312 @@
+import { a as inspectFaceTimeNativePackage, c as uninstallFaceTimeDriver, i as inspectFaceTimeArtifacts, l as resolveFaceTimeConfig, o as inspectFaceTimeDriver, t as runFaceTimeSetup, u as validateFaceTimeConfig } from "./.setup/setup-CoxvlB5L.mjs";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { ErrorCodes, errorShape } from "openclaw/plugin-sdk/gateway-runtime";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { asRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { stringEnum } from "openclaw/plugin-sdk/channel-actions";
+import { jsonResult } from "openclaw/plugin-sdk/tool-results";
+import { Type } from "typebox";
+//#region extensions/facetime/src/runtime-lifecycle.ts
+async function stopRetainedRuntime(current, clearIfCurrent) {
+	if (!current) return;
+	let runtime;
+	try {
+		runtime = await current;
+	} catch (error) {
+		clearIfCurrent(current);
+		throw error;
+	}
+	await runtime.stop();
+	clearIfCurrent(current);
+}
+//#endregion
+//#region extensions/facetime/src/static-status.ts
+async function inspectFaceTimeStaticStatus(params) {
+	const [artifacts, driver] = await Promise.all([inspectFaceTimeArtifacts({}), inspectFaceTimeDriver(params).then((status) => ({ status }), (error) => ({ error: formatErrorMessage(error) }))]);
+	return {
+		enabled: params.config.enabled,
+		activation: "inactive",
+		configValid: params.configErrors.length === 0,
+		configErrors: params.configErrors,
+		artifacts,
+		driverStatus: "status" in driver ? driver.status : void 0,
+		driverError: "error" in driver ? driver.error : void 0,
+		note: "Static inspection only; helper, carrier, model media, and remote audibility were not activated or tested."
+	};
+}
+//#endregion
+//#region extensions/facetime/src/tool.ts
+const FaceTimeCallToolSchema = Type.Object({
+	action: stringEnum([
+		"get_status",
+		"check_readiness",
+		"initiate_call",
+		"end_call"
+	]),
+	handle: Type.Optional(Type.String({
+		description: "Authorized owner FaceTime email or phone number",
+		maxLength: 256
+	})),
+	mode: Type.Optional(stringEnum(["audio", "video"])),
+	callUUID: Type.Optional(Type.String({ description: "Current call identity. Omit to end the current call." }))
+}, { additionalProperties: false });
+function resolveFaceTimeToolApproval(input) {
+	const raw = asRecord(input);
+	if (raw.action !== "initiate_call") return;
+	const handle = normalizeOptionalString(raw.handle);
+	if (!handle) return;
+	return { requireApproval: {
+		title: "Place FaceTime call",
+		description: `Place a ${raw.mode === "video" ? "video" : "audio"} FaceTime call to ${handle}.`,
+		severity: "warning",
+		allowedDecisions: ["allow-once", "deny"],
+		timeoutMs: 12e4
+	} };
+}
+function summarizeStatus(status) {
+	return {
+		stageMeaning: "Internal carrier/model/native stages only; remote audibility is not measured.",
+		enabled: status.enabled,
+		helperConnected: status.helperConnected,
+		helperProtocol: status.helperProtocol,
+		helperTargets: status.helperTargets.map((target) => ({
+			target: target.target,
+			connected: target.connected,
+			stale: target.stale,
+			retryScheduled: target.retryScheduled
+		})),
+		driverInstallPending: status.driverInstallPending,
+		driverInstall: status.driverInstall,
+		processOutputSuppressed: status.processOutputSuppressed,
+		outboundCallPending: status.outboundCallPending,
+		calls: status.calls.map((call) => ({
+			callUUID: call.callUUID,
+			phase: call.phase,
+			carrierMode: call.carrierMode,
+			modelMediaMode: call.modelMediaMode,
+			handle: call.handle,
+			realtimeActive: call.realtimeActive,
+			audioReady: call.audioReady,
+			processInputVerified: call.audioTransport?.processInputVerified === true,
+			processOutputSuppressed: call.audioTransport?.processOutputSuppressed === true,
+			lastRoutingError: call.lastRoutingError,
+			carrierHangupPending: call.carrierHangupPending
+		}))
+	};
+}
+function createFaceTimeCallTool(params) {
+	return {
+		name: "facetime_call",
+		label: "FaceTime Call",
+		description: "Inspect FaceTime stages and manage calls for configured owner handles on this Mac.",
+		parameters: FaceTimeCallToolSchema,
+		async execute(_toolCallId, input) {
+			const raw = asRecord(input);
+			const action = normalizeOptionalString(raw.action);
+			try {
+				switch (action) {
+					case "get_status": return jsonResult({
+						ok: true,
+						action,
+						status: await params.getStatus().then((status) => "calls" in status ? summarizeStatus(status) : status)
+					});
+					case "check_readiness": {
+						const readiness = await params.getStatus();
+						return jsonResult({
+							ok: "calls" in readiness ? true : readiness.configValid,
+							action,
+							status: "calls" in readiness ? summarizeStatus(readiness) : readiness,
+							note: "Reports internal static/runtime stages only; it does not prove remote audibility."
+						});
+					}
+					case "initiate_call": {
+						const runtime = await params.ensureRuntime();
+						const handle = normalizeOptionalString(raw.handle);
+						if (!handle) throw new Error("handle is required");
+						const status = await runtime.status();
+						if (!status.helperConnected) throw new Error("FaceTime helper is not connected");
+						if (status.driverInstallPending) throw new Error("FaceTime audio driver installation is pending");
+						if (status.calls.length > 0 || status.outboundCallPending) throw new Error("another FaceTime call is active or pending");
+						const mode = raw.mode === "audio" || raw.mode === "video" ? raw.mode : void 0;
+						const { helper: _helper, ...publicResult } = await runtime.dial({
+							handle,
+							mode
+						});
+						return jsonResult({
+							ok: true,
+							action,
+							...publicResult
+						});
+					}
+					case "end_call": {
+						const result = await (await params.ensureRuntime()).hangup({ callUUID: normalizeOptionalString(raw.callUUID) });
+						return jsonResult({
+							ok: true,
+							action,
+							...result
+						});
+					}
+					default: throw new Error("action must be get_status, check_readiness, initiate_call, or end_call");
+				}
+			} catch (error) {
+				return jsonResult({
+					ok: false,
+					action,
+					error: formatErrorMessage(error)
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region extensions/facetime/index.ts
+const faceTimePlugin = definePluginEntry({
+	id: "facetime",
+	name: "FaceTime",
+	description: "Experimental private FaceTime realtime voice carrier for OpenClaw agents",
+	configSchema: { parse(value) {
+		return resolveFaceTimeConfig(value);
+	} },
+	register(api) {
+		const config = resolveFaceTimeConfig(api.pluginConfig);
+		const validation = validateFaceTimeConfig(config);
+		const pluginRoot = api.rootDir ?? api.resolvePath(".");
+		let runtimePromise;
+		let uninstalling = false;
+		const ensureRuntime = async () => {
+			if (uninstalling) throw new Error("facetime native uninstall is in progress");
+			if (!config.enabled) throw new Error("facetime disabled in plugin config");
+			if (!validation.valid) throw new Error(validation.errors.join("; "));
+			runtimePromise ??= import("./runtime-api.js").then(({ createFaceTimeRuntime }) => createFaceTimeRuntime({
+				config,
+				fullConfig: api.config,
+				runtime: api.runtime,
+				logger: api.logger,
+				pluginRoot
+			})).catch((error) => {
+				runtimePromise = void 0;
+				throw error;
+			});
+			return await runtimePromise;
+		};
+		const getStatus = async () => {
+			const current = runtimePromise;
+			if (current) try {
+				return await (await current).status();
+			} catch {}
+			return await inspectFaceTimeStaticStatus({
+				config,
+				configErrors: validation.errors,
+				pluginRoot,
+				runCommandWithTimeout: api.runtime.system.runCommandWithTimeout
+			});
+		};
+		api.registerTool(() => createFaceTimeCallTool({
+			ensureRuntime,
+			getStatus
+		}), { name: "facetime_call" });
+		api.on("before_tool_call", (event) => {
+			if (event.toolName !== "facetime_call") return;
+			return resolveFaceTimeToolApproval(event.params);
+		});
+		api.registerService({
+			id: "facetime-runtime",
+			async start() {
+				if (!config.enabled || !validation.valid) return;
+				try {
+					await ensureRuntime();
+				} catch (error) {
+					api.logger.warn(`[facetime] startup skipped: ${formatErrorMessage(error)}`);
+				}
+			},
+			async stop() {
+				await stopRetainedRuntime(runtimePromise, (stopped) => {
+					if (runtimePromise === stopped) runtimePromise = void 0;
+				});
+			}
+		});
+		const registerGateway = (name, scope, handler) => {
+			api.registerGatewayMethod(name, async (options) => {
+				try {
+					options.respond(true, await handler(options));
+				} catch (error) {
+					options.respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatErrorMessage(error)));
+				}
+			}, { scope });
+		};
+		registerGateway("facetime.status", "operator.read", getStatus);
+		registerGateway("facetime.setup", "operator.admin", async () => {
+			const nativePackageReady = await inspectFaceTimeNativePackage();
+			if (!nativePackageReady) return await runFaceTimeSetup({
+				config,
+				nativePackageReady,
+				pluginRoot,
+				runCommandWithTimeout: api.runtime.system.runCommandWithTimeout
+			});
+			let runtime;
+			try {
+				runtime = await ensureRuntime();
+			} catch (runtimeError) {
+				return await runFaceTimeSetup({
+					config,
+					nativePackageReady: await inspectFaceTimeNativePackage(),
+					pluginRoot,
+					runCommandWithTimeout: api.runtime.system.runCommandWithTimeout,
+					runtimeError: formatErrorMessage(runtimeError)
+				});
+			}
+			return await runtime.setup();
+		});
+		registerGateway("facetime.driverStatus", "operator.read", async () => ({ status: await inspectFaceTimeDriver({
+			pluginRoot,
+			runCommandWithTimeout: api.runtime.system.runCommandWithTimeout
+		}) }));
+		const installDriver = async () => ({
+			ok: true,
+			...await (await ensureRuntime()).installDriver()
+		});
+		for (const name of ["facetime.installDriver", "facetime.updateDriver"]) registerGateway(name, "operator.admin", installDriver);
+		registerGateway("facetime.uninstall", "operator.admin", async () => {
+			if (uninstalling) throw new Error("facetime native uninstall is already in progress");
+			uninstalling = true;
+			try {
+				const current = runtimePromise;
+				if (current) await stopRetainedRuntime(current, (stopped) => {
+					if (runtimePromise === stopped) runtimePromise = void 0;
+				});
+				await uninstallFaceTimeDriver({
+					pluginRoot,
+					runCommandWithTimeout: api.runtime.system.runCommandWithTimeout
+				});
+				return {
+					ok: true,
+					guidance: "Quit and reopen FaceTime and Phone before re-enabling this plugin."
+				};
+			} finally {
+				uninstalling = false;
+			}
+		});
+		registerGateway("facetime.preflight", "operator.admin", async () => await (await ensureRuntime()).preflight());
+		registerGateway("facetime.dial", "operator.write", async ({ params }) => {
+			const record = params && typeof params === "object" ? params : {};
+			const handle = "handle" in record ? record.handle : void 0;
+			const mode = "mode" in record ? record.mode : void 0;
+			return {
+				ok: true,
+				...await (await ensureRuntime()).dial({
+					handle,
+					mode
+				})
+			};
+		});
+		registerGateway("facetime.hangup", "operator.write", async ({ params }) => {
+			const callUUID = params && typeof params === "object" && "callUUID" in params ? params.callUUID : void 0;
+			return {
+				ok: true,
+				...await (await ensureRuntime()).hangup({ callUUID })
+			};
+		});
+	}
+});
+//#endregion
+export { faceTimePlugin as default };