@pmate/chat-sdk 0.5.1 → 0.6.1

package/lib/index.d.ts

@@ -32,3 +32,4 @@ export * from "./mentions/model";
 export * from "./hooks/useMentions";
 export * from "./components/MentionMenu";
 export * from "./runtime/activity";
+export * from "./runtime/call";

package/lib/index.js

@@ -32,3 +32,4 @@ export * from "./mentions/model";
 export * from "./hooks/useMentions";
 export * from "./components/MentionMenu";
 export * from "./runtime/activity";
+export * from "./runtime/call";

package/lib/runtime/call.d.ts

@@ -0,0 +1,72 @@
+export type CallPhase = "idle" | "requesting" | "ringing" | "incoming" | "connecting" | "connected" | "ended";
+export type CallSnapshot = {
+    phase: CallPhase;
+    ready: boolean;
+    callId?: string;
+    peerId?: string;
+    direction?: "incoming" | "outgoing";
+    startedAt?: number;
+    muted: boolean;
+    sharing: boolean;
+    remoteSharing: boolean;
+    remoteStream?: MediaStream;
+    localScreen?: MediaStream;
+    error?: string;
+    reason?: string;
+};
+export type CallEnded = {
+    peerId: string;
+    callId: string;
+    direction: "incoming" | "outgoing";
+    reason: string;
+    durationMs: number;
+};
+export type CallClientOptions = {
+    profileId: string;
+    token: string;
+    url?: string;
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    onEnded?: (event: CallEnded) => void;
+    mediaDevices?: Pick<MediaDevices, "getUserMedia" | "getDisplayMedia">;
+    createPeerConnection?: (config: RTCConfiguration) => RTCPeerConnection;
+    createWebSocket?: (url: string) => WebSocket;
+};
+/** Explicit user actions own microphone/display capture. No media is acquired on incoming calls. */
+export declare class CallClient {
+    private options;
+    private state;
+    private listeners;
+    private ws?;
+    private pc?;
+    private microphone?;
+    private screen?;
+    private video?;
+    private candidates;
+    private generation;
+    private closed;
+    private capturePending;
+    private requestId?;
+    private heartbeat?;
+    private timeout?;
+    private reconnect?;
+    private queue;
+    constructor(options: CallClientOptions);
+    snapshot(): CallSnapshot;
+    subscribe(listener: (state: CallSnapshot) => void): () => void;
+    connect(): void;
+    start(peerId: string): Promise<void>;
+    accept(): Promise<void>;
+    hangup(): void;
+    dismiss(): void;
+    mute(): void;
+    shareScreen(): Promise<void>;
+    stopSharing(): Promise<void>;
+    close(): void;
+    private update;
+    private send;
+    private acquireMicrophone;
+    private armTimeout;
+    private fail;
+    private release;
+    private receive;
+}

package/lib/runtime/call.js

@@ -0,0 +1,309 @@
+/** Explicit user actions own microphone/display capture. No media is acquired on incoming calls. */
+export class CallClient {
+    options;
+    state = { phase: "idle", ready: false, muted: false, sharing: false, remoteSharing: false };
+    listeners = new Set();
+    ws;
+    pc;
+    microphone;
+    screen;
+    video;
+    candidates = [];
+    generation = 0;
+    closed = false;
+    capturePending = false;
+    requestId;
+    heartbeat;
+    timeout;
+    reconnect;
+    queue = Promise.resolve();
+    constructor(options) {
+        this.options = options;
+    }
+    snapshot() { return this.state; }
+    subscribe(listener) { this.listeners.add(listener); listener(this.state); return () => { this.listeners.delete(listener); }; }
+    connect() {
+        if (this.closed || this.ws)
+            return;
+        const ws = (this.options.createWebSocket ?? (url => new WebSocket(url)))(this.options.url ?? "wss://calls.pmate.chat/call");
+        this.ws = ws;
+        ws.onopen = () => { if (this.ws === ws)
+            this.send({ type: "auth", token: this.options.token, profileId: this.options.profileId }); };
+        ws.onmessage = event => {
+            if (this.ws !== ws)
+                return;
+            this.queue = this.queue.then(async () => {
+                if (this.ws !== ws)
+                    return;
+                const gen = this.generation;
+                try {
+                    await this.receive(JSON.parse(String(event.data)));
+                }
+                catch {
+                    if (gen === this.generation)
+                        this.fail("CONNECTION_FAILED");
+                }
+            });
+        };
+        ws.onerror = () => { };
+        ws.onclose = event => {
+            if (this.ws !== ws)
+                return;
+            this.ws = undefined;
+            clearInterval(this.heartbeat);
+            const active = !["idle", "ended"].includes(this.state.phase);
+            this.release();
+            this.update({ ready: false, phase: active ? "ended" : this.state.phase, error: event.code === 1008 ? "UNAUTHORIZED" : "DISCONNECTED" });
+            if (!this.closed && event.code !== 1008)
+                this.reconnect = setTimeout(() => this.connect(), 3000);
+        };
+    }
+    async start(peerId) {
+        if (!this.state.ready || !["idle", "ended"].includes(this.state.phase))
+            return;
+        this.release();
+        this.update({ phase: "requesting", peerId, direction: "outgoing", error: undefined, reason: undefined, callId: undefined, startedAt: undefined });
+        const gen = this.generation;
+        this.requestId = String(gen);
+        try {
+            if (!await this.acquireMicrophone(gen))
+                return;
+            this.send({ type: "invite", peerId, requestId: this.requestId });
+            this.armTimeout(40000);
+        }
+        catch {
+            if (gen === this.generation)
+                this.fail("MICROPHONE_DENIED");
+        }
+    }
+    async accept() {
+        if (this.state.phase !== "incoming" || this.capturePending)
+            return;
+        const gen = this.generation;
+        this.capturePending = true;
+        this.update({ phase: "connecting", error: undefined });
+        try {
+            if (!await this.acquireMicrophone(gen))
+                return;
+            this.send({ type: "accept", callId: this.state.callId });
+            this.armTimeout(30000);
+        }
+        catch {
+            if (gen === this.generation)
+                this.fail("MICROPHONE_DENIED");
+        }
+        finally {
+            if (gen === this.generation)
+                this.capturePending = false;
+        }
+    }
+    hangup() {
+        if (this.state.callId && !["idle", "ended"].includes(this.state.phase))
+            this.send({ type: "hangup", callId: this.state.callId });
+        this.release();
+        this.update({ phase: "ended", reason: "cancelled" });
+    }
+    dismiss() { if (this.state.phase === "ended")
+        this.update({ phase: "idle", error: undefined, reason: undefined, callId: undefined, peerId: undefined }); }
+    mute() {
+        const muted = !this.state.muted;
+        this.microphone?.getAudioTracks().forEach(track => { track.enabled = !muted; });
+        this.update({ muted });
+    }
+    async shareScreen() {
+        if (this.state.phase !== "connected" || !this.video || this.capturePending)
+            return;
+        if (this.screen)
+            return this.stopSharing();
+        const gen = this.generation;
+        this.capturePending = true;
+        try {
+            const media = this.options.mediaDevices ?? navigator.mediaDevices;
+            if (!media.getDisplayMedia)
+                throw new Error("unsupported");
+            const stream = await media.getDisplayMedia({ video: { frameRate: { ideal: 15, max: 30 }, width: { ideal: 1920 }, height: { ideal: 1080 } }, audio: false });
+            if (gen !== this.generation) {
+                stream.getTracks().forEach(t => t.stop());
+                return;
+            }
+            this.screen = stream;
+            const track = stream.getVideoTracks()[0];
+            if (!track)
+                throw new Error("No display track");
+            track.contentHint = "detail";
+            await this.video.sender.replaceTrack(track);
+            if (gen !== this.generation)
+                return;
+            track.onended = () => { if (gen === this.generation)
+                void this.stopSharing(); };
+            this.send({ type: "sharing", callId: this.state.callId, active: true });
+            this.update({ sharing: true, localScreen: stream, error: undefined });
+        }
+        catch (error) {
+            if (gen === this.generation) {
+                await this.stopSharing();
+                if (!(error instanceof DOMException && error.name === "NotAllowedError"))
+                    this.update({ error: "SCREEN_UNAVAILABLE" });
+            }
+        }
+        finally {
+            if (gen === this.generation)
+                this.capturePending = false;
+        }
+    }
+    async stopSharing() {
+        const gen = this.generation;
+        const screen = this.screen;
+        this.screen = undefined;
+        screen?.getTracks().forEach(t => { t.onended = null; t.stop(); });
+        try {
+            await this.video?.sender.replaceTrack(null);
+        }
+        catch { /* peer may have closed */ }
+        if (gen !== this.generation)
+            return;
+        this.send({ type: "sharing", callId: this.state.callId, active: false });
+        this.update({ sharing: false, localScreen: undefined });
+    }
+    close() {
+        this.closed = true;
+        clearTimeout(this.reconnect);
+        clearInterval(this.heartbeat);
+        this.hangup();
+        this.ws?.close();
+        this.ws = undefined;
+        this.update({ ready: false });
+        this.listeners.clear();
+    }
+    update(patch) { this.state = { ...this.state, ...patch }; this.listeners.forEach(fn => fn(this.state)); }
+    send(message) { if (this.ws?.readyState === 1)
+        this.ws.send(JSON.stringify(message)); }
+    async acquireMicrophone(gen) {
+        const stream = await (this.options.mediaDevices ?? navigator.mediaDevices).getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true }, video: false });
+        if (gen !== this.generation) {
+            stream.getTracks().forEach(t => t.stop());
+            return false;
+        }
+        this.microphone = stream;
+        stream.getAudioTracks().forEach(track => { track.onended = () => { if (gen === this.generation)
+            this.fail("MICROPHONE_DENIED"); }; });
+        return true;
+    }
+    armTimeout(ms) { clearTimeout(this.timeout); this.timeout = setTimeout(() => this.fail("CONNECTION_TIMEOUT"), ms); }
+    fail(error) { this.hangup(); this.update({ error }); }
+    release() {
+        this.generation++;
+        clearTimeout(this.timeout);
+        this.capturePending = false;
+        this.pc?.close();
+        this.pc = undefined;
+        this.video = undefined;
+        this.candidates = [];
+        for (const stream of [this.microphone, this.screen])
+            stream?.getTracks().forEach(t => { t.onended = null; t.stop(); });
+        this.microphone = undefined;
+        this.screen = undefined;
+        this.update({ muted: false, sharing: false, remoteSharing: false, remoteStream: undefined, localScreen: undefined });
+    }
+    async receive(message) {
+        if (message.type === "ready") {
+            this.update({ ready: true, error: undefined });
+            clearInterval(this.heartbeat);
+            this.heartbeat = setInterval(() => this.send({ type: "ping" }), 20000);
+            return;
+        }
+        if (message.type === "pong")
+            return;
+        if (message.type === "error") {
+            if (message.requestId && message.requestId !== this.requestId)
+                return;
+            if (!message.callId || message.callId === this.state.callId)
+                this.fail(message.code);
+            return;
+        }
+        if (message.type === "ringing") {
+            if (message.direction === "outgoing" && (this.state.phase !== "requesting" || message.requestId !== this.requestId)) {
+                this.send({ type: "hangup", callId: message.callId });
+                return;
+            }
+            if (message.direction === "incoming" && !["idle", "ended"].includes(this.state.phase)) {
+                this.send({ type: "hangup", callId: message.callId });
+                return;
+            }
+            this.update({ phase: message.direction === "incoming" ? "incoming" : "ringing", callId: message.callId, peerId: message.peerId, direction: message.direction, error: undefined, reason: undefined, startedAt: undefined });
+            this.armTimeout(35000);
+            return;
+        }
+        if (message.callId !== this.state.callId)
+            return;
+        if (message.type === "ended") {
+            const event = { callId: message.callId, peerId: this.state.peerId, direction: this.state.direction, reason: message.reason, durationMs: message.durationMs };
+            this.release();
+            this.update({ phase: "ended", reason: message.reason });
+            this.options.onEnded?.(event);
+            return;
+        }
+        if (["idle", "ended"].includes(this.state.phase))
+            return;
+        const gen = this.generation;
+        if (message.type === "accepted") {
+            this.update({ phase: "connecting" });
+            this.armTimeout(30000);
+            const pc = (this.options.createPeerConnection ?? (config => new RTCPeerConnection(config)))({ iceServers: message.iceServers, iceTransportPolicy: this.options.iceTransportPolicy ?? "all" });
+            this.pc = pc;
+            const microphone = this.microphone;
+            for (const track of microphone.getAudioTracks())
+                pc.addTrack(track, microphone);
+            this.video = pc.addTransceiver("video", { direction: "sendrecv" });
+            const remote = new MediaStream();
+            pc.ontrack = event => {
+                if (gen !== this.generation)
+                    return;
+                remote.addTrack(event.track);
+                this.update({ remoteStream: remote });
+            };
+            pc.onicecandidate = event => { if (gen === this.generation && event.candidate)
+                this.send({ type: "ice", callId: this.state.callId, candidate: event.candidate.toJSON() }); };
+            pc.onconnectionstatechange = () => {
+                if (gen !== this.generation)
+                    return;
+                if (pc.connectionState === "connected") {
+                    clearTimeout(this.timeout);
+                    this.update({ phase: "connected", startedAt: this.state.startedAt ?? Date.now(), error: undefined });
+                }
+                else if (pc.connectionState === "failed")
+                    this.fail("CONNECTION_FAILED");
+                else if (pc.connectionState === "disconnected") {
+                    this.update({ phase: "connecting" });
+                    this.armTimeout(15000);
+                }
+            };
+            if (this.state.direction === "outgoing") {
+                await pc.setLocalDescription(await pc.createOffer());
+                if (gen === this.generation)
+                    this.send({ type: "sdp", callId: this.state.callId, description: pc.localDescription });
+            }
+        }
+        else if (message.type === "sdp" && this.pc) {
+            const pc = this.pc;
+            await pc.setRemoteDescription(message.description);
+            if (gen !== this.generation)
+                return;
+            for (const candidate of this.candidates.splice(0))
+                await pc.addIceCandidate(candidate);
+            if (message.description.type === "offer") {
+                await pc.setLocalDescription(await pc.createAnswer());
+                if (gen === this.generation)
+                    this.send({ type: "sdp", callId: this.state.callId, description: pc.localDescription });
+            }
+        }
+        else if (message.type === "ice") {
+            if (this.pc?.remoteDescription)
+                await this.pc.addIceCandidate(message.candidate);
+            else if (this.candidates.length < 100)
+                this.candidates.push(message.candidate);
+        }
+        else if (message.type === "sharing")
+            this.update({ remoteSharing: message.active });
+    }
+}

package/lib/runtime/index.d.ts

@@ -5,3 +5,4 @@ export * from "./protocol.js";
 export * from "./readerClient.js";
 export * from "./thread.js";
 export * from "./activity.js";
+export * from "./call.js";

package/lib/runtime/index.js

@@ -5,3 +5,4 @@ export * from "./protocol.js";
 export * from "./readerClient.js";
 export * from "./thread.js";
 export * from "./activity.js";
+export * from "./call.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",
@@ -11,8 +11,7 @@
   },
   "homepage": "https://github.com/parrot-mate/pmate-mono/tree/main/packages/chat-sdk",
   "files": [
-    "lib",
-    "dist"
+    "lib"
   ],
   "exports": {
     ".": {