@openclaw/facetime 0.0.0 → 2026.9.6

package/src/runtime-state.ts

@@ -0,0 +1,213 @@
+import type { FaceTimeCallStatusEvent, AuthenticatedFaceTimeOwner } from "./call-events.js";
+import { FaceTimeCallInstance } from "./call-lifecycle.js";
+import type { HelperActionResult, FaceTimeHelperPeer } from "./helper-rpc.js";
+import type { FaceTimeHelperSupervisorStatus } from "./helper-supervisor.js";
+import type { FaceTimeDialMode, PendingFaceTimeDial } from "./outbound-call.js";
+import type { FaceTimeTalkDriver } from "./talk-driver.js";
+import type { FaceTimeTalkEventSummary } from "./talk-events-summary.js";
+
+export class ActiveFaceTimeCall extends FaceTimeCallInstance {
+  readonly carrierCallUUIDs: Set<string>;
+  readonly retiredCarrierCallUUIDs = new Set<string>();
+  carrierCallUUID: string;
+  readonly carrierPeers = new Map<number, FaceTimeHelperPeer>();
+  readonly senderId: string;
+  readonly senderIsOwner: true = true;
+  handle?: string;
+  callStatus?: number;
+  isSendingAudio?: boolean;
+  isSendingTransmission?: boolean;
+  isUplinkMuted?: boolean;
+  isSendingVideo?: boolean;
+  conversationUUID?: string;
+  conversationGroupUUID?: string;
+  conversationAudioEnabled?: boolean;
+  conversationVideoEnabled?: boolean;
+  conversationAVMode?: number;
+  conversationResolvedAudioVideoMode?: number;
+  localMeterLevel?: number;
+  remoteMeterLevel?: number;
+  maxLocalMeterLevel?: number;
+  maxRemoteMeterLevel?: number;
+  audioReady = false;
+  audioTransport?: {
+    captureBinary: string;
+    feedDevice: string;
+    microphoneDevice: string;
+    processInputVerified: boolean;
+    processOutputSuppressed: boolean;
+  };
+  lastHelperAction?: HelperActionResult;
+  lastRoutingError?: string;
+  audioRouting?: Promise<void>;
+  talk?: FaceTimeTalkDriver;
+  talkStarting?: Promise<void>;
+  talkActivation?: Promise<void>;
+  carrierHangupPending?: boolean;
+  carrierHangupRetryTimer?: NodeJS.Timeout;
+  carrierHangupAttempt?: Promise<boolean>;
+  readonly callUUID: string;
+
+  constructor(params: {
+    callUUID: string;
+    phase: "ringing" | "active";
+    owner: AuthenticatedFaceTimeOwner;
+    handle?: string;
+    peer?: FaceTimeHelperPeer;
+  }) {
+    super(params.callUUID, params.phase);
+    this.callUUID = params.callUUID;
+    this.carrierCallUUID = params.callUUID;
+    this.carrierCallUUIDs = new Set([params.callUUID]);
+    this.senderId = params.owner.senderId;
+    this.handle = params.handle;
+    if (params.peer) {
+      this.carrierPeers.set(params.peer.processId, params.peer);
+    }
+  }
+
+  promoteCarrierCallUUID(callUUID: string): void {
+    if (callUUID !== this.carrierCallUUID) {
+      this.retiredCarrierCallUUIDs.add(this.carrierCallUUID);
+      this.retiredCarrierCallUUIDs.delete(callUUID);
+    }
+    this.carrierCallUUIDs.add(callUUID);
+    this.carrierCallUUID = callUUID;
+  }
+}
+
+export type FaceTimeRuntimeStatus = {
+  enabled: true;
+  helperConnected: boolean;
+  helperProtocol: {
+    version: 1;
+    authentication: "mutual-hmac-sha256-v1";
+    eventIntegrity: "epoch-sequence-hmac-v1";
+    statusClassifier: "explicit-ended-tu-call-status-v1";
+    transportClassifier: "tu-provider-v1";
+  };
+  helperTargets: FaceTimeHelperSupervisorStatus;
+  driverInstallPending: boolean;
+  driverInstall: {
+    phase: "idle" | "installing" | "succeeded" | "failed";
+    startedAt?: string;
+    finishedAt?: string;
+    changed?: boolean;
+    error?: string;
+  };
+  processOutputSuppressed: boolean;
+  outboundCallPending?: {
+    dialID: string;
+    delivery: PendingFaceTimeDial["delivery"];
+    handle: string;
+    mode: FaceTimeDialMode;
+    requestedAt: string;
+    proxyIdentifier?: string;
+  };
+  calls: Array<{
+    callUUID: string;
+    generation: number;
+    phase: ActiveFaceTimeCall["phase"];
+    carrierMode: ActiveFaceTimeCall["carrierMode"];
+    modelMediaMode: ActiveFaceTimeCall["modelMediaMode"];
+    handle?: string;
+    callStatus?: number;
+    isSendingAudio?: boolean;
+    isSendingTransmission?: boolean;
+    isUplinkMuted?: boolean;
+    isSendingVideo?: boolean;
+    conversationUUID?: string;
+    conversationGroupUUID?: string;
+    conversationAudioEnabled?: boolean;
+    conversationVideoEnabled?: boolean;
+    conversationAVMode?: number;
+    conversationResolvedAudioVideoMode?: number;
+    localMeterLevel?: number;
+    remoteMeterLevel?: number;
+    maxLocalMeterLevel?: number;
+    maxRemoteMeterLevel?: number;
+    realtimeActive: boolean;
+    audioReady: boolean;
+    audioTransport?: ActiveFaceTimeCall["audioTransport"];
+    lastHelperAction?: HelperActionResult;
+    lastRoutingError?: string;
+    carrierHangupPending?: boolean;
+    recentTalkEvents?: FaceTimeTalkEventSummary[];
+  }>;
+};
+
+export function readCallUUID(event: FaceTimeCallStatusEvent): string {
+  return String(event.data.call_uuid);
+}
+
+export function updateCallStatus(call: ActiveFaceTimeCall, event: FaceTimeCallStatusEvent): void {
+  call.callStatus =
+    typeof event.data.call_status === "number" ? event.data.call_status : call.callStatus;
+  call.isSendingAudio =
+    typeof event.data.is_sending_audio === "boolean"
+      ? event.data.is_sending_audio
+      : call.isSendingAudio;
+  call.isSendingTransmission =
+    typeof event.data.is_sending_transmission === "boolean"
+      ? event.data.is_sending_transmission
+      : call.isSendingTransmission;
+  call.isUplinkMuted =
+    typeof event.data.is_uplink_muted === "boolean"
+      ? event.data.is_uplink_muted
+      : call.isUplinkMuted;
+  call.isSendingVideo =
+    typeof event.data.is_sending_video === "boolean"
+      ? event.data.is_sending_video
+      : call.isSendingVideo;
+  call.conversationUUID =
+    typeof event.data.conversation_uuid === "string"
+      ? event.data.conversation_uuid
+      : call.conversationUUID;
+  call.conversationGroupUUID =
+    typeof event.data.conversation_group_uuid === "string"
+      ? event.data.conversation_group_uuid
+      : call.conversationGroupUUID;
+  call.conversationAudioEnabled =
+    typeof event.data.conversation_audio_enabled === "boolean"
+      ? event.data.conversation_audio_enabled
+      : call.conversationAudioEnabled;
+  call.conversationVideoEnabled =
+    typeof event.data.conversation_video_enabled === "boolean"
+      ? event.data.conversation_video_enabled
+      : call.conversationVideoEnabled;
+  call.conversationAVMode =
+    typeof event.data.conversation_av_mode === "number"
+      ? event.data.conversation_av_mode
+      : call.conversationAVMode;
+  call.conversationResolvedAudioVideoMode =
+    typeof event.data.conversation_resolved_audio_video_mode === "number"
+      ? event.data.conversation_resolved_audio_video_mode
+      : call.conversationResolvedAudioVideoMode;
+  call.localMeterLevel =
+    typeof event.data.local_meter_level === "number"
+      ? event.data.local_meter_level
+      : call.localMeterLevel;
+  call.remoteMeterLevel =
+    typeof event.data.remote_meter_level === "number"
+      ? event.data.remote_meter_level
+      : call.remoteMeterLevel;
+  if (typeof event.data.local_meter_level === "number") {
+    call.maxLocalMeterLevel = Math.max(call.maxLocalMeterLevel ?? 0, event.data.local_meter_level);
+  }
+  if (typeof event.data.remote_meter_level === "number") {
+    call.maxRemoteMeterLevel = Math.max(
+      call.maxRemoteMeterLevel ?? 0,
+      event.data.remote_meter_level,
+    );
+  }
+}
+
+export function createManagedCall(params: {
+  callUUID: string;
+  phase: "ringing" | "active";
+  owner: AuthenticatedFaceTimeOwner;
+  handle?: string;
+  peer?: FaceTimeHelperPeer;
+}): ActiveFaceTimeCall {
+  return new ActiveFaceTimeCall(params);
+}

package/src/runtime-status.ts

@@ -0,0 +1,77 @@
+import type { FaceTimeCallRegistry } from "./call-lifecycle.js";
+import type { FaceTimeHelperSupervisorStatus } from "./helper-supervisor.js";
+import type { PendingFaceTimeDial } from "./outbound-call.js";
+import type { ActiveFaceTimeCall, FaceTimeRuntimeStatus } from "./runtime-state.js";
+import { summarizeRecentTalkEvents } from "./talk-events-summary.js";
+
+export function buildFaceTimeRuntimeStatus(params: {
+  calls: FaceTimeCallRegistry<ActiveFaceTimeCall>;
+  helperConnected: boolean;
+  helperTargets: FaceTimeHelperSupervisorStatus;
+  driverInstall: FaceTimeRuntimeStatus["driverInstall"];
+  pendingDial?: PendingFaceTimeDial;
+}): FaceTimeRuntimeStatus {
+  const calls = [...params.calls.values()];
+  return {
+    enabled: true,
+    helperConnected: params.helperConnected,
+    helperProtocol: {
+      version: 1,
+      authentication: "mutual-hmac-sha256-v1",
+      eventIntegrity: "epoch-sequence-hmac-v1",
+      statusClassifier: "explicit-ended-tu-call-status-v1",
+      transportClassifier: "tu-provider-v1",
+    },
+    helperTargets: params.helperTargets,
+    driverInstallPending: params.driverInstall.phase === "installing",
+    driverInstall: params.driverInstall,
+    processOutputSuppressed: calls.some((call) => call.talk?.processOutputSuppressed() === true),
+    outboundCallPending: params.pendingDial
+      ? {
+          dialID: params.pendingDial.dialID,
+          delivery: params.pendingDial.delivery,
+          handle: params.pendingDial.handle,
+          mode: params.pendingDial.mode,
+          requestedAt: params.pendingDial.requestedAt,
+          proxyIdentifier: params.pendingDial.proxyIdentifier,
+        }
+      : undefined,
+    calls: calls.map((call) => ({
+      callUUID: call.callUUID,
+      generation: call.generation,
+      phase: call.phase,
+      carrierMode: call.carrierMode,
+      modelMediaMode: call.modelMediaMode,
+      handle: call.handle,
+      callStatus: call.callStatus,
+      isSendingAudio: call.isSendingAudio,
+      isSendingTransmission: call.isSendingTransmission,
+      isUplinkMuted: call.isUplinkMuted,
+      isSendingVideo: call.isSendingVideo,
+      conversationUUID: call.conversationUUID,
+      conversationGroupUUID: call.conversationGroupUUID,
+      conversationAudioEnabled: call.conversationAudioEnabled,
+      conversationVideoEnabled: call.conversationVideoEnabled,
+      conversationAVMode: call.conversationAVMode,
+      conversationResolvedAudioVideoMode: call.conversationResolvedAudioVideoMode,
+      localMeterLevel: call.localMeterLevel,
+      remoteMeterLevel: call.remoteMeterLevel,
+      maxLocalMeterLevel: call.maxLocalMeterLevel,
+      maxRemoteMeterLevel: call.maxRemoteMeterLevel,
+      realtimeActive: call.talk?.realtimeActive() === true,
+      audioReady: call.audioReady,
+      audioTransport: call.audioTransport
+        ? {
+            ...call.audioTransport,
+            processOutputSuppressed: call.talk?.processOutputSuppressed() === true,
+          }
+        : undefined,
+      lastHelperAction: call.lastHelperAction,
+      lastRoutingError: call.lastRoutingError,
+      carrierHangupPending: call.carrierHangupPending,
+      recentTalkEvents: call.talk
+        ? summarizeRecentTalkEvents(call.talk.recentTalkEvents)
+        : undefined,
+    })),
+  };
+}