@shadowob/sdk 1.1.4 → 1.1.6-dev.311

package/dist/index.js

@@ -522,6 +522,43 @@ var ShadowClient = class {
   async removeChannelMember(channelId, userId) {
     return this.request(`/api/channels/${channelId}/members/${userId}`, { method: "DELETE" });
   }
+  async getVoiceState(channelId) {
+    return this.request(`/api/channels/${channelId}/voice/state`);
+  }
+  async joinVoiceChannel(channelId, options) {
+    return this.request(`/api/channels/${channelId}/voice/join`, {
+      method: "POST",
+      body: JSON.stringify(options ?? {})
+    });
+  }
+  async renewVoiceCredentials(channelId, options) {
+    return this.request(`/api/channels/${channelId}/voice/renew`, {
+      method: "POST",
+      body: JSON.stringify(options ?? {})
+    });
+  }
+  async leaveVoiceChannel(channelId, options) {
+    return this.request(`/api/channels/${channelId}/voice/leave`, {
+      method: "POST",
+      body: JSON.stringify(options ?? {})
+    });
+  }
+  async updateVoiceState(channelId, data) {
+    return this.request(`/api/channels/${channelId}/voice/state`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async getVoicePolicy(channelId, agentId) {
+    const params = new URLSearchParams({ agentId });
+    return this.request(`/api/channels/${channelId}/voice-policy?${params}`);
+  }
+  async updateVoicePolicy(channelId, data) {
+    return this.request(`/api/channels/${channelId}/voice-policy`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
   // ── Channel Buddy Policy ─────────────────────────────────────────────
   async setBuddyPolicy(channelId, agentId, data) {
     return this.request(`/api/channels/${channelId}/agents/${agentId}/policy`, {
@@ -1240,6 +1277,9 @@ var ShadowClient = class {
   async getScopeNeutralProduct(productId) {
     return this.request(`/api/products/${productId}`);
   }
+  async getCommerceProductContext(productId) {
+    return this.request(`/api/commerce/products/${productId}/context`);
+  }
   async getShopProduct(shopId, productId) {
     return this.request(`/api/shops/${shopId}/products/${productId}`);
   }
@@ -1430,6 +1470,11 @@ var ShadowClient = class {
       method: "POST"
     });
   }
+  async completeOrder(serverId, orderId) {
+    return this.request(`/api/servers/${serverId}/shop/orders/${orderId}/complete`, {
+      method: "POST"
+    });
+  }
   async getProductReviews(serverId, productId) {
     return this.request(`/api/servers/${serverId}/shop/products/${productId}/reviews`);
   }
@@ -1665,6 +1710,23 @@ var ShadowClient = class {
   async getAllEntitlements() {
     return this.request("/api/entitlements");
   }
+  async getEntitlement(entitlementId) {
+    return this.request(`/api/entitlements/${entitlementId}`);
+  }
+  async getOAuthCommerceEntitlementAccess(params) {
+    const qs = new URLSearchParams();
+    if (params?.resourceType) qs.set("resourceType", params.resourceType);
+    if (params?.resourceId) qs.set("resourceId", params.resourceId);
+    if (params?.capability) qs.set("capability", params.capability);
+    const query = qs.toString();
+    return this.request(`/api/oauth/commerce/entitlements${query ? `?${query}` : ""}`);
+  }
+  async redeemOAuthCommerceEntitlement(data) {
+    return this.request("/api/oauth/commerce/entitlements/redeem", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
   async verifyEntitlement(entitlementId) {
     return this.request(`/api/entitlements/${entitlementId}/verify`);
   }
@@ -1674,6 +1736,12 @@ var ShadowClient = class {
       body: JSON.stringify({ reason })
     });
   }
+  async cancelEntitlementRenewal(entitlementId, reason) {
+    return this.request(`/api/entitlements/${entitlementId}/cancel-renewal`, {
+      method: "POST",
+      body: JSON.stringify({ reason })
+    });
+  }
   // ── Task Center ───────────────────────────────────────────────────────
   async getTaskCenter() {
     return this.request("/api/tasks");
@@ -1714,6 +1782,16 @@ var ShadowClient = class {
     if (params?.limit) qs.set("limit", String(params.limit));
     return this.request(`/api/discover/search?${qs}`);
   }
+  async discoverCommerce(params) {
+    const qs = new URLSearchParams();
+    if (params?.q) qs.set("q", params.q);
+    if (params?.limit) qs.set("limit", String(params.limit));
+    const suffix = qs.toString();
+    return this.request(`/api/discover/business${suffix ? `?${suffix}` : ""}`);
+  }
+  async discoverBusinessHub(params) {
+    return this.discoverCommerce(params);
+  }
   // ── Voice Enhance ─────────────────────────────────────────────────────
   async enhanceVoice(data) {
     return this.request("/api/voice/enhance", {
@@ -1923,6 +2001,53 @@ var ShadowSocket = class {
   leaveChannel(channelId) {
     this.socket.emit("channel:leave", { channelId });
   }
+  joinVoiceChannel(channelId, options) {
+    return new Promise((resolve) => {
+      this.socket.emit(
+        "voice:join",
+        { channelId, ...options },
+        (res) => {
+          resolve(res ?? { ok: false, error: "Voice join failed" });
+        }
+      );
+    });
+  }
+  leaveVoiceChannel(channelId, options) {
+    return new Promise((resolve) => {
+      this.socket.emit(
+        "voice:leave",
+        { channelId, ...options },
+        (res) => {
+          resolve(res ?? { ok: true });
+        }
+      );
+    });
+  }
+  renewVoiceCredentials(channelId, options) {
+    return new Promise((resolve) => {
+      this.socket.emit(
+        "voice:token:renew",
+        { channelId, ...options },
+        (res) => {
+          resolve(res ?? { ok: false, error: "Voice token renewal failed" });
+        }
+      );
+    });
+  }
+  updateVoiceState(channelId, data) {
+    return new Promise((resolve) => {
+      this.socket.emit(
+        "voice:state:update",
+        { channelId, ...data },
+        (res) => {
+          resolve(res ?? { ok: true });
+        }
+      );
+    });
+  }
+  sendVoiceHeartbeat(channelId, options) {
+    this.socket.emit("voice:heartbeat", { channelId, ...options });
+  }
   // ── Client actions ────────────────────────────────────────────────────
   /** Send a message via WebSocket (text-only; for file attachments use REST) */
   sendMessage(data) {
@@ -1941,11 +2066,198 @@ var ShadowSocket = class {
     this.socket.emit("presence:activity", { channelId, activity });
   }
 };
+
+// src/voice.ts
+var cachedAgoraRTC = null;
+async function loadAgoraRTC() {
+  if (cachedAgoraRTC) return cachedAgoraRTC;
+  try {
+    const module = await import("agora-rtc-sdk-ng");
+    cachedAgoraRTC = module.default;
+    return cachedAgoraRTC;
+  } catch (error) {
+    throw new Error(
+      `Agora RTC SDK is required for ShadowVoiceConsumer. Install agora-rtc-sdk-ng in this app to use browser voice media. ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function createVoiceClientId() {
+  return `shadow-sdk-${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`}`;
+}
+var ShadowVoiceConsumer = class {
+  constructor(options) {
+    this.options = options;
+    this.clientId = options.clientId ?? createVoiceClientId();
+  }
+  rtc = null;
+  screenRtc = null;
+  audioTrack = null;
+  screenTrack = null;
+  session = null;
+  clientId;
+  tokenRenewTimer = null;
+  get joinResult() {
+    return this.session;
+  }
+  async join() {
+    const AgoraRTC = await loadAgoraRTC();
+    this.session = await this.options.client.joinVoiceChannel(this.options.channelId, {
+      muted: this.options.muted,
+      clientId: this.clientId
+    });
+    const { credentials } = this.session;
+    const rtc = AgoraRTC.createClient({ mode: "rtc", codec: "vp8" });
+    this.rtc = rtc;
+    try {
+      this.bindTokenRenewal(rtc);
+      rtc.on("user-published", async (user, mediaType) => {
+        await rtc.subscribe(user, mediaType);
+        if (mediaType === "audio" && user.audioTrack) {
+          this.options.onRemoteAudio?.({ uid: user.uid, track: user.audioTrack });
+        }
+        if (mediaType === "video" && user.videoTrack) {
+          this.options.onRemoteScreen?.({ uid: user.uid, track: user.videoTrack });
+        }
+      });
+      await rtc.join(
+        credentials.appId,
+        credentials.agoraChannelName,
+        credentials.token,
+        credentials.uid
+      );
+      this.audioTrack = await AgoraRTC.createMicrophoneAudioTrack();
+      await this.audioTrack.setEnabled(!this.options.muted);
+      await rtc.publish([this.audioTrack]);
+      this.scheduleTokenRenewal();
+      return this.session;
+    } catch (error) {
+      this.clearTokenRenewal();
+      this.audioTrack?.stop();
+      this.audioTrack?.close();
+      this.audioTrack = null;
+      await rtc.leave().catch(() => void 0);
+      this.rtc = null;
+      await this.options.client.leaveVoiceChannel(this.options.channelId, { clientId: this.clientId }).catch(() => void 0);
+      this.session = null;
+      throw error;
+    }
+  }
+  async setMuted(muted) {
+    await this.audioTrack?.setEnabled(!muted);
+    await this.options.client.updateVoiceState(this.options.channelId, {
+      clientId: this.clientId,
+      muted
+    });
+  }
+  async startScreenShare() {
+    if (!this.session || this.screenRtc || this.screenTrack) return;
+    const { credentials } = this.session;
+    const AgoraRTC = await loadAgoraRTC();
+    const screenRtc = AgoraRTC.createClient({ mode: "rtc", codec: "vp8" });
+    this.screenRtc = screenRtc;
+    try {
+      this.bindTokenRenewal(screenRtc);
+      await screenRtc.join(
+        credentials.appId,
+        credentials.agoraChannelName,
+        credentials.screenToken,
+        credentials.screenUid
+      );
+      const trackResult = await AgoraRTC.createScreenVideoTrack(
+        { encoderConfig: "1080p_1" },
+        "disable"
+      );
+      const screenTrack = Array.isArray(trackResult) ? trackResult[0] : trackResult;
+      this.screenTrack = screenTrack;
+      await screenRtc.publish([this.screenTrack]);
+      await this.options.client.updateVoiceState(this.options.channelId, {
+        clientId: this.clientId,
+        screenSharing: true
+      });
+    } catch (error) {
+      this.screenTrack?.stop();
+      this.screenTrack?.close();
+      this.screenTrack = null;
+      await screenRtc.leave().catch(() => void 0);
+      this.screenRtc = null;
+      await this.options.client.updateVoiceState(this.options.channelId, {
+        clientId: this.clientId,
+        screenSharing: false
+      }).catch(() => void 0);
+      throw error;
+    }
+  }
+  async stopScreenShare() {
+    this.screenTrack?.stop();
+    this.screenTrack?.close();
+    this.screenTrack = null;
+    await this.screenRtc?.leave();
+    this.screenRtc = null;
+    await this.options.client.updateVoiceState(this.options.channelId, {
+      clientId: this.clientId,
+      screenSharing: false
+    });
+  }
+  async leave() {
+    this.clearTokenRenewal();
+    await this.stopScreenShare();
+    this.audioTrack?.stop();
+    this.audioTrack?.close();
+    this.audioTrack = null;
+    await this.rtc?.leave();
+    this.rtc = null;
+    await this.options.client.leaveVoiceChannel(this.options.channelId, { clientId: this.clientId });
+    this.session = null;
+  }
+  bindTokenRenewal(rtc) {
+    rtc.on("token-privilege-will-expire", () => {
+      void this.renewTokens();
+    });
+    rtc.on("token-privilege-did-expire", () => {
+      void this.renewTokens();
+    });
+  }
+  scheduleTokenRenewal() {
+    this.clearTokenRenewal();
+    const expiresAt = this.session?.credentials.expiresAt;
+    if (!expiresAt) return;
+    const renewAt = new Date(expiresAt).getTime() - 5 * 6e4;
+    const delay = Math.max(3e4, renewAt - Date.now());
+    this.tokenRenewTimer = setTimeout(() => {
+      void this.renewTokens();
+    }, delay);
+  }
+  clearTokenRenewal() {
+    if (this.tokenRenewTimer) {
+      clearTimeout(this.tokenRenewTimer);
+      this.tokenRenewTimer = null;
+    }
+  }
+  async renewTokens() {
+    if (!this.session) return;
+    const result = await this.options.client.renewVoiceCredentials(this.options.channelId, {
+      clientId: this.clientId
+    });
+    this.session = {
+      ...this.session,
+      credentials: result.credentials,
+      state: result.state
+    };
+    if (result.credentials.token) {
+      await this.rtc?.renewToken?.(result.credentials.token);
+    }
+    if (result.credentials.screenToken) {
+      await this.screenRtc?.renewToken?.(result.credentials.screenToken);
+    }
+    this.scheduleTokenRenewal();
+  }
+};
 export {
   CLIENT_EVENTS,
   SERVER_EVENTS,
   ShadowClient,
   ShadowSocket,
+  ShadowVoiceConsumer,
   channelRoom,
   threadRoom,
   userRoom

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shadowob/sdk",
-  "version": "1.1.4",
+  "version": "1.1.6-dev.311",
   "description": "Shadow SDK — typed REST client and real-time Socket.IO event listener for Shadow servers",
   "license": "MIT",
   "type": "module",
@@ -22,9 +22,18 @@
   ],
   "dependencies": {
     "socket.io-client": "^4.8.1",
-    "@shadowob/shared": "1.1.4"
+    "@shadowob/shared": "1.1.6-dev.311"
+  },
+  "peerDependencies": {
+    "agora-rtc-sdk-ng": "^4.24.3"
+  },
+  "peerDependenciesMeta": {
+    "agora-rtc-sdk-ng": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "agora-rtc-sdk-ng": "^4.24.3",
     "tsup": "^8.5.0",
     "typescript": "^5.9.3"
   },