| import { |
| asPositiveFiniteNumber as readPositiveNumber, |
| asSafeIntegerInRange, |
| } from "@openclaw/normalization-core/number-coercion"; |
| import { asOptionalRecord } from "@openclaw/normalization-core/record-coerce"; |
| import { readNonEmptyStringPreservingWhitespace as readNonEmptyString } from "@openclaw/normalization-core/string-coerce"; |
| import type { |
| OpenClawPluginNodeInvokePolicy, |
| OpenClawPluginNodeInvokePolicyResult, |
| } from "../plugins/plugin-registration.types.js"; |
| import type { MeetingAudioBackendSelection } from "./audio-backend.js"; |
| import { isMeetingAudioBase64 } from "./audio-base64.js"; |
| import type { MeetingRealtimeAudioFormat } from "./realtime-audio-format.js"; |
|
|
| export type MeetingBrowserNodeStartConfig = { |
| launch: boolean; |
| browserProfile?: string; |
| joinTimeoutMs: number; |
| audioBackend?: MeetingAudioBackendSelection; |
| audioBufferBytes?: number; |
| audioFormat?: MeetingRealtimeAudioFormat; |
| audioInputCommand?: string[]; |
| audioInputCommandOverride?: string[]; |
| audioOutputCommand?: string[]; |
| audioOutputCommandOverride?: string[]; |
| bargeInInputCommand?: string[]; |
| audioBridgeCommand?: string[]; |
| audioBridgeHealthCommand?: string[]; |
| }; |
|
|
| export type MeetingBrowserNodePolicyOptions = { |
| commandName: string; |
| displayName: string; |
| deniedCode: string; |
| supportedModes: ReadonlySet<string>; |
| normalizeUrl(input: unknown): string; |
| useConfiguredSetupCommands?: boolean; |
| start: MeetingBrowserNodeStartConfig; |
| }; |
|
|
| type PolicyDecision = |
| | { approved: true; params: Record<string, unknown> } |
| | { approved: false; result: OpenClawPluginNodeInvokePolicyResult }; |
|
|
| function readOutputGeneration(value: unknown): number | undefined { |
| return asSafeIntegerInRange(value, { min: 0 }); |
| } |
|
|
| function copyCommand(command: string[] | undefined): string[] | undefined { |
| return command && command.length > 0 ? [...command] : undefined; |
| } |
|
|
| function copyConfiguredAudio( |
| target: Record<string, unknown>, |
| start: MeetingBrowserNodeStartConfig, |
| ): void { |
| if ( |
| start.audioBackend === "auto" || |
| start.audioBackend === "blackhole-2ch" || |
| start.audioBackend === "pipewire-pulse" |
| ) { |
| target.audioBackend = start.audioBackend; |
| } |
| if (typeof start.audioBufferBytes === "number" && start.audioBufferBytes > 0) { |
| target.audioBufferBytes = start.audioBufferBytes; |
| } |
| if (start.audioFormat === "pcm16-24khz" || start.audioFormat === "g711-ulaw-8khz") { |
| target.audioFormat = start.audioFormat; |
| } |
| const hasCommandOverrideFields = |
| "audioInputCommandOverride" in start || "audioOutputCommandOverride" in start; |
| const audioInputCommand = copyCommand( |
| start.audioInputCommandOverride ?? |
| (hasCommandOverrideFields ? undefined : start.audioInputCommand), |
| ); |
| const audioOutputCommand = copyCommand( |
| start.audioOutputCommandOverride ?? |
| (hasCommandOverrideFields ? undefined : start.audioOutputCommand), |
| ); |
| if (audioInputCommand) { |
| target.audioInputCommand = audioInputCommand; |
| } |
| if (audioOutputCommand) { |
| target.audioOutputCommand = audioOutputCommand; |
| } |
| for (const key of [ |
| "bargeInInputCommand", |
| "audioBridgeCommand", |
| "audioBridgeHealthCommand", |
| ] as const) { |
| const command = copyCommand(start[key]); |
| if (command) { |
| target[key] = command; |
| } |
| } |
| } |
|
|
| function denied(options: MeetingBrowserNodePolicyOptions, message: string) { |
| return { ok: false as const, code: options.deniedCode, message }; |
| } |
|
|
| function approved(params: Record<string, unknown>): PolicyDecision { |
| return { approved: true, params }; |
| } |
|
|
| function buildStartParams( |
| params: Record<string, unknown>, |
| options: MeetingBrowserNodePolicyOptions, |
| ): PolicyDecision { |
| let url: string; |
| try { |
| url = options.normalizeUrl(params.url); |
| } catch (error) { |
| return { |
| approved: false, |
| result: denied( |
| options, |
| error instanceof Error ? error.message : `${options.commandName} start requires url`, |
| ), |
| }; |
| } |
| const mode = readNonEmptyString(params.mode); |
| if (mode && !options.supportedModes.has(mode)) { |
| return { |
| approved: false, |
| result: denied(options, `${options.commandName} start mode is unsupported: ${mode}`), |
| }; |
| } |
| const startParams: Record<string, unknown> = { |
| action: "start", |
| url, |
| launch: params.launch === false ? false : options.start.launch, |
| browserProfile: options.start.browserProfile, |
| joinTimeoutMs: options.start.joinTimeoutMs, |
| }; |
| if (mode) { |
| startParams.mode = mode; |
| } |
| copyConfiguredAudio(startParams, options.start); |
| return approved(startParams); |
| } |
|
|
| function denyMissing( |
| options: MeetingBrowserNodePolicyOptions, |
| action: string, |
| field: string, |
| ): PolicyDecision { |
| return { |
| approved: false, |
| result: denied(options, `${options.commandName} ${action} requires ${field}`), |
| }; |
| } |
|
|
| function buildForwardParams( |
| params: Record<string, unknown>, |
| options: MeetingBrowserNodePolicyOptions, |
| ): PolicyDecision | null { |
| const action = readNonEmptyString(params.action); |
| switch (action) { |
| case "setup": |
| return approved({ action }); |
| case "status": { |
| const bridgeId = readNonEmptyString(params.bridgeId); |
| return approved(bridgeId ? { action, bridgeId } : { action }); |
| } |
| case "list": { |
| const forwarded: Record<string, unknown> = { action }; |
| const url = readNonEmptyString(params.url); |
| const mode = readNonEmptyString(params.mode); |
| if (url) { |
| try { |
| forwarded.url = options.normalizeUrl(url); |
| } catch (error) { |
| return { |
| approved: false, |
| result: denied( |
| options, |
| error instanceof Error ? error.message : `${options.commandName} list url`, |
| ), |
| }; |
| } |
| } |
| if (mode) { |
| forwarded.mode = mode; |
| } |
| return approved(forwarded); |
| } |
| case "stopByUrl": { |
| const forwarded: Record<string, unknown> = { action }; |
| const url = readNonEmptyString(params.url); |
| const mode = readNonEmptyString(params.mode); |
| const exceptBridgeId = readNonEmptyString(params.exceptBridgeId); |
| if (!url) { |
| return denyMissing(options, action, "url"); |
| } |
| try { |
| forwarded.url = options.normalizeUrl(url); |
| } catch (error) { |
| return { |
| approved: false, |
| result: denied( |
| options, |
| error instanceof Error ? error.message : `${options.commandName} stopByUrl url`, |
| ), |
| }; |
| } |
| if (mode) { |
| forwarded.mode = mode; |
| } |
| if (exceptBridgeId) { |
| forwarded.exceptBridgeId = exceptBridgeId; |
| } |
| return approved(forwarded); |
| } |
| case "pullAudio": { |
| const forwarded: Record<string, unknown> = { action }; |
| const bridgeId = readNonEmptyString(params.bridgeId); |
| const timeoutMs = readPositiveNumber(params.timeoutMs); |
| if (!bridgeId) { |
| return denyMissing(options, action, "bridgeId"); |
| } |
| forwarded.bridgeId = bridgeId; |
| if (timeoutMs) { |
| forwarded.timeoutMs = timeoutMs; |
| } |
| return approved(forwarded); |
| } |
| case "pushAudio": { |
| const forwarded: Record<string, unknown> = { action }; |
| const bridgeId = readNonEmptyString(params.bridgeId); |
| const base64 = readNonEmptyString(params.base64); |
| if (!bridgeId) { |
| return denyMissing(options, action, "bridgeId"); |
| } |
| if (!base64) { |
| return denyMissing(options, action, "base64"); |
| } |
| if (!isMeetingAudioBase64(base64)) { |
| return { |
| approved: false, |
| result: denied(options, "base64 must be a valid audio payload"), |
| }; |
| } |
| forwarded.bridgeId = bridgeId; |
| forwarded.base64 = base64; |
| const outputGeneration = readOutputGeneration(params.outputGeneration); |
| if (params.outputGeneration !== undefined && outputGeneration === undefined) { |
| return { |
| approved: false, |
| result: denied(options, "outputGeneration must be a non-negative safe integer"), |
| }; |
| } |
| if (outputGeneration !== undefined) { |
| forwarded.outputGeneration = outputGeneration; |
| } |
| return approved(forwarded); |
| } |
| case "clearAudio": { |
| const bridgeId = readNonEmptyString(params.bridgeId); |
| if (!bridgeId) { |
| return denyMissing(options, action, "bridgeId"); |
| } |
| const outputGeneration = readOutputGeneration(params.outputGeneration); |
| if (params.outputGeneration !== undefined && outputGeneration === undefined) { |
| return { |
| approved: false, |
| result: denied(options, "outputGeneration must be a non-negative safe integer"), |
| }; |
| } |
| return approved({ |
| action, |
| bridgeId, |
| ...(outputGeneration !== undefined ? { outputGeneration } : {}), |
| }); |
| } |
| case "stop": { |
| const bridgeId = readNonEmptyString(params.bridgeId); |
| return approved(bridgeId ? { action, bridgeId } : { action }); |
| } |
| default: |
| return null; |
| } |
| } |
|
|
| export function createMeetingBrowserNodeInvokePolicy( |
| options: MeetingBrowserNodePolicyOptions, |
| ): OpenClawPluginNodeInvokePolicy { |
| return { |
| commands: [options.commandName], |
| dangerous: true, |
| async handle(ctx) { |
| if (ctx.command !== options.commandName) { |
| return denied(options, `unsupported ${options.displayName} node command: ${ctx.command}`); |
| } |
| const params = asOptionalRecord(ctx.params) ?? {}; |
| const action = readNonEmptyString(params.action); |
| if (action === "setup" && options.useConfiguredSetupCommands) { |
| const setupParams: Record<string, unknown> = { action }; |
| copyConfiguredAudio(setupParams, options.start); |
| return await ctx.invokeNode({ params: setupParams }); |
| } |
| const decision = |
| action === "start" |
| ? buildStartParams(params, options) |
| : (buildForwardParams(params, options) ?? { |
| approved: false as const, |
| result: denied(options, `unsupported ${options.commandName} action`), |
| }); |
| if (!decision.approved) { |
| return decision.result; |
| } |
| return await ctx.invokeNode({ params: decision.params }); |
| }, |
| }; |
| } |
|
|
