@openclaw/facetime 0.0.0 → 2026.9.6

package/scripts/verify-xcode-trust.sh

@@ -0,0 +1,152 @@
+#!/bin/sh
+set -eu
+
+if test "$#" -ne 1 || test -z "$1"; then
+  echo "Usage: $0 <Xcode.app>" >&2
+  exit 2
+fi
+
+xcode_app=$1
+apple_team_id="59GAB85EFG"
+failed=false
+
+reject() {
+  echo "$1" >&2
+  failed=true
+}
+
+remove_file() {
+  target=$1
+  if ! /usr/bin/trash "$target" >/dev/null 2>&1; then
+    /usr/bin/python3 -I -c 'import os, sys; p=sys.argv[1]; os.unlink(p) if os.path.lexists(p) else None' "$target"
+  fi
+}
+
+canonical_path() {
+  /usr/bin/python3 -I -c 'import os, sys; print(os.path.realpath(sys.argv[1]))' "$1"
+}
+
+has_standard_applications_acl() {
+  component=$1
+  test "$component" = "/Applications" || return 1
+  acl_lines=$(/bin/ls -lde "$component" | /usr/bin/sed -n '/^[[:space:]]*[0-9][0-9]*:/p')
+  test "$(printf '%s\n' "$acl_lines" | /usr/bin/grep -c .)" = "1" &&
+    printf '%s\n' "$acl_lines" |
+      /usr/bin/grep -Eq '^[[:space:]]*0:[[:space:]]+group:everyone[[:space:]]+deny[[:space:]]+delete$'
+}
+
+check_path_component_trust() {
+  component=$1
+  while :; do
+    if test "$(/usr/bin/stat -f '%u' "$component" 2>/dev/null || echo missing)" != "0"; then
+      reject "Xcode path component is not root-owned: $component"
+    fi
+    if /usr/bin/find "$component" -prune -perm -002 -print -quit | /usr/bin/grep -q .; then
+      reject "Xcode path component is group/world writable: $component"
+    fi
+    if /usr/bin/find "$component" -prune -perm -020 -print -quit | /usr/bin/grep -q .; then
+      # macOS ships /Applications as root:admin 0775. The approved admin user
+      # already authorizes this root operation, while the Xcode bundle and all
+      # tools below it remain root-owned, sealed, and non-writable.
+      if test "$component" != "/Applications" ||
+         test "$(/usr/bin/stat -f '%Sg' "$component" 2>/dev/null || echo missing)" != "admin" ||
+         test "$(/usr/bin/stat -f '%OLp' "$component" 2>/dev/null || echo missing)" != "775"; then
+        reject "Xcode path component is group/world writable: $component"
+      fi
+    fi
+    if /usr/bin/find "$component" -prune -acl -print | /usr/bin/grep -q . &&
+       ! has_standard_applications_acl "$component"; then
+      reject "Xcode path component has an access-control list that cannot be trusted for root compilation: $component"
+    fi
+    test "$component" = "/" && break
+    component=$(/usr/bin/dirname "$component")
+  done
+}
+
+check_apple_signature() {
+  target=$1
+  expected_identifier=$2
+  label=$3
+  details=$(/usr/bin/mktemp /private/tmp/openclaw-xcode-signature.XXXXXX)
+  if ! /usr/bin/codesign --verify --strict "$target" >/dev/null 2>&1 ||
+     ! /usr/bin/codesign -dv --verbose=4 "$target" >"$details" 2>&1; then
+    reject "$label is not signed by Apple: $target"
+    remove_file "$details"
+    return
+  fi
+  if /usr/bin/grep -qx 'Authority=Software Signing' "$details"; then
+    expected_intermediate='Authority=Apple Code Signing Certification Authority'
+  elif /usr/bin/grep -qx 'Authority=Apple Mac OS Application Signing' "$details"; then
+    expected_intermediate='Authority=Apple Worldwide Developer Relations Certification Authority'
+  else
+    expected_intermediate=''
+  fi
+  if ! /usr/bin/grep -qx "Identifier=$expected_identifier" "$details" ||
+     ! /usr/bin/grep -qx "TeamIdentifier=$apple_team_id" "$details" ||
+     test -z "$expected_intermediate" ||
+     ! /usr/bin/grep -qx "$expected_intermediate" "$details" ||
+     ! /usr/bin/grep -qx 'Authority=Apple Root CA' "$details"; then
+    reject "$label does not have the required Apple signing identity: $target"
+  fi
+  remove_file "$details"
+}
+
+if ! test -d "$xcode_app" || test -L "$xcode_app"; then
+  echo "Trusted Xcode is required as a real application at $xcode_app." >&2
+  exit 1
+fi
+
+canonical_xcode=$(canonical_path "$xcode_app")
+if test "$canonical_xcode" != "$xcode_app"; then
+  reject "Xcode must use its canonical path, not a symlink or redirected path: $xcode_app"
+fi
+
+check_path_component_trust "$canonical_xcode"
+if /usr/bin/find "$canonical_xcode" ! -user root -print -quit | /usr/bin/grep -q .; then
+  reject "Xcode and every bundled tool must be root-owned. Reinstall Xcode from Apple into /Applications using an administrator-managed install."
+fi
+if /usr/bin/find "$canonical_xcode" -perm -002 -print -quit | /usr/bin/grep -q . ||
+   /usr/bin/find "$canonical_xcode" -perm -020 ! -group wheel -print -quit | /usr/bin/grep -q .; then
+  reject "Xcode contains group/world-writable content. Reinstall Xcode from Apple; OpenClaw will not repair unsafe ownership or modes."
+fi
+if /usr/bin/find "$canonical_xcode" -acl -print -quit | /usr/bin/grep -q .; then
+  reject "Xcode contains access-control lists that cannot be trusted for root compilation. Reinstall Xcode from Apple."
+fi
+if ! /usr/bin/codesign --verify --deep --strict "$canonical_xcode" >/dev/null 2>&1; then
+  reject "The Xcode application seal is invalid. Reinstall Xcode from Apple before installing the FaceTime driver."
+fi
+check_apple_signature "$canonical_xcode" "com.apple.dt.Xcode" "Xcode"
+
+for tool_spec in \
+  "Contents/Developer/usr/bin/xcodebuild|com.apple.dt.xcodebuild|xcodebuild" \
+  "Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang|com.apple.clang|clang" \
+  "Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++|com.apple.clang|clang++" \
+  "Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/ld|com.apple.ld|ld" \
+  "Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/libtool|com.apple.libtool|libtool"
+do
+  relative_path=${tool_spec%%|*}
+  remainder=${tool_spec#*|}
+  expected_identifier=${remainder%%|*}
+  label=${remainder#*|}
+  tool="$canonical_xcode/$relative_path"
+  if ! test -x "$tool"; then
+    reject "Required Apple Xcode tool is missing or not executable: $tool"
+    continue
+  fi
+  canonical_tool=$(canonical_path "$tool")
+  case "$canonical_tool" in
+    "$canonical_xcode"/*) ;;
+    *)
+      reject "$label resolves outside the verified Xcode application: $tool"
+      continue
+      ;;
+  esac
+  check_path_component_trust "$canonical_tool"
+  check_apple_signature "$canonical_tool" "$expected_identifier" "$label"
+done
+
+if test "$failed" = true; then
+  exit 1
+fi
+
+printf 'Verified trusted Apple Xcode at %s\n' "$canonical_xcode"

package/skills/facetime/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: facetime
+description: "Inspect FaceTime internal stages, place an approved call to a configured owner handle, and request hangup through facetime_call."
+metadata:
+  { "openclaw": { "emoji": "📞", "requires": { "config": ["plugins.entries.facetime.enabled"] } } }
+allowed-tools: facetime_call
+---
+
+# FaceTime
+
+Use only `facetime_call`. Do not use shell commands or another call tool.
+
+- Use `get_status` or `check_readiness` for read-only inspection. Report the
+  returned fields as internal stages. Never infer that a remote participant
+  answered, heard audio, or can hear audio from readiness flags.
+- Use `initiate_call` only for the exact owner handle the user requested.
+  Default to `audio`; use `video` only on an explicit request. OpenClaw obtains
+  one-shot approval before dialing.
+- Report only the returned `pending` or `ringing` state. Do not invent a later
+  carrier state.
+- Use `end_call` to request hangup. A successful tool result means the request
+  entered the carrier lifecycle; report stronger closure only when a later
+  status result contains no active or pending call.
+- If a call or dial is already present, do not start another.
+- Never install/update/uninstall the driver, change SIP or developer-tools
+  policy, grant permissions, edit `ownerHandles`, or operate System Settings.
+  Those are explicit operator-admin actions.

package/skills/facetime/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "FaceTime Calls"
+  short_description: "Inspect and manage FaceTime calls for owner handles"
+  default_prompt: "Use $facetime to inspect internal stages or request a call to a configured owner handle."

package/src/audio-pump.ts

@@ -0,0 +1,498 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import type { Writable } from "node:stream";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import type { RuntimeLogger } from "openclaw/plugin-sdk/plugin-runtime";
+import type {
+  RealtimeVoiceAudioChunkMetadata,
+  RealtimeVoicePlaybackItem,
+} from "openclaw/plugin-sdk/realtime-voice";
+
+type PumpProcess = {
+  pid?: number;
+  killed?: boolean;
+  stdin?: (Writable & { writableLength?: number }) | null;
+  stdout?: { on(event: "data", listener: (chunk: Buffer | string) => void): unknown } | null;
+  stderr?: { on(event: "data", listener: (chunk: Buffer | string) => void): unknown } | null;
+  kill(signal?: NodeJS.Signals): boolean;
+  on(
+    event: "exit",
+    listener: (code: number | null, signal: NodeJS.Signals | null) => void,
+  ): unknown;
+  on(event: "error", listener: (error: Error) => void): unknown;
+};
+
+type SpawnFn = (
+  command: string,
+  args: string[],
+  options: {
+    env: NodeJS.ProcessEnv;
+    stdio: ["pipe" | "ignore", "pipe" | "ignore", "pipe" | "ignore"];
+  },
+) => PumpProcess;
+
+const CAFFEINATE_COMMAND = "/usr/bin/caffeinate";
+const CAPTURE_CLOSE_SAFE_FRAME = Buffer.from([4, 0, 0, 0, 4, 0, 0, 0, 0]);
+const FACETIME_AUDIO_SAMPLE_RATE_HZ = 24_000;
+const OUTPUT_LATENCY_BUDGET_MS = 100;
+// The paired device renders 48 kHz float32 stereo. This gives Core Audio about
+// 21 ms of output buffering, enough to survive ordinary scheduler jitter.
+const SOX_COREAUDIO_BUFFER_BYTES = 8 * 1024;
+const SOX_COMMAND =
+  [
+    process.env.HOME ? `${process.env.HOME}/.homebrew/bin/sox` : undefined,
+    "/opt/homebrew/bin/sox",
+    "/usr/local/bin/sox",
+  ].find((path): path is string => Boolean(path && existsSync(path))) ?? "sox";
+export const FACETIME_FEED_DEVICE_NAME = "OpenClaw-Feed";
+export const FACETIME_MIC_DEVICE_NAME = "OpenClaw-Mic";
+const MAX_PLAYBACK_BUFFERED_BYTES = 2 * 1024 * 1024;
+
+type FaceTimeAudioPump = {
+  suppressionReady(): Promise<void>;
+  routeReady(): Promise<void>;
+  processOutputSuppressed(): boolean;
+  writeOutputAudio(audio: Buffer, metadata?: RealtimeVoiceAudioChunkMetadata): void;
+  getPlaybackState(): RealtimeVoicePlaybackItem[];
+  finishOutputAudio(): void;
+  clearOutputAudio(): void;
+  playedAudioFrames(): number;
+  queuedAudioFrames(): number;
+  suspendMedia(): Promise<void>;
+  stop(): Promise<void>;
+};
+
+function sanitizedAudioChildEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  return Object.fromEntries(
+    Object.entries(env).filter(
+      ([key]) => !/(?:API_?KEY|AUTH|CREDENTIAL|PASSWORD|SECRET|TOKEN)/iu.test(key),
+    ),
+  );
+}
+
+class PlaybackClock {
+  private generatedFrames = 0;
+  private playedFramesBeforeSegment = 0;
+  private playbackStartsAtMs = 0;
+  private playbackUntilMs = 0;
+  private retiredFrames = 0;
+  private items: Array<{ itemId?: string; frames: number }> = [];
+
+  append(frames: number, itemId?: string, nowMs = Date.now()): void {
+    if (nowMs >= this.playbackUntilMs) {
+      this.playedFramesBeforeSegment = this.generatedFrames;
+      this.playbackStartsAtMs = nowMs + OUTPUT_LATENCY_BUDGET_MS;
+      this.playbackUntilMs = this.playbackStartsAtMs;
+    }
+    this.generatedFrames += frames;
+    this.playbackUntilMs += (frames / FACETIME_AUDIO_SAMPLE_RATE_HZ) * 1000;
+    const previous = this.items.at(-1);
+    if (previous && previous.itemId === itemId) {
+      previous.frames += frames;
+    } else {
+      this.items.push({ itemId, frames });
+    }
+  }
+
+  playbackState(): RealtimeVoicePlaybackItem[] {
+    let remaining = Math.max(0, this.playedFrames() - this.retiredFrames);
+    const playedByItem = new Map<string, number>();
+    for (const item of this.items) {
+      const consumed = Math.min(remaining, item.frames);
+      remaining -= consumed;
+      if (item.itemId) {
+        playedByItem.set(item.itemId, (playedByItem.get(item.itemId) ?? 0) + consumed);
+      }
+    }
+    return Array.from(playedByItem, ([itemId, frames]) => ({
+      itemId,
+      audioEndMs: Math.floor((frames * 1000) / FACETIME_AUDIO_SAMPLE_RATE_HZ),
+    }));
+  }
+
+  retireItems(): void {
+    this.items = [];
+    this.retiredFrames = this.generatedFrames;
+  }
+
+  playedFrames(nowMs = Date.now()): number {
+    if (nowMs <= this.playbackStartsAtMs) {
+      return this.playedFramesBeforeSegment;
+    }
+    const elapsedFrames =
+      ((nowMs - this.playbackStartsAtMs) / 1000) * FACETIME_AUDIO_SAMPLE_RATE_HZ;
+    return Math.min(this.generatedFrames, this.playedFramesBeforeSegment + elapsedFrames);
+  }
+
+  queuedFrames(nowMs = Date.now()): number {
+    return Math.max(0, this.generatedFrames - this.playedFrames(nowMs));
+  }
+
+  millisecondsUntilDrained(nowMs = Date.now()): number {
+    return Math.max(0, this.playbackUntilMs - nowMs);
+  }
+
+  reset(): void {
+    this.generatedFrames = 0;
+    this.playedFramesBeforeSegment = 0;
+    this.playbackStartsAtMs = 0;
+    this.playbackUntilMs = 0;
+    this.retireItems();
+  }
+}
+
+function buildSoxOutputArguments(): string[] {
+  return [
+    "-q",
+    "--buffer",
+    String(SOX_COREAUDIO_BUFFER_BYTES),
+    "-t",
+    "raw",
+    "-r",
+    String(FACETIME_AUDIO_SAMPLE_RATE_HZ),
+    "-c",
+    "1",
+    "-e",
+    "signed-integer",
+    "-b",
+    "16",
+    "-L",
+    "-",
+    "-t",
+    "coreaudio",
+    FACETIME_FEED_DEVICE_NAME,
+  ];
+}
+
+async function terminateProcess(proc: PumpProcess, signal: NodeJS.Signals = "SIGTERM") {
+  if (proc.killed && signal !== "SIGKILL") {
+    return;
+  }
+  let exited = false;
+  const exitedPromise = new Promise<void>((resolve) => {
+    proc.on("exit", () => {
+      exited = true;
+      resolve();
+    });
+  });
+  try {
+    proc.kill(signal);
+  } catch {
+    return;
+  }
+  await Promise.race([
+    exitedPromise,
+    new Promise<void>((resolve) => {
+      const timer = setTimeout(resolve, 500);
+      timer.unref?.();
+    }),
+  ]);
+  if (!exited && signal !== "SIGKILL") {
+    try {
+      proc.kill("SIGKILL");
+    } catch {
+      return;
+    }
+    await Promise.race([
+      exitedPromise,
+      new Promise<void>((resolve) => {
+        const timer = setTimeout(resolve, 500);
+        timer.unref?.();
+      }),
+    ]);
+  }
+}
+
+export function startFaceTimeAudioPump(params: {
+  captureBinary: string;
+  logger: RuntimeLogger;
+  onInputAudio: (audio: Buffer) => void;
+  onError?: (error: Error) => boolean | void | Promise<boolean | void>;
+  onSuppressionLost?: (error: Error) => void | Promise<void>;
+  onPlaybackDrained?: (event: { generation: number; playedFrames: number }) => void;
+  spawn?: SpawnFn;
+}): FaceTimeAudioPump {
+  const spawnFn: SpawnFn =
+    params.spawn ?? ((command, args, options) => spawn(command, args, options));
+  const childEnv = sanitizedAudioChildEnv();
+  const playbackClock = new PlaybackClock();
+  let playbackGeneration = 1;
+  let drainTimer: NodeJS.Timeout | undefined;
+  let outputProcess: PumpProcess;
+  const captureProcess = spawnFn(params.captureBinary, [], {
+    env: childEnv,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  let stopped = false;
+  let mediaSuspended = false;
+  let captureSuppressionActive = false;
+  let captureFailureReported = false;
+  let captureReadySettled = false;
+  let routeReadySettled = false;
+  let routeReadyTimer: NodeJS.Timeout | undefined;
+  let captureStderr = "";
+  let resolveCaptureReady = () => {};
+  let rejectCaptureReady = (_error: Error) => {};
+  const captureReadyPromise = new Promise<void>((resolve, reject) => {
+    resolveCaptureReady = resolve;
+    rejectCaptureReady = reject;
+  });
+  let resolveRouteReady = () => {};
+  let rejectRouteReady = (_error: Error) => {};
+  const routeReadyPromise = new Promise<void>((resolve, reject) => {
+    resolveRouteReady = resolve;
+    rejectRouteReady = reject;
+  });
+  void captureReadyPromise.catch(() => {});
+  void routeReadyPromise.catch(() => {});
+
+  const settleCaptureReady = (error?: Error) => {
+    if (captureReadySettled) {
+      return;
+    }
+    captureReadySettled = true;
+    clearTimeout(captureReadyTimer);
+    if (error) {
+      rejectCaptureReady(error);
+    } else {
+      resolveCaptureReady();
+    }
+  };
+  const settleRouteReady = (error?: Error) => {
+    if (routeReadySettled) {
+      return;
+    }
+    routeReadySettled = true;
+    if (routeReadyTimer) {
+      clearTimeout(routeReadyTimer);
+      routeReadyTimer = undefined;
+    }
+    if (error) {
+      rejectRouteReady(error);
+    } else {
+      resolveRouteReady();
+    }
+  };
+  const reportFailure = (error: Error, suppressionLost: boolean) => {
+    if (stopped) {
+      return;
+    }
+    if (suppressionLost) {
+      captureSuppressionActive = false;
+      void params.onSuppressionLost?.(error);
+    }
+    settleCaptureReady(error);
+    settleRouteReady(error);
+    params.logger.warn(`[facetime] native audio bridge failed: ${formatErrorMessage(error)}`);
+    void Promise.resolve(params.onError?.(error)).then((safeToStop) => {
+      if (safeToStop !== false) {
+        void stop();
+      }
+    });
+  };
+  const cancelDrainTimer = () => {
+    if (drainTimer) {
+      clearTimeout(drainTimer);
+      drainTimer = undefined;
+    }
+  };
+  const spawnOutput = () => {
+    // Playback stays out of the capture helper: an in-process AVAudioEngine can
+    // rebind OpenClaw-Feed after FaceTime claims it and tear down the carrier.
+    const proc = spawnFn(SOX_COMMAND, buildSoxOutputArguments(), {
+      env: childEnv,
+      stdio: ["pipe", "ignore", "pipe"],
+    });
+    proc.on("error", (error) => {
+      if (!stopped && !mediaSuspended && proc === outputProcess) {
+        reportFailure(error, false);
+      }
+    });
+    proc.stdin?.on("error", (error) => {
+      if (!stopped && !mediaSuspended && proc === outputProcess) {
+        reportFailure(error, false);
+      }
+    });
+    proc.on("exit", (code, signal) => {
+      if (!stopped && !mediaSuspended && proc === outputProcess) {
+        reportFailure(new Error(`SoX playback exited (${code ?? signal ?? "done"})`), false);
+      }
+    });
+    proc.stderr?.on("data", (chunk) => {
+      if (proc === outputProcess) {
+        params.logger.debug?.(`[facetime] SoX playback: ${String(chunk).trim()}`);
+      }
+    });
+    return proc;
+  };
+  outputProcess = spawnOutput();
+  const captureReadyTimer = setTimeout(() => {
+    reportFailure(new Error("FaceTime process tap was not ready within 10 seconds"), true);
+  }, 10_000);
+  captureReadyTimer.unref?.();
+  const startRouteReadyTimer = () => {
+    if (routeReadySettled || routeReadyTimer) {
+      return;
+    }
+    routeReadyTimer = setTimeout(() => {
+      reportFailure(new Error("FaceTime input route was not verified within 15 seconds"), true);
+    }, 15_000);
+    routeReadyTimer.unref?.();
+  };
+  const clearPlayback = () => {
+    if (stopped || mediaSuspended) {
+      return;
+    }
+    const previous = outputProcess;
+    outputProcess = spawnOutput();
+    playbackGeneration += 1;
+    cancelDrainTimer();
+    playbackClock.reset();
+    void terminateProcess(previous, "SIGKILL");
+  };
+  const stop = async () => {
+    if (stopped) {
+      return;
+    }
+    mediaSuspended = true;
+    captureSuppressionActive = false;
+    settleCaptureReady(new Error("FaceTime native audio bridge stopped before readiness"));
+    settleRouteReady(new Error("FaceTime input route stopped before verification"));
+    cancelDrainTimer();
+    playbackClock.reset();
+    try {
+      captureProcess.stdin?.write(CAPTURE_CLOSE_SAFE_FRAME);
+      captureProcess.stdin?.end();
+    } catch {
+      // Process exit below remains joined.
+    }
+    stopped = true;
+    await Promise.all([
+      terminateProcess(captureProcess),
+      terminateProcess(outputProcess, "SIGKILL"),
+      wakeProcess ? terminateProcess(wakeProcess) : Promise.resolve(),
+    ]);
+  };
+  const wakeProcess = existsSync(CAFFEINATE_COMMAND)
+    ? spawnFn(
+        CAFFEINATE_COMMAND,
+        ["-d", "-i", ...(captureProcess.pid ? ["-w", String(captureProcess.pid)] : [])],
+        { env: childEnv, stdio: ["ignore", "ignore", "pipe"] },
+      )
+    : undefined;
+  wakeProcess?.on("error", () => undefined);
+  captureProcess.on("error", (error) => reportFailure(error, true));
+  captureProcess.stdin?.on("error", (error) => reportFailure(error, false));
+  captureProcess.on("exit", (code, signal) => {
+    if (!stopped) {
+      reportFailure(new Error(`native audio bridge exited (${code ?? signal ?? "done"})`), true);
+    }
+  });
+  captureProcess.stderr?.on("data", (chunk) => {
+    const message = String(chunk);
+    captureStderr = `${captureStderr}${message}`.slice(-8192);
+    for (const line of captureStderr.split(/\r?\n/u).slice(0, -1)) {
+      if (line.includes("started FaceTime process tap")) {
+        captureSuppressionActive = true;
+        settleCaptureReady();
+      }
+      if (line.includes("verified OpenClaw-Mic input route")) {
+        settleRouteReady();
+      }
+      const fatal = line.match(/facetime-audio-capture: fatal(?:-safety-retained)?:\s*(.*)$/u);
+      if (!captureFailureReported && fatal) {
+        captureFailureReported = true;
+        const detail = fatal[1]?.trim();
+        reportFailure(
+          new Error(
+            detail
+              ? `native FaceTime safety monitor reported a fatal error: ${detail}`
+              : "native FaceTime safety monitor reported a fatal error",
+          ),
+          false,
+        );
+      }
+    }
+    captureStderr = captureStderr.split(/\r?\n/u).at(-1) ?? "";
+  });
+  captureProcess.stdout?.on("data", (chunk) => {
+    if (!stopped && !mediaSuspended) {
+      const audio = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      if (audio.byteLength > 0) {
+        params.onInputAudio(audio);
+      }
+    }
+  });
+
+  return {
+    suppressionReady: async () => await captureReadyPromise,
+    routeReady: async () => {
+      startRouteReadyTimer();
+      await routeReadyPromise;
+    },
+    processOutputSuppressed: () => captureSuppressionActive,
+    writeOutputAudio(audio, metadata) {
+      if (stopped || mediaSuspended || audio.byteLength === 0) {
+        return;
+      }
+      const bufferedBytes = outputProcess.stdin?.writableLength ?? 0;
+      if (bufferedBytes + audio.byteLength > MAX_PLAYBACK_BUFFERED_BYTES) {
+        reportFailure(new Error("SoX playback queue exceeded 2 MiB"), false);
+        return;
+      }
+      if (!outputProcess.stdin) {
+        reportFailure(new Error("SoX playback stdin is unavailable"), false);
+        return;
+      }
+      try {
+        cancelDrainTimer();
+        outputProcess.stdin.write(audio);
+        playbackClock.append(audio.byteLength / 2, metadata?.itemId);
+      } catch (error) {
+        reportFailure(error instanceof Error ? error : new Error(formatErrorMessage(error)), false);
+      }
+    },
+    finishOutputAudio() {
+      if (stopped || mediaSuspended) {
+        return;
+      }
+      if (playbackClock.queuedFrames() <= 0) {
+        playbackClock.retireItems();
+        return;
+      }
+      cancelDrainTimer();
+      const generation = playbackGeneration;
+      const notifyWhenDrained = () => {
+        if (stopped || mediaSuspended || generation !== playbackGeneration) {
+          return;
+        }
+        const delayMs = Math.ceil(playbackClock.millisecondsUntilDrained());
+        if (delayMs > 0) {
+          drainTimer = setTimeout(notifyWhenDrained, Math.max(1, delayMs));
+          drainTimer.unref?.();
+          return;
+        }
+        drainTimer = undefined;
+        playbackClock.retireItems();
+        params.onPlaybackDrained?.({
+          generation,
+          playedFrames: Math.floor(playbackClock.playedFrames()),
+        });
+      };
+      notifyWhenDrained();
+    },
+    getPlaybackState: () => playbackClock.playbackState(),
+    clearOutputAudio: clearPlayback,
+    playedAudioFrames: () => Math.floor(playbackClock.playedFrames()),
+    queuedAudioFrames: () => Math.ceil(playbackClock.queuedFrames()),
+    async suspendMedia() {
+      if (!stopped && !mediaSuspended) {
+        mediaSuspended = true;
+        cancelDrainTimer();
+        playbackClock.reset();
+        await terminateProcess(outputProcess, "SIGKILL");
+      }
+    },
+    stop,
+  };
+}