@shadowob/cli 1.1.3 → 1.1.5

package/dist/index.js

@@ -2,11 +2,13 @@
 import {
   configManager,
   getClient,
-  getSocket
-} from "./chunk-T3BKMB7N.js";
+  getClientWithToken,
+  getSocket,
+  parsePositiveInt
+} from "./chunk-E364BDQO.js";
 
 // src/index.ts
-import { Command as Command25 } from "commander";
+import { Command as Command28 } from "commander";
 
 // src/commands/agents.ts
 import { Command } from "commander";
@@ -265,11 +267,169 @@ function createApiTokensCommand() {
   return tokens;
 }
 
+// src/commands/app.ts
+import { readFile, writeFile } from "fs/promises";
+import { basename } from "path";
+import { Command as Command3 } from "commander";
+function resolveServer(value) {
+  const server = value ?? process.env.SHADOWOB_SERVER_ID;
+  if (!server) throw new Error("Missing server. Pass --server or set SHADOWOB_SERVER_ID.");
+  return server;
+}
+function parseJsonInput(value) {
+  if (!value) return {};
+  const parsed = JSON.parse(value);
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && "input" in parsed && Object.keys(parsed).every((key) => key === "input" || key === "channelId")) {
+    return parsed.input ?? {};
+  }
+  return parsed;
+}
+async function readJsonFile(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+function commandHandlerError(error, json) {
+  outputError(error instanceof Error ? error.message : String(error), { json });
+  process.exit(1);
+}
+function createAppCommand() {
+  const app = new Command3("app").description("Server App integration commands");
+  app.command("list").description("List apps installed in a server").requiredOption("--server <server>", "Server ID or slug").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = await getClient(options.profile);
+      output(await client.listServerApps(resolveServer(options.server)), { json: options.json });
+    } catch (error) {
+      commandHandlerError(error, options.json);
+    }
+  });
+  app.command("preview").description("Discover and preview a server App manifest before installing it").requiredOption("--server <server>", "Server ID or slug").option("--manifest-url <url>", "Manifest URL").option("--manifest-file <path>", "Local manifest JSON file").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        if (!options.manifestUrl && !options.manifestFile) {
+          throw new Error("Pass --manifest-url or --manifest-file");
+        }
+        const client = await getClient(options.profile);
+        const manifest = options.manifestFile ? await readJsonFile(options.manifestFile) : void 0;
+        output(
+          await client.discoverServerApp(resolveServer(options.server), {
+            manifestUrl: options.manifestUrl,
+            manifest
+          }),
+          { json: options.json }
+        );
+      } catch (error) {
+        commandHandlerError(error, options.json);
+      }
+    }
+  );
+  app.command("install").description("Install or update a server App from a manifest").requiredOption("--server <server>", "Server ID or slug").option("--manifest-url <url>", "Manifest URL").option("--manifest-file <path>", "Local manifest JSON file").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        if (!options.manifestUrl && !options.manifestFile) {
+          throw new Error("Pass --manifest-url or --manifest-file");
+        }
+        const client = await getClient(options.profile);
+        const manifest = options.manifestFile ? await readJsonFile(options.manifestFile) : void 0;
+        const result = await client.installServerApp(resolveServer(options.server), {
+          manifestUrl: options.manifestUrl,
+          manifest
+        });
+        output(result, { json: options.json });
+      } catch (error) {
+        commandHandlerError(error, options.json);
+      }
+    }
+  );
+  app.command("inspect").description("Inspect an installed server App").argument("<app-key>", "App key").requiredOption("--server <server>", "Server ID or slug").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (appKey, options) => {
+      try {
+        const client = await getClient(options.profile);
+        output(await client.getServerApp(resolveServer(options.server), appKey), {
+          json: options.json
+        });
+      } catch (error) {
+        commandHandlerError(error, options.json);
+      }
+    }
+  );
+  app.command("grant").description("Grant a Buddy access to an installed server App").argument("<app-key>", "App key").requiredOption("--server <server>", "Server ID or slug").requiredOption("--buddy <agent-id>", "Buddy agent ID").requiredOption("--permissions <permissions>", "Comma-separated permissions, or *").option("--approval-mode <mode>", "none, first_time, every_time, or policy", "none").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (appKey, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const permissions = options.permissions.split(",").map((item) => item.trim()).filter(Boolean);
+        const result = await client.grantServerAppToBuddy(resolveServer(options.server), appKey, {
+          buddyAgentId: options.buddy,
+          permissions,
+          approvalMode: options.approvalMode
+        });
+        output(result, { json: options.json });
+      } catch (error) {
+        commandHandlerError(error, options.json);
+      }
+    }
+  );
+  app.command("discover").description("Emit Skill-style command discovery for server Apps").requiredOption("--server <server>", "Server ID or slug").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = await getClient(options.profile);
+      const server = resolveServer(options.server);
+      const apps = await client.listServerApps(server);
+      const docs = await Promise.all(
+        apps.map((entry) => client.getServerAppSkills(server, entry.appKey))
+      );
+      if (options.json) {
+        output(docs, { json: true });
+      } else {
+        console.log(docs.map((doc) => doc.markdown).join("\n\n---\n\n"));
+      }
+    } catch (error) {
+      commandHandlerError(error, options.json);
+    }
+  });
+  app.command("skills").description("Emit Skill text for one installed server App").argument("<app-key>", "App key").requiredOption("--server <server>", "Server ID or slug").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (appKey, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const result = await client.getServerAppSkills(resolveServer(options.server), appKey);
+        if (options.json) output(result, { json: true });
+        else console.log(result.markdown);
+      } catch (error) {
+        commandHandlerError(error, options.json);
+      }
+    }
+  );
+  app.command("call").description("Call a server App command").argument("<app-key>", "App key").argument("<command>", "Command name").requiredOption("--server <server>", "Server ID or slug").option("--json-input <json>", "JSON command input").option("--input-file <path>", "Read JSON command input from file").option("--file <path>", "Attach a binary file").option("--field <field>", "Multipart file field name", "file").option("--output <path>", "Write binary dataBase64 response to this path").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (appKey, commandName, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const input = options.inputFile ? await readJsonFile(options.inputFile) : parseJsonInput(options.jsonInput);
+        const server = resolveServer(options.server);
+        const result = options.file ? await client.callServerAppCommandMultipart(server, appKey, commandName, {
+          input,
+          file: new Blob([await readFile(options.file)]),
+          filename: basename(options.file),
+          field: options.field
+        }) : await client.callServerAppCommand(server, appKey, commandName, { input });
+        if (options.output && result && typeof result === "object" && "dataBase64" in result && typeof result.dataBase64 === "string") {
+          await writeFile(
+            options.output,
+            Buffer.from(result.dataBase64, "base64")
+          );
+          outputSuccess(`Wrote ${options.output}`, { json: options.json });
+          return;
+        }
+        output(result, { json: options.json });
+      } catch (error) {
+        commandHandlerError(error, options.json);
+      }
+    }
+  );
+  return app;
+}
+
 // src/commands/auth.ts
 import { ShadowClient } from "@shadowob/sdk";
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 function createAuthCommand() {
-  const auth = new Command3("auth").description("Authentication commands");
+  const auth = new Command4("auth").description("Authentication commands");
   auth.command("login").description("Authenticate with a Shadow server").requiredOption("--server-url <url>", "Shadow server URL").requiredOption("--token <token>", "JWT token").option("--profile <name>", "Profile name", "default").option("--json", "Output as JSON").action(
     async (options) => {
       try {
@@ -382,9 +542,9 @@ function createAuthCommand() {
 }
 
 // src/commands/channels.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 function createChannelsCommand() {
-  const channels = new Command4("channels").description("Channel commands");
+  const channels = new Command5("channels").description("Channel commands");
   channels.command("list").description("List channels in a server").requiredOption("--server-id <id>", "Server ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient(options.profile);
@@ -572,9 +732,9 @@ function createChannelsCommand() {
 
 // src/commands/cloud.ts
 import { execFileSync, spawnSync } from "child_process";
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 function createCloudCommand() {
-  const cloud = new Command5("cloud").description("Shadow Cloud \u2014 deploy AI agent clusters to Kubernetes (via shadowob-cloud)").allowUnknownOption(true).allowExcessArguments(true).action(async (_, cmd) => {
+  const cloud = new Command6("cloud").description("Shadow Cloud \u2014 deploy AI agent clusters to Kubernetes (via shadowob-cloud)").allowUnknownOption(true).allowExcessArguments(true).action(async (_, cmd) => {
     const args = cmd.args ?? [];
     ensureCloudCliInstalled();
     spawnCloudCli(args);
@@ -597,10 +757,217 @@ function spawnCloudCli(args) {
   }
 }
 
+// src/commands/commerce.ts
+import { randomUUID } from "crypto";
+import { Command as Command7 } from "commander";
+function buildIdempotencyKey(value, prefix) {
+  return value?.trim() || `${prefix}-${randomUUID()}`;
+}
+function parsePositiveInteger(value, name) {
+  if (value == null) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+  return parsed;
+}
+function parseMetadata(value) {
+  if (!value) return void 0;
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("--metadata must be a JSON object");
+  }
+  return parsed;
+}
+async function runCommand(options, task) {
+  try {
+    const result = await task();
+    output(result, { json: options.json });
+  } catch (error) {
+    outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+    process.exit(1);
+  }
+}
+function createCommerceCommand() {
+  const commerce = new Command7("commerce").description("Commerce, purchases, delivery, and assets");
+  const products = commerce.command("products").description("Buyer-facing product commands");
+  products.command("context").description("Get buyer-facing product context").argument("<product-id>", "Product ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (productId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.getCommerceProductContext(productId);
+    })
+  );
+  const offers = commerce.command("offers").description("Commerce offer commands");
+  offers.command("preview").description("Preview checkout for an offer").argument("<offer-id>", "Offer ID").option("--sku-id <id>", "SKU ID").option("--viewer-user-id <id>", "Viewer user ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (offerId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.getCommerceOfferCheckoutPreview(offerId, {
+        skuId: options.skuId,
+        viewerUserId: options.viewerUserId
+      });
+    })
+  );
+  offers.command("purchase").description("Purchase an offer").argument("<offer-id>", "Offer ID").option("--sku-id <id>", "SKU ID").option("--destination-kind <kind>", "Delivery destination kind, currently channel").option("--destination-id <id>", "Delivery destination ID").option("--idempotency-key <key>", "Idempotency key, generated if omitted").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (offerId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.purchaseCommerceOffer(offerId, {
+        skuId: options.skuId,
+        idempotencyKey: buildIdempotencyKey(options.idempotencyKey, "cli-offer-purchase"),
+        destinationKind: options.destinationId ? options.destinationKind ?? "channel" : void 0,
+        destinationId: options.destinationId
+      });
+    })
+  );
+  const cards = commerce.command("cards").description("Chat commerce card commands");
+  cards.command("list").description("List commerce product cards available for a channel").requiredOption("--channel-id <id>", "Channel ID").option("--keyword <keyword>", "Search keyword").option("--limit <n>", "Maximum cards").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.listCommerceProductCards({
+        target: "channel",
+        channelId: options.channelId,
+        keyword: options.keyword,
+        limit: parsePositiveInteger(options.limit, "--limit")
+      });
+    })
+  );
+  cards.command("purchase").description("Purchase a chat commerce card").argument("<message-id>", "Message ID").argument("<card-id>", "Commerce card ID").option("--sku-id <id>", "SKU ID").option("--idempotency-key <key>", "Idempotency key, generated if omitted").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (messageId, cardId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.purchaseMessageCommerceCard(messageId, cardId, {
+        skuId: options.skuId,
+        idempotencyKey: buildIdempotencyKey(options.idempotencyKey, "cli-card-purchase")
+      });
+    })
+  );
+  const entitlements = commerce.command("entitlements").description("Purchase entitlement commands");
+  entitlements.command("list").description("List my purchase entitlements").option("--server-id <id>", "Limit to a server shop entitlement list").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return options.serverId ? client.getEntitlements(options.serverId) : client.getAllEntitlements();
+    })
+  );
+  entitlements.command("get").description("Get purchase delivery detail").argument("<entitlement-id>", "Entitlement ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (entitlementId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.getEntitlement(entitlementId);
+    })
+  );
+  entitlements.command("verify").description("Verify entitlement provisioning/access").argument("<entitlement-id>", "Entitlement ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (entitlementId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.verifyEntitlement(entitlementId);
+    })
+  );
+  entitlements.command("cancel").description("Cancel an entitlement and request any available refund").argument("<entitlement-id>", "Entitlement ID").option("--reason <reason>", "Cancellation reason").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (entitlementId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.cancelEntitlement(entitlementId, options.reason);
+    })
+  );
+  entitlements.command("cancel-renewal").description("Stop subscription renewal while keeping current access").argument("<entitlement-id>", "Entitlement ID").option("--reason <reason>", "Cancellation reason").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (entitlementId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.cancelEntitlementRenewal(entitlementId, options.reason);
+    })
+  );
+  const assets = commerce.command("assets").description("Community asset commands");
+  assets.command("list").description("List my community assets").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.listCommunityAssets();
+    })
+  );
+  assets.command("get").description("Get a community asset grant").argument("<grant-id>", "Asset grant ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (grantId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.getCommunityAsset(grantId);
+    })
+  );
+  for (const action of ["consume", "lock", "unlock"]) {
+    assets.command(action).description(`${action} a community asset grant`).argument("<grant-id>", "Asset grant ID").option("--idempotency-key <key>", "Idempotency key, generated if omitted").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+      (grantId, options) => runCommand(options, async () => {
+        const client = await getClient(options.profile);
+        const data = {
+          idempotencyKey: buildIdempotencyKey(options.idempotencyKey, `cli-asset-${action}`)
+        };
+        if (action === "consume") return client.consumeCommunityAsset(grantId, data);
+        if (action === "lock") return client.lockCommunityAsset(grantId, data);
+        return client.unlockCommunityAsset(grantId, data);
+      })
+    );
+  }
+  assets.command("revoke").description("Revoke a community asset grant").argument("<grant-id>", "Asset grant ID").option("--reason <reason>", "Revocation reason").option("--idempotency-key <key>", "Idempotency key, generated if omitted").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (grantId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.revokeCommunityAsset(grantId, {
+        reason: options.reason,
+        idempotencyKey: buildIdempotencyKey(options.idempotencyKey, "cli-asset-revoke")
+      });
+    })
+  );
+  const paidFiles = commerce.command("paid-files").description("Protected paid file commands");
+  paidFiles.command("open").description("Open a paid file with entitlement authorization").argument("<file-id>", "Paid file/workspace file ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (fileId, options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.openPaidFile(fileId);
+    })
+  );
+  const settlements = commerce.command("settlements").description("Settlement commands");
+  settlements.command("list").description("List settlement lines").option("--limit <n>", "Maximum settlement lines").option("--offset <n>", "Offset").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.listSettlements({
+        limit: parsePositiveInteger(options.limit, "--limit"),
+        offset: options.offset ? Number.parseInt(options.offset, 10) : void 0
+      });
+    })
+  );
+  settlements.command("settle").description("Settle currently available settlement lines").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.settleAvailableSettlements();
+    })
+  );
+  const tips = commerce.command("tips").description("Tip commands");
+  tips.command("send").description("Send a tip").requiredOption("--recipient-user-id <id>", "Recipient user ID").requiredOption("--amount <amount>", "Amount").option("--message <message>", "Message").option("--context <json>", "Context JSON object").option("--idempotency-key <key>", "Idempotency key, generated if omitted").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      const amount = parsePositiveInteger(options.amount, "--amount");
+      return client.sendTip({
+        recipientUserId: options.recipientUserId,
+        amount: amount ?? 0,
+        message: options.message,
+        context: parseMetadata(options.context),
+        idempotencyKey: buildIdempotencyKey(options.idempotencyKey, "cli-tip")
+      });
+    })
+  );
+  const gifts = commerce.command("gifts").description("Gift commands");
+  gifts.command("list").description("List gifts").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.listGifts();
+    })
+  );
+  gifts.command("send").description("Send a gift").requiredOption("--recipient-user-id <id>", "Recipient user ID").option("--assets <json>", "Assets JSON array").option("--currencies <json>", "Currencies JSON array").option("--message <message>", "Message").option("--idempotency-key <key>", "Idempotency key, generated if omitted").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    (options) => runCommand(options, async () => {
+      const client = await getClient(options.profile);
+      return client.sendGift({
+        recipientUserId: options.recipientUserId,
+        assets: options.assets ? JSON.parse(options.assets) : void 0,
+        currencies: options.currencies ? JSON.parse(options.currencies) : void 0,
+        message: options.message,
+        idempotencyKey: buildIdempotencyKey(options.idempotencyKey, "cli-gift")
+      });
+    })
+  );
+  return commerce;
+}
+
 // src/commands/config.ts
-import { Command as Command6 } from "commander";
+import { Command as Command8 } from "commander";
 function createConfigCommand() {
-  const config = new Command6("config").description("Configuration management commands");
+  const config = new Command8("config").description("Configuration management commands");
   config.command("path").description("Show configuration file path").action(() => {
     console.log(configManager.getConfigPath());
   });
@@ -671,9 +1038,9 @@ function createConfigCommand() {
 }
 
 // src/commands/discover.ts
-import { Command as Command7 } from "commander";
+import { Command as Command9 } from "commander";
 function createDiscoverCommand() {
-  const discover = new Command7("discover").description("Discover popular servers and channels");
+  const discover = new Command9("discover").description("Discover popular servers and channels");
   discover.command("feed").description("Get the discovery feed").option("--type <type>", "Filter by type (all, servers, channels, rentals)", "all").option("--limit <n>", "Number of results", "20").option("--offset <n>", "Offset for pagination", "0").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient(options.profile);
@@ -710,9 +1077,9 @@ function createDiscoverCommand() {
 }
 
 // src/commands/dms.ts
-import { Command as Command8 } from "commander";
+import { Command as Command10 } from "commander";
 function createDirectMessagesCommand() {
-  const dms = new Command8("dms").description("Direct message commands");
+  const dms = new Command10("dms").description("Direct message commands");
   dms.command("list").description("List direct channels").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient(options.profile);
@@ -790,9 +1157,9 @@ function createDirectMessagesCommand() {
 }
 
 // src/commands/friends.ts
-import { Command as Command9 } from "commander";
+import { Command as Command11 } from "commander";
 function createFriendsCommand() {
-  const friends = new Command9("friends").description("Friendship management commands");
+  const friends = new Command11("friends").description("Friendship management commands");
   friends.command("list").description("List friends").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient(options.profile);
@@ -876,9 +1243,9 @@ function createFriendsCommand() {
 }
 
 // src/commands/invites.ts
-import { Command as Command10 } from "commander";
+import { Command as Command12 } from "commander";
 function createInvitesCommand() {
-  const invites = new Command10("invites").description("Invite code management commands");
+  const invites = new Command12("invites").description("Invite code management commands");
   invites.command("list").description("List your invite codes").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient(options.profile);
@@ -929,15 +1296,15 @@ function createInvitesCommand() {
 }
 
 // src/commands/listen.ts
-import { Command as Command11 } from "commander";
+import { Command as Command13 } from "commander";
 function createListenCommand() {
-  const listen = new Command11("listen").description("Listen to real-time events");
+  const listen = new Command13("listen").description("Listen to real-time events");
   listen.command("channel").description("Listen to events in a channel").argument("<channel-id>", "Channel ID").option("--mode <mode>", "Listen mode: stream or poll", "stream").option("--timeout <seconds>", "Timeout in seconds (stream mode)", "60").option("--count <n>", "Stop after N events (stream mode)").option("--since <duration>", "Poll events since duration (e.g., 5m, 1h)", "5m").option("--last <n>", "Poll last N messages", "50").option("--event-type <type>", "Filter by event type (comma-separated)").option("--profile <name>", "Profile to use").option("--json", "Output as JSON (one per line)").action(
     async (channelId, options) => {
       try {
         const eventTypes = options.eventType?.split(",").map((t) => t.trim());
         if (options.mode === "poll") {
-          const { getClient: getClient2 } = await import("./client-OCEGJPBJ.js");
+          const { getClient: getClient2 } = await import("./client-ZIUDIQPZ.js");
           const client = await getClient2(options.profile);
           const limit = parseInt(options.last ?? "50", 10);
           const result = await client.getMessages(channelId, limit);
@@ -1051,9 +1418,9 @@ function createListenCommand() {
 }
 
 // src/commands/marketplace.ts
-import { Command as Command12 } from "commander";
+import { Command as Command14 } from "commander";
 function createMarketplaceCommand() {
-  const marketplace = new Command12("marketplace").description("Marketplace commands");
+  const marketplace = new Command14("marketplace").description("Marketplace commands");
   const listings = marketplace.command("listings").description("Listing commands");
   listings.command("list").description("Browse marketplace listings").option("--search <text>", "Search query").option("--tags <tags>", "Comma-separated tags").option("--min-price <n>", "Minimum price per hour").option("--max-price <n>", "Maximum price per hour").option("--limit <n>", "Number of results", "20").option("--offset <n>", "Pagination offset", "0").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
     async (options) => {
@@ -1198,9 +1565,9 @@ function createMarketplaceCommand() {
 
 // src/commands/media.ts
 import { readFileSync } from "fs";
-import { Command as Command13 } from "commander";
+import { Command as Command15 } from "commander";
 function createMediaCommand() {
-  const media = new Command13("media").description("Media management commands");
+  const media = new Command15("media").description("Media management commands");
   media.command("upload").description("Upload a file").requiredOption("--file <path>", "File path to upload").option("--message-id <id>", "Associate with message").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
     async (options) => {
       try {
@@ -1266,16 +1633,18 @@ function createMediaCommand() {
 }
 
 // src/commands/notifications.ts
-import { Command as Command14 } from "commander";
+import { Command as Command16 } from "commander";
 function createNotificationsCommand() {
-  const notifications = new Command14("notifications").description("Notification commands");
+  const notifications = new Command16("notifications").description("Notification commands");
   notifications.command("list").description("List notifications").option("--unread-only", "Show only unread notifications").option("--limit <n>", "Number of notifications", "20").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
     async (options) => {
       try {
         const client = await getClient(options.profile);
         const limit = parseInt(options.limit ?? "20", 10);
         const result = await client.listNotifications(limit);
-        const notifications2 = Array.isArray(result) ? result : [];
+        const notifications2 = (Array.isArray(result) ? result : []).filter(
+          (item) => !options.unreadOnly || item.isRead === false
+        );
         output(notifications2, { json: options.json });
       } catch (error) {
         outputError(error instanceof Error ? error.message : String(error), {
@@ -1307,13 +1676,62 @@ function createNotificationsCommand() {
       process.exit(1);
     }
   });
+  const preferences = notifications.command("preferences").description("Notification preferences");
+  preferences.command("get").description("Get notification preferences").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = await getClient(options.profile);
+      output(await client.getNotificationPreferences(), { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  preferences.command("update").description("Update notification preferences").option("--strategy <strategy>", "all | mention_only | none").option("--muted-server-ids <ids>", "Comma-separated server IDs").option("--muted-channel-ids <ids>", "Comma-separated channel IDs").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        if (options.strategy && !["all", "mention_only", "none"].includes(options.strategy)) {
+          throw new Error("Invalid --strategy. Expected all, mention_only, or none");
+        }
+        const client = await getClient(options.profile);
+        const data = {
+          ...options.strategy ? { strategy: options.strategy } : {},
+          ...options.mutedServerIds !== void 0 ? { mutedServerIds: splitIds(options.mutedServerIds) } : {},
+          ...options.mutedChannelIds !== void 0 ? { mutedChannelIds: splitIds(options.mutedChannelIds) } : {}
+        };
+        output(await client.updateNotificationPreferences(data), { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
   return notifications;
 }
+function splitIds(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
 
 // src/commands/oauth.ts
-import { Command as Command15 } from "commander";
+import { Command as Command17 } from "commander";
+function resolveOAuthAccessToken(options) {
+  const token = options.accessToken || process.env.SHADOWOB_OAUTH_TOKEN;
+  if (!token) {
+    throw new Error("Provide --access-token or SHADOWOB_OAUTH_TOKEN for OAuth commerce APIs");
+  }
+  return token;
+}
+function parseMetadata2(value) {
+  if (!value) return void 0;
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("--metadata must be a JSON object");
+  }
+  return parsed;
+}
 function createOAuthCommand() {
-  const oauth = new Command15("oauth").description("OAuth management commands");
+  const oauth = new Command17("oauth").description("OAuth management commands");
   oauth.command("list").description("List OAuth apps").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient(options.profile);
@@ -1403,13 +1821,52 @@ function createOAuthCommand() {
       process.exit(1);
     }
   });
+  const commerce = oauth.command("commerce").description("OAuth commerce entitlement commands");
+  commerce.command("check").description("Check the OAuth token user entitlement for the calling app").option("--resource-type <type>", "Resource type, defaults to external_app").option("--resource-id <id>", "App resource ID or app-id:feature").option("--capability <capability>", "Capability, defaults to use").option("--access-token <token>", "OAuth access token; defaults to SHADOWOB_OAUTH_TOKEN").option("--profile <name>", "Profile to use for server URL").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClientWithToken(resolveOAuthAccessToken(options), options.profile);
+        const result = await client.getOAuthCommerceEntitlementAccess({
+          resourceType: options.resourceType,
+          resourceId: options.resourceId,
+          capability: options.capability
+        });
+        output(result, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  commerce.command("redeem").description("Redeem the OAuth token user entitlement for the calling app").requiredOption("--idempotency-key <key>", "Provider idempotency key").option("--resource-type <type>", "Resource type, defaults to external_app").option("--resource-id <id>", "App resource ID or app-id:feature").option("--capability <capability>", "Capability, defaults to use").option("--metadata <json>", "Flat provider metadata JSON object").option("--access-token <token>", "OAuth access token; defaults to SHADOWOB_OAUTH_TOKEN").option("--profile <name>", "Profile to use for server URL").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClientWithToken(resolveOAuthAccessToken(options), options.profile);
+        const result = await client.redeemOAuthCommerceEntitlement({
+          idempotencyKey: options.idempotencyKey,
+          resourceType: options.resourceType,
+          resourceId: options.resourceId,
+          capability: options.capability,
+          metadata: parseMetadata2(options.metadata)
+        });
+        output(result, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
   return oauth;
 }
 
 // src/commands/ping.ts
-import { Command as Command16 } from "commander";
+import { Command as Command18 } from "commander";
 function createPingCommand() {
-  const ping = new Command16("ping").description("Test connection to Shadow server");
+  const ping = new Command18("ping").description("Test connection to Shadow server");
   ping.option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     const startTime = Date.now();
     const outputOpts = { json: options.json };
@@ -1458,9 +1915,9 @@ function createPingCommand() {
 }
 
 // src/commands/profile-comments.ts
-import { Command as Command17 } from "commander";
+import { Command as Command19 } from "commander";
 function createProfileCommentsCommand() {
-  const comments = new Command17("profile-comments").description(
+  const comments = new Command19("profile-comments").description(
     "Profile comment management commands"
   );
   comments.command("get").description("Get comments for a user profile").argument("<user-id>", "Profile user ID").option("--limit <n>", "Number of results", "20").option("--offset <n>", "Offset for pagination", "0").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (userId, options) => {
@@ -1510,9 +1967,9 @@ function createProfileCommentsCommand() {
 }
 
 // src/commands/search.ts
-import { Command as Command18 } from "commander";
+import { Command as Command20 } from "commander";
 function createSearchCommand() {
-  const search = new Command18("search").description("Search commands");
+  const search = new Command20("search").description("Search commands");
   search.command("messages").description("Search messages").requiredOption("--query <text>", "Search query").option("--server-id <id>", "Limit to server").option("--channel-id <id>", "Limit to channel").option("--limit <n>", "Number of results (1-100)", "20").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
     async (options) => {
       try {
@@ -1537,9 +1994,9 @@ function createSearchCommand() {
 }
 
 // src/commands/servers.ts
-import { Command as Command19 } from "commander";
+import { Command as Command21 } from "commander";
 function createServersCommand() {
-  const servers = new Command19("servers").description("Server management commands");
+  const servers = new Command21("servers").description("Server management commands");
   servers.command("list").description("List all servers you have joined").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient(options.profile);
@@ -1619,45 +2076,6 @@ function createServersCommand() {
       process.exit(1);
     }
   });
-  servers.command("homepage").description("Get or set server homepage").argument("<server-id>", "Server ID or slug").option("--set <file>", 'Set homepage from HTML file (use "-" for stdin)').option("--clear", "Clear homepage (reset to default)").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
-    async (serverId, options) => {
-      try {
-        const client = await getClient(options.profile);
-        if (options.clear) {
-          const result = await client.updateServerHomepage(serverId, null);
-          output(result, { json: options.json });
-          return;
-        }
-        if (options.set) {
-          let html;
-          if (options.set === "-") {
-            const chunks = [];
-            for await (const chunk of process.stdin) {
-              chunks.push(Buffer.from(chunk));
-            }
-            html = Buffer.concat(chunks).toString("utf-8");
-          } else {
-            const { readFile: readFile2 } = await import("fs/promises");
-            html = await readFile2(options.set, "utf-8");
-          }
-          const result = await client.updateServerHomepage(serverId, html);
-          output(result, { json: options.json });
-          return;
-        }
-        const server = await client.getServer(serverId);
-        if (options.json) {
-          output({ homepageHtml: server.homepageHtml }, { json: true });
-        } else {
-          console.log(server.homepageHtml ?? "(default homepage)");
-        }
-      } catch (error) {
-        outputError(error instanceof Error ? error.message : String(error), {
-          json: options.json
-        });
-        process.exit(1);
-      }
-    }
-  );
   servers.command("discover").description("Discover public servers").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient(options.profile);
@@ -1672,9 +2090,25 @@ function createServersCommand() {
 }
 
 // src/commands/shop.ts
-import { Command as Command20 } from "commander";
+import { Command as Command22 } from "commander";
+function parseJsonObject(value, optionName) {
+  if (!value) return {};
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${optionName} must be a JSON object`);
+  }
+  return parsed;
+}
+function parseOptionalNumber(value, optionName) {
+  if (value == null) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    throw new Error(`${optionName} must be a positive integer`);
+  }
+  return parsed;
+}
 function createShopCommand() {
-  const shop = new Command20("shop").description("Shop commands");
+  const shop = new Command22("shop").description("Shop commands");
   shop.command("get").description("Get shop info").argument("<server-id>", "Server ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (serverId, options) => {
     try {
       const client = await getClient(options.profile);
@@ -1685,17 +2119,77 @@ function createShopCommand() {
       process.exit(1);
     }
   });
-  const products = shop.command("products").description("Product commands");
-  products.command("list").description("List products").argument("<server-id>", "Server ID").option("--category-id <id>", "Filter by category").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
-    async (serverId, options) => {
-      try {
-        const client = await getClient(options.profile);
-        const products2 = await client.listProducts(serverId, { categoryId: options.categoryId });
-        output(products2, { json: options.json });
-      } catch (error) {
-        outputError(error instanceof Error ? error.message : String(error), {
-          json: options.json
-        });
+  shop.command("get-by-id").description("Get shop info by shop ID").argument("<shop-id>", "Shop ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (shopId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const shopData = await client.getShopById(shopId);
+      output(shopData, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  const me = shop.command("me").description("Personal shop commands");
+  me.command("get").description("Get my personal shop").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = await getClient(options.profile);
+      output(await client.getMyShop(), { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  me.command("upsert").description("Create or update my personal shop").option("--data <json>", "Shop JSON payload").option("--name <name>", "Shop name").option("--description <description>", "Shop description").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const payload = parseJsonObject(options.data, "--data");
+        if (options.name) payload.name = options.name;
+        if (options.description) payload.description = options.description;
+        output(await client.upsertMyShop(payload), { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  const products = shop.command("products").description("Product commands");
+  products.command("list").description("List products").argument("<server-id>", "Server ID").option("--category-id <id>", "Filter by category").option("--status <status>", "Filter by status").option("--keyword <keyword>", "Search keyword").option("--limit <n>", "Maximum products").option("--offset <n>", "Offset").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const products2 = await client.listProducts(serverId, {
+          categoryId: options.categoryId,
+          status: options.status,
+          keyword: options.keyword,
+          limit: parseOptionalNumber(options.limit, "--limit"),
+          offset: options.offset ? Number.parseInt(options.offset, 10) : void 0
+        });
+        output(products2, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  products.command("list-by-shop").description("List products by shop ID").argument("<shop-id>", "Shop ID").option("--keyword <keyword>", "Search keyword").option("--limit <n>", "Maximum products").option("--offset <n>", "Offset").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (shopId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const result = await client.listShopProducts(shopId, {
+          keyword: options.keyword,
+          limit: parseOptionalNumber(options.limit, "--limit"),
+          offset: options.offset ? Number.parseInt(options.offset, 10) : void 0
+        });
+        output(result, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
         process.exit(1);
       }
     }
@@ -1714,6 +2208,208 @@ function createShopCommand() {
       }
     }
   );
+  products.command("context").description("Get buyer-facing product context").argument("<product-id>", "Product ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (productId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      output(await client.getCommerceProductContext(productId), { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), {
+        json: options.json
+      });
+      process.exit(1);
+    }
+  });
+  products.command("create-by-shop").description("Create a product by shop ID using a JSON payload").argument("<shop-id>", "Shop ID").requiredOption("--data <json>", "Product JSON payload").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (shopId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      output(await client.createShopProduct(shopId, parseJsonObject(options.data, "--data")), {
+        json: options.json
+      });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), {
+        json: options.json
+      });
+      process.exit(1);
+    }
+  });
+  products.command("update-by-shop").description("Update a product by shop ID using a JSON payload").argument("<shop-id>", "Shop ID").argument("<product-id>", "Product ID").requiredOption("--data <json>", "Product JSON payload").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (shopId, productId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        output(
+          await client.updateShopProduct(
+            shopId,
+            productId,
+            parseJsonObject(options.data, "--data")
+          ),
+          { json: options.json }
+        );
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  products.command("purchase").description("Purchase a product by shop ID").argument("<shop-id>", "Shop ID").argument("<product-id>", "Product ID").option("--sku-id <id>", "SKU ID").requiredOption("--idempotency-key <key>", "Idempotency key").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (shopId, productId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        output(
+          await client.purchaseShopProduct(shopId, productId, {
+            skuId: options.skuId,
+            idempotencyKey: options.idempotencyKey
+          }),
+          { json: options.json }
+        );
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  const offers = shop.command("offers").description("Commerce offer commands");
+  offers.command("list").description("List commerce offers for a shop").argument("<shop-id>", "Shop ID").option("--keyword <keyword>", "Search keyword").option("--limit <n>", "Maximum offers").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (shopId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        output(
+          await client.listCommerceOffers(shopId, {
+            keyword: options.keyword,
+            limit: parseOptionalNumber(options.limit, "--limit")
+          }),
+          { json: options.json }
+        );
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  offers.command("create").description("Create a commerce offer for a shop").argument("<shop-id>", "Shop ID").requiredOption("--product-id <id>", "Product ID").option("--allowed-surfaces <list>", "Comma-separated surfaces, e.g. channel,dm").option("--price-override <amount>", "Price override").option("--seller-buddy-user-id <id>", "Seller Buddy user ID").option("--status <status>", "Offer status").option("--metadata <json>", "Metadata JSON object").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (shopId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        output(
+          await client.createCommerceOffer(shopId, {
+            productId: options.productId,
+            allowedSurfaces: options.allowedSurfaces ? options.allowedSurfaces.split(",").map((item) => item.trim()) : void 0,
+            priceOverride: options.priceOverride ? Number(options.priceOverride) : void 0,
+            sellerBuddyUserId: options.sellerBuddyUserId,
+            status: options.status,
+            metadata: options.metadata ? parseJsonObject(options.metadata, "--metadata") : void 0
+          }),
+          { json: options.json }
+        );
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  const deliverables = offers.command("deliverables").description("Commerce deliverable commands");
+  deliverables.command("create").description("Create a deliverable for an offer").argument("<shop-id>", "Shop ID").argument("<offer-id>", "Offer ID").requiredOption("--resource-id <id>", "Resource ID").option("--kind <kind>", "Deliverable kind").option("--resource-type <type>", "Resource type").option("--sender-buddy-user-id <id>", "Sender Buddy user ID").option("--message-template-key <key>", "Message template key").option("--metadata <json>", "Metadata JSON object").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (shopId, offerId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        output(
+          await client.createCommerceDeliverable(shopId, offerId, {
+            resourceId: options.resourceId,
+            kind: options.kind,
+            resourceType: options.resourceType,
+            senderBuddyUserId: options.senderBuddyUserId,
+            messageTemplateKey: options.messageTemplateKey,
+            metadata: options.metadata ? parseJsonObject(options.metadata, "--metadata") : void 0
+          }),
+          { json: options.json }
+        );
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  const assetDefinitions = shop.command("assets").description("Shop asset definition commands");
+  assetDefinitions.command("list").description("List shop asset definitions").argument("<shop-id>", "Shop ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (shopId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      output(await client.listShopAssetDefinitions(shopId), { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), {
+        json: options.json
+      });
+      process.exit(1);
+    }
+  });
+  assetDefinitions.command("create").description("Create a shop asset definition").argument("<shop-id>", "Shop ID").requiredOption("--asset-type <type>", "Asset type").requiredOption("--name <name>", "Asset name").option("--data <json>", "Additional asset definition JSON").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (shopId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        output(
+          await client.createShopAssetDefinition(shopId, {
+            ...parseJsonObject(options.data, "--data"),
+            assetType: options.assetType,
+            name: options.name
+          }),
+          { json: options.json }
+        );
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  assetDefinitions.command("update").description("Update a shop asset definition").argument("<shop-id>", "Shop ID").argument("<asset-definition-id>", "Asset definition ID").requiredOption("--data <json>", "Asset definition JSON payload").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (shopId, assetDefinitionId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        output(
+          await client.updateShopAssetDefinition(
+            shopId,
+            assetDefinitionId,
+            parseJsonObject(options.data, "--data")
+          ),
+          { json: options.json }
+        );
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  const entitlements = shop.command("entitlements").description("Shop entitlement commands");
+  entitlements.command("list").description("List entitlements for a shop").argument("<shop-id>", "Shop ID").option("--limit <n>", "Maximum entitlements").option("--offset <n>", "Offset").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (shopId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        output(
+          await client.listShopEntitlements(shopId, {
+            limit: parseOptionalNumber(options.limit, "--limit"),
+            offset: options.offset ? Number.parseInt(options.offset, 10) : void 0
+          }),
+          { json: options.json }
+        );
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
   const cart = shop.command("cart").description("Cart commands");
   cart.command("list").description("List cart items").argument("<server-id>", "Server ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (serverId, options) => {
     try {
@@ -1765,9 +2461,9 @@ function createShopCommand() {
 }
 
 // src/commands/status.ts
-import { Command as Command21 } from "commander";
+import { Command as Command23 } from "commander";
 function createStatusCommand() {
-  const status = new Command21("status").description("Show detailed status information");
+  const status = new Command23("status").description("Show detailed status information");
   status.option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     const outputOpts = { json: options.json };
     try {
@@ -1782,7 +2478,7 @@ function createStatusCommand() {
       }
       const client = await getClient(options.profile);
       const user = await client.getMe();
-      const notifications = await client.listNotifications(1).catch(() => []);
+      const unread = await client.getUnreadCount().catch(() => ({ count: 0 }));
       const statusInfo = {
         profile: {
           name: profileName,
@@ -1795,7 +2491,7 @@ function createStatusCommand() {
           avatarUrl: user.avatarUrl
         },
         stats: {
-          unreadNotifications: Array.isArray(notifications) ? notifications.length : 0
+          unreadNotifications: unread.count
         },
         connection: {
           status: "connected",
@@ -1845,9 +2541,9 @@ function createStatusCommand() {
 }
 
 // src/commands/threads.ts
-import { Command as Command22 } from "commander";
+import { Command as Command24 } from "commander";
 function createThreadsCommand() {
-  const threads = new Command22("threads").description("Thread commands");
+  const threads = new Command24("threads").description("Thread commands");
   threads.command("list").description("List threads in a channel").argument("<channel-id>", "Channel ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (channelId, options) => {
     try {
       const client = await getClient(options.profile);
@@ -1928,52 +2624,1359 @@ function createThreadsCommand() {
   return threads;
 }
 
-// src/commands/voice-enhance.ts
-import { Command as Command23 } from "commander";
-function createVoiceEnhanceCommand() {
-  const voice = new Command23("voice-enhance").description("Voice enhancement commands");
-  voice.command("enhance").description("Enhance a voice transcript").requiredOption("--transcript <text>", "Transcript text to enhance").option("--language <lang>", "Language code (e.g. zh-CN, en-US)").option("--no-self-correction", "Disable self-correction").option("--no-list-formatting", "Disable list formatting").option("--no-filler-removal", "Disable filler word removal").option("--tone-adjustment", "Enable tone adjustment").option("--target-tone <tone>", "Target tone (formal, casual, professional)").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
-    try {
-      const client = await getClient(options.profile);
-      const result = await client.enhanceVoice({
-        transcript: options.transcript,
-        language: options.language,
+// src/commands/voice.ts
+import { join as join2 } from "path";
+import { Command as Command25 } from "commander";
+
+// src/utils/voice-media-bridge.ts
+import { execFileSync as execFileSync2, spawn } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import { createWriteStream, existsSync } from "fs";
+import { mkdir, mkdtemp, open, readdir, readFile as readFile2, rm, stat, writeFile as writeFile2 } from "fs/promises";
+import { createServer } from "http";
+import { createRequire } from "module";
+import { homedir, tmpdir } from "os";
+import { basename as basename2, dirname, join } from "path";
+var require2 = createRequire(import.meta.url);
+var DEFAULT_SCREEN_INTERVAL_MS = 1e3;
+var MAX_POST_BYTES = 20 * 1024 * 1024;
+var PLAYWRIGHT_VERSION = "1.59.1";
+var defaultScreenIntervalMs = DEFAULT_SCREEN_INTERVAL_MS;
+async function runVoiceMediaBridge(options) {
+  const chromeExecutable = await findBrowserExecutable(options.browser, {
+    installBrowser: options.installBrowser,
+    json: options.json
+  });
+  const agoraScriptPath = resolveAgoraBrowserScript(options.agoraSdk);
+  const bridgeClientId = `shadowob-cli-media-bridge-${randomUUID2()}`;
+  const joinResult = await options.client.joinVoiceChannel(options.channelId, {
+    muted: options.muted,
+    clientId: bridgeClientId
+  });
+  const state = createRuntimeState(options, joinResult, agoraScriptPath, bridgeClientId);
+  let chrome = null;
+  try {
+    const server = createServer((req, res) => {
+      void handleBridgeRequest(state, req, res);
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const address = server.address();
+    if (!address || typeof address === "string") throw new Error("Failed to start media bridge");
+    state.baseUrl = `http://127.0.0.1:${address.port}/${state.token}`;
+    emitBridgeEvent(state, {
+      type: "bridge:started",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      detail: {
+        channelId: options.channelId,
+        audioOutDir: options.audioOutDir ?? null,
+        videoOutDir: options.videoOutDir ?? null,
+        screenOutDir: options.screenOutDir ?? null,
+        input: options.stdinPcm ? "stdin-pcm" : options.inputFile ? "file" : null
+      }
+    });
+    chrome = await launchChrome(chromeExecutable, `${state.baseUrl}/`, options);
+    attachConsoleInspector(chrome.port, state);
+    if (options.stdinPcm) {
+      startReadingStdinPcm(state);
+    }
+    await waitForBridgeStop(options.durationSeconds, chrome);
+    await shutdownBridge(state, server, chrome, options);
+  } catch (error) {
+    await shutdownBridge(state, null, chrome, options).catch(() => void 0);
+    throw error;
+  }
+}
+function createRuntimeState(options, joinResult, agoraScriptPath, clientId) {
+  return {
+    options,
+    joinResult,
+    agoraScriptPath,
+    clientId,
+    token: randomUUID2(),
+    baseUrl: "",
+    screenSeq: /* @__PURE__ */ new Map(),
+    audioSinks: /* @__PURE__ */ new Map(),
+    videoSinks: /* @__PURE__ */ new Map(),
+    pcmChunks: [],
+    pcmNextIndex: 0,
+    pendingPcmRequests: /* @__PURE__ */ new Set(),
+    stdinEnded: false,
+    shuttingDown: false
+  };
+}
+async function handleBridgeRequest(state, req, res) {
+  try {
+    const url = new URL(req.url ?? "/", state.baseUrl || "http://127.0.0.1");
+    const parts = url.pathname.split("/").filter(Boolean);
+    if (parts[0] !== state.token) {
+      sendText(res, 404, "Not found");
+      return;
+    }
+    const route = parts[1] ?? "";
+    if (req.method === "GET" && route === "") {
+      sendHtml(res, bridgeHtml(state.token));
+      return;
+    }
+    if (req.method === "GET" && route === "bridge.js") {
+      sendJavaScript(res, bridgeClientScript());
+      return;
+    }
+    if (req.method === "GET" && route === "agora.js") {
+      sendBuffer(res, await readFile2(state.agoraScriptPath), "application/javascript");
+      return;
+    }
+    if (req.method === "GET" && route === "config") {
+      sendJson(res, {
+        credentials: state.joinResult.credentials,
         options: {
-          enableSelfCorrection: options.selfCorrection !== false,
-          enableListFormatting: options.listFormatting !== false,
-          enableFillerRemoval: options.fillerRemoval !== false,
-          enableToneAdjustment: options.toneAdjustment === true,
-          targetTone: options.targetTone
+          muted: Boolean(state.options.muted),
+          recordAudio: Boolean(state.options.audioOutDir),
+          recordVideo: Boolean(state.options.videoOutDir),
+          recordScreen: Boolean(state.options.screenOutDir),
+          screenIntervalMs: state.options.screenIntervalMs,
+          input: state.options.stdinPcm ? {
+            mode: "stdin-pcm",
+            sampleRate: state.options.stdinSampleRate,
+            channels: state.options.stdinChannels
+          } : state.options.inputFile ? { mode: "file" } : null
         }
       });
-      output(result, { json: options.json });
-    } catch (error) {
-      outputError(error instanceof Error ? error.message : String(error), {
-        json: options.json
-      });
-      process.exit(1);
+      return;
     }
-  });
-  voice.command("config").description("Get voice enhancement config").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
-    try {
-      const client = await getClient(options.profile);
-      const config = await client.getVoiceConfig();
-      output(config, { json: options.json });
-    } catch (error) {
-      outputError(error instanceof Error ? error.message : String(error), {
-        json: options.json
+    if (req.method === "POST" && route === "token") {
+      const result = await state.options.client.renewVoiceCredentials(state.options.channelId, {
+        clientId: state.clientId
       });
-      process.exit(1);
+      state.joinResult = {
+        ...state.joinResult,
+        credentials: result.credentials,
+        state: result.state
+      };
+      sendJson(res, result);
+      return;
     }
-  });
-  return voice;
+    if (req.method === "GET" && route === "input-file") {
+      if (!state.options.inputFile) {
+        sendText(res, 404, "No input file configured");
+        return;
+      }
+      sendBuffer(
+        res,
+        await readFile2(state.options.inputFile),
+        mediaTypeForPath(state.options.inputFile)
+      );
+      return;
+    }
+    if (req.method === "GET" && route === "input-pcm") {
+      handleInputPcmRequest(state, Number(url.searchParams.get("cursor") ?? "0"), res);
+      return;
+    }
+    if (req.method === "POST" && route === "event") {
+      const body = await readRequestBody(req, MAX_POST_BYTES);
+      emitBridgeEvent(state, JSON.parse(body.toString("utf8")));
+      sendJson(res, { ok: true });
+      return;
+    }
+    if (req.method === "POST" && route === "audio") {
+      const uid = sanitizeSegment(url.searchParams.get("uid") ?? "unknown");
+      const sampleRate = Number(url.searchParams.get("sampleRate") ?? "48000");
+      const channels = Number(url.searchParams.get("channels") ?? "1");
+      const body = await readRequestBody(req, MAX_POST_BYTES);
+      await writeAudioChunk(state, uid, body, sampleRate, channels);
+      sendJson(res, { ok: true });
+      return;
+    }
+    if (req.method === "POST" && route === "screen") {
+      const uid = sanitizeSegment(url.searchParams.get("uid") ?? "unknown");
+      const body = await readRequestBody(req, MAX_POST_BYTES);
+      await writeScreenFrame(state, uid, body);
+      sendJson(res, { ok: true });
+      return;
+    }
+    if (req.method === "POST" && route === "video") {
+      const uid = sanitizeSegment(url.searchParams.get("uid") ?? "unknown");
+      const body = await readRequestBody(req, MAX_POST_BYTES);
+      await writeVideoChunk(state, uid, body);
+      sendJson(res, { ok: true });
+      return;
+    }
+    sendText(res, 404, "Not found");
+  } catch (error) {
+    sendJson(res, { ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
+  }
+}
+function bridgeHtml(token) {
+  return `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Shadow Voice Bridge</title>
+    <style>
+      body { margin: 0; background: #050607; color: #f3f4f6; font: 14px system-ui, sans-serif; }
+      main { padding: 18px; }
+      video { width: 320px; max-width: 100%; background: #000; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <strong>Shadow Voice Bridge</strong>
+      <div id="status">starting</div>
+      <div id="screens"></div>
+    </main>
+    <script>window.__SHADOW_BRIDGE_TOKEN__ = ${JSON.stringify(token)};</script>
+    <script src="./agora.js"></script>
+    <script type="module" src="./bridge.js"></script>
+  </body>
+</html>`;
+}
+function bridgeClientScript() {
+  return `
+const token = window.__SHADOW_BRIDGE_TOKEN__;
+const base = '/' + token;
+const statusEl = document.getElementById('status');
+const screenRoot = document.getElementById('screens');
+const config = await fetch(base + '/config').then((res) => res.json());
+const AgoraRTC = window.AgoraRTC;
+AgoraRTC.disableLogUpload?.();
+AgoraRTC.setLogLevel?.(3);
+
+const client = AgoraRTC.createClient({ mode: 'rtc', codec: 'vp8' });
+let credentials = config.credentials;
+let tokenRenewTimer = null;
+const audioRecorders = new Map();
+const screenRecorders = new Map();
+const videoRecorders = new Map();
+let inputAudioTrack = null;
+
+function setStatus(value) {
+  statusEl.textContent = value;
+}
+
+async function emit(type, detail = {}) {
+  const payload = { type, timestamp: new Date().toISOString(), ...detail };
+  console.log('[shadow-voice-bridge]', payload);
+  try {
+    await fetch(base + '/event', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+  } catch (error) {
+    console.error('failed to emit bridge event', error);
+  }
+}
+
+function clearTokenRenewal() {
+  if (!tokenRenewTimer) return;
+  clearTimeout(tokenRenewTimer);
+  tokenRenewTimer = null;
+}
+
+function scheduleTokenRenewal() {
+  clearTokenRenewal();
+  if (!credentials.expiresAt) return;
+  const renewAt = new Date(credentials.expiresAt).getTime() - 5 * 60_000;
+  const delay = Math.max(30_000, renewAt - Date.now());
+  tokenRenewTimer = setTimeout(() => {
+    void renewTokens();
+  }, delay);
+}
+
+async function renewTokens() {
+  const result = await fetch(base + '/token', { method: 'POST' }).then((res) => {
+    if (!res.ok) throw new Error('token renewal failed: ' + res.status);
+    return res.json();
+  });
+  credentials = result.credentials;
+  if (credentials.token) await client.renewToken(credentials.token);
+  scheduleTokenRenewal();
+  void emit('token:renewed', { detail: { expiresAt: credentials.expiresAt } });
+}
+
+function int16FromFloat32(input) {
+  const output = new Int16Array(input.length);
+  for (let index = 0; index < input.length; index += 1) {
+    const sample = Math.max(-1, Math.min(1, input[index]));
+    output[index] = sample < 0 ? sample * 0x8000 : sample * 0x7fff;
+  }
+  return output;
+}
+
+function startAudioRecorder(uid, track) {
+  if (!config.options.recordAudio || audioRecorders.has(String(uid))) return;
+  const mediaTrack = track.getMediaStreamTrack?.();
+  if (!mediaTrack) {
+    void emit('audio:unsupported', { uid: String(uid), message: 'remote audio track has no MediaStreamTrack' });
+    return;
+  }
+  const context = new AudioContext({ sampleRate: 48000 });
+  const source = context.createMediaStreamSource(new MediaStream([mediaTrack]));
+  const processor = context.createScriptProcessor(4096, 1, 1);
+  const mute = context.createGain();
+  mute.gain.value = 0;
+  processor.onaudioprocess = (event) => {
+    const channel = event.inputBuffer.getChannelData(0);
+    const pcm = int16FromFloat32(channel);
+    void fetch(base + '/audio?uid=' + encodeURIComponent(String(uid)) + '&sampleRate=' + context.sampleRate + '&channels=1', {
+      method: 'POST',
+      body: pcm.buffer,
+    }).catch(() => undefined);
+  };
+  source.connect(processor);
+  processor.connect(mute);
+  mute.connect(context.destination);
+  audioRecorders.set(String(uid), { context, source, processor, mute });
+  void emit('audio:recording-started', { uid: String(uid) });
+}
+
+function stopAudioRecorder(uid) {
+  const recorder = audioRecorders.get(String(uid));
+  if (!recorder) return;
+  recorder.processor.disconnect();
+  recorder.source.disconnect();
+  recorder.mute.disconnect();
+  void recorder.context.close();
+  audioRecorders.delete(String(uid));
+  void emit('audio:recording-stopped', { uid: String(uid) });
+}
+
+async function startScreenRecorder(uid, track) {
+  if ((!config.options.recordScreen && !config.options.recordVideo) || screenRecorders.has(String(uid))) return;
+  const mediaTrack = track.getMediaStreamTrack?.();
+  if (!mediaTrack) {
+    void emit('screen:unsupported', { uid: String(uid), message: 'remote video track has no MediaStreamTrack' });
+    return;
+  }
+  if (config.options.recordVideo && !videoRecorders.has(String(uid))) {
+    if (typeof MediaRecorder === 'undefined') {
+      void emit('video:unsupported', { uid: String(uid), message: 'MediaRecorder is not available' });
+    } else {
+    const stream = new MediaStream([mediaTrack.clone()]);
+    const mimeTypes = [
+      'video/webm;codecs=vp9',
+      'video/webm;codecs=vp8',
+      'video/webm',
+    ];
+    const mimeType = mimeTypes.find((candidate) => MediaRecorder.isTypeSupported(candidate)) || '';
+    try {
+      const recorder = new MediaRecorder(stream, mimeType ? { mimeType } : undefined);
+      recorder.ondataavailable = (event) => {
+        if (!event.data || event.data.size === 0) return;
+        void fetch(base + '/video?uid=' + encodeURIComponent(String(uid)), {
+          method: 'POST',
+          body: event.data,
+        }).catch(() => undefined);
+      };
+      recorder.onerror = (event) => {
+        void emit('video:error', { uid: String(uid), message: String(event.error?.message || event.type) });
+      };
+      recorder.start(1000);
+      videoRecorders.set(String(uid), { recorder, stream });
+      void emit('video:recording-started', { uid: String(uid), detail: { mimeType: recorder.mimeType } });
+    } catch (error) {
+      stream.getTracks().forEach((item) => item.stop());
+      void emit('video:unsupported', { uid: String(uid), message: error?.message || String(error) });
+    }
+    }
+  }
+  if (!config.options.recordScreen) return;
+  const video = document.createElement('video');
+  video.muted = true;
+  video.autoplay = true;
+  video.playsInline = true;
+  video.srcObject = new MediaStream([mediaTrack]);
+  screenRoot.append(video);
+  await video.play().catch(() => undefined);
+  const canvas = document.createElement('canvas');
+  const context = canvas.getContext('2d');
+  const timer = setInterval(() => {
+    const width = video.videoWidth || 1280;
+    const height = video.videoHeight || 720;
+    canvas.width = width;
+    canvas.height = height;
+    context.drawImage(video, 0, 0, width, height);
+    canvas.toBlob((blob) => {
+      if (!blob) return;
+      void fetch(base + '/screen?uid=' + encodeURIComponent(String(uid)), {
+        method: 'POST',
+        body: blob,
+      }).catch(() => undefined);
+    }, 'image/png');
+  }, Math.max(250, config.options.screenIntervalMs || 1000));
+  screenRecorders.set(String(uid), { video, timer });
+  void emit('screen:recording-started', { uid: String(uid) });
+}
+
+function stopScreenRecorder(uid) {
+  const recorder = screenRecorders.get(String(uid));
+  if (recorder) {
+    clearInterval(recorder.timer);
+    recorder.video.remove();
+    screenRecorders.delete(String(uid));
+    void emit('screen:recording-stopped', { uid: String(uid) });
+  }
+  const videoRecorder = videoRecorders.get(String(uid));
+  if (videoRecorder) {
+    try {
+      if (videoRecorder.recorder.state !== 'inactive') videoRecorder.recorder.stop();
+    } catch {
+      // Best effort shutdown; chunks already emitted are still kept.
+    }
+    videoRecorder.stream.getTracks().forEach((item) => item.stop());
+    videoRecorders.delete(String(uid));
+    void emit('video:recording-stopped', { uid: String(uid) });
+  }
+}
+
+async function publishInputFile() {
+  const response = await fetch(base + '/input-file');
+  const data = await response.arrayBuffer();
+  const context = new AudioContext();
+  const buffer = await context.decodeAudioData(data.slice(0));
+  await publishAudioBuffer(context, buffer);
+  void emit('input:file-published');
+}
+
+async function publishAudioBuffer(context, buffer) {
+  const destination = context.createMediaStreamDestination();
+  inputAudioTrack = AgoraRTC.createCustomAudioTrack({
+    mediaStreamTrack: destination.stream.getAudioTracks()[0],
+    encoderConfig: 'music_standard',
+  });
+  await client.publish([inputAudioTrack]);
+  const source = context.createBufferSource();
+  source.buffer = buffer;
+  source.connect(destination);
+  source.start();
+}
+
+async function publishStdinPcm() {
+  const input = config.options.input;
+  const context = new AudioContext({ sampleRate: input.sampleRate });
+  const destination = context.createMediaStreamDestination();
+  inputAudioTrack = AgoraRTC.createCustomAudioTrack({
+    mediaStreamTrack: destination.stream.getAudioTracks()[0],
+    encoderConfig: 'music_standard',
+  });
+  await client.publish([inputAudioTrack]);
+  let cursor = 0;
+  let playAt = context.currentTime + 0.2;
+  void emit('input:stdin-pcm-published', { detail: { sampleRate: input.sampleRate, channels: input.channels } });
+  while (true) {
+    const response = await fetch(base + '/input-pcm?cursor=' + cursor);
+    if (response.status === 204) {
+      if (response.headers.get('x-input-ended') === 'true') break;
+      await new Promise((resolve) => setTimeout(resolve, 40));
+      continue;
+    }
+    if (!response.ok) throw new Error('input-pcm failed: ' + response.status);
+    cursor = Number(response.headers.get('x-next-cursor') || cursor + 1);
+    const sampleRate = Number(response.headers.get('x-sample-rate') || input.sampleRate);
+    const channels = Number(response.headers.get('x-channels') || input.channels);
+    const pcm = new Int16Array(await response.arrayBuffer());
+    const frames = Math.floor(pcm.length / channels);
+    const buffer = context.createBuffer(1, frames, sampleRate);
+    const channel = buffer.getChannelData(0);
+    for (let frame = 0; frame < frames; frame += 1) {
+      channel[frame] = pcm[frame * channels] / 32768;
+    }
+    const source = context.createBufferSource();
+    source.buffer = buffer;
+    source.connect(destination);
+    playAt = Math.max(playAt, context.currentTime + 0.05);
+    source.start(playAt);
+    playAt += buffer.duration;
+  }
+  void emit('input:stdin-ended');
+}
+
+client.on('user-published', async (user, mediaType) => {
+  await client.subscribe(user, mediaType);
+  if (mediaType === 'audio' && user.audioTrack) {
+    startAudioRecorder(user.uid, user.audioTrack);
+    void emit('remote-audio:subscribed', { uid: String(user.uid) });
+  }
+  if (mediaType === 'video' && user.videoTrack) {
+    await startScreenRecorder(user.uid, user.videoTrack);
+    void emit('remote-screen:subscribed', { uid: String(user.uid) });
+  }
+});
+
+client.on('token-privilege-will-expire', () => {
+  void renewTokens().catch((error) => emit('token:error', { message: error.message }));
+});
+
+client.on('token-privilege-did-expire', () => {
+  void renewTokens().catch((error) => emit('token:error', { message: error.message }));
+});
+
+client.on('user-unpublished', (user, mediaType) => {
+  if (mediaType === 'audio') stopAudioRecorder(user.uid);
+  if (mediaType === 'video') stopScreenRecorder(user.uid);
+  void emit('remote-unpublished', { uid: String(user.uid), detail: { mediaType } });
+});
+
+window.addEventListener('error', (event) => {
+  void emit('browser:error', { message: event.message, detail: { filename: event.filename, lineno: event.lineno } });
+});
+window.addEventListener('unhandledrejection', (event) => {
+  void emit('browser:unhandled-rejection', { message: String(event.reason?.message || event.reason) });
+});
+
+window.__shadowVoiceBridgeStop = async () => {
+  clearTokenRenewal();
+  for (const uid of [...screenRecorders.keys(), ...videoRecorders.keys()]) {
+    stopScreenRecorder(uid);
+  }
+  if (inputAudioTrack) {
+    inputAudioTrack.stop?.();
+    inputAudioTrack.close?.();
+    inputAudioTrack = null;
+  }
+  await new Promise((resolve) => setTimeout(resolve, 600));
+  await client.leave().catch(() => undefined);
+  void emit('bridge:page-stopped');
+};
+
+try {
+  setStatus('joining');
+  await client.join(credentials.appId, credentials.agoraChannelName, credentials.token, credentials.uid);
+  setStatus('joined');
+  void emit('bridge:joined', { detail: { uid: credentials.uid, screenUid: credentials.screenUid } });
+  scheduleTokenRenewal();
+  if (config.options.input?.mode === 'file') await publishInputFile();
+  if (config.options.input?.mode === 'stdin-pcm') void publishStdinPcm().catch((error) => emit('input:error', { message: error.message }));
+} catch (error) {
+  setStatus('error');
+  void emit('bridge:error', { message: error?.message || String(error) });
+}
+`;
+}
+function resolveAgoraBrowserScript(explicit) {
+  if (explicit) {
+    if (!existsSync(explicit)) throw new Error(`Agora Web SDK script not found: ${explicit}`);
+    return explicit;
+  }
+  if (process.env.SHADOWOB_AGORA_WEB_SDK) {
+    if (!existsSync(process.env.SHADOWOB_AGORA_WEB_SDK)) {
+      throw new Error(`Agora Web SDK script not found: ${process.env.SHADOWOB_AGORA_WEB_SDK}`);
+    }
+    return process.env.SHADOWOB_AGORA_WEB_SDK;
+  }
+  const direct = tryRequireResolve("agora-rtc-sdk-ng/AgoraRTC_N-production.js");
+  if (direct) return direct;
+  const sdkEntry = tryRequireResolve("@shadowob/sdk");
+  if (sdkEntry) {
+    let current = dirname(sdkEntry);
+    for (let depth = 0; depth < 6; depth += 1) {
+      const candidate = join(
+        current,
+        "node_modules",
+        "agora-rtc-sdk-ng",
+        "AgoraRTC_N-production.js"
+      );
+      if (existsSync(candidate)) return candidate;
+      current = dirname(current);
+    }
+  }
+  throw new Error(
+    "Agora Web SDK is not available. Install agora-rtc-sdk-ng next to the CLI, or pass --agora-sdk / set SHADOWOB_AGORA_WEB_SDK to AgoraRTC_N-production.js."
+  );
+}
+function tryRequireResolve(specifier) {
+  try {
+    return require2.resolve(specifier);
+  } catch {
+    return null;
+  }
+}
+async function installVoiceTestBrowser(options = {}) {
+  const existing = await resolveVoiceTestBrowserPath();
+  if (existing) return existing;
+  const root = managedBrowserRoot();
+  await mkdir(root, { recursive: true });
+  const executable = process.platform === "win32" ? "npx.cmd" : "npx";
+  const args = ["--yes", `playwright@${PLAYWRIGHT_VERSION}`, "install", "chromium"];
+  const output2 = [];
+  await new Promise((resolve, reject) => {
+    const child = spawn(executable, args, {
+      env: {
+        ...process.env,
+        PLAYWRIGHT_BROWSERS_PATH: root
+      },
+      stdio: options.json ? ["ignore", "pipe", "pipe"] : "inherit"
+    });
+    if (options.json) {
+      child.stdout?.on("data", (chunk) => output2.push(Buffer.from(chunk)));
+      child.stderr?.on("data", (chunk) => output2.push(Buffer.from(chunk)));
+    }
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else {
+        const detail = Buffer.concat(output2).toString("utf8").trim();
+        reject(
+          new Error(
+            `Failed to install test Chromium with npx playwright install chromium${detail ? `: ${detail}` : ""}`
+          )
+        );
+      }
+    });
+  });
+  const installed = await resolveVoiceTestBrowserPath();
+  if (!installed)
+    throw new Error(`Chromium was installed under ${root}, but no executable was found`);
+  return installed;
+}
+async function resolveVoiceTestBrowserPath() {
+  const root = managedBrowserRoot();
+  if (!existsSync(root)) return null;
+  return findExecutableUnder(root, managedBrowserExecutableNames());
+}
+function managedBrowserRoot() {
+  return process.env.SHADOWOB_BROWSER_CACHE_DIR ? join(process.env.SHADOWOB_BROWSER_CACHE_DIR, "playwright") : join(homedir(), ".cache", "shadowob", "browsers", "playwright");
+}
+function managedBrowserExecutableNames() {
+  if (process.platform === "darwin") {
+    return ["Chromium.app/Contents/MacOS/Chromium", "Chrome.app/Contents/MacOS/Chrome"];
+  }
+  if (process.platform === "win32") return ["chrome.exe"];
+  return ["chrome", "chromium"];
+}
+async function findExecutableUnder(root, names) {
+  const queue = [root];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    let entries;
+    try {
+      entries = await readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) {
+        for (const name of names) {
+          const candidate = join(full, name);
+          if (existsSync(candidate)) return candidate;
+        }
+        queue.push(full);
+      } else if (entry.isFile() && names.includes(entry.name)) {
+        return full;
+      }
+    }
+  }
+  return null;
+}
+async function findBrowserExecutable(explicit, options = {}) {
+  if (explicit) {
+    if (!existsSync(explicit)) throw new Error(`Browser executable not found: ${explicit}`);
+    return explicit;
+  }
+  if (process.env.SHADOWOB_BROWSER && existsSync(process.env.SHADOWOB_BROWSER)) {
+    return process.env.SHADOWOB_BROWSER;
+  }
+  const managed = await resolveVoiceTestBrowserPath();
+  if (managed) return managed;
+  if (options.installBrowser) {
+    return installVoiceTestBrowser({ json: options.json });
+  }
+  const candidates = process.platform === "darwin" ? [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium"
+  ] : process.platform === "win32" ? [
+    `${process.env.PROGRAMFILES ?? "C:\\Program Files"}\\Google\\Chrome\\Application\\chrome.exe`,
+    `${process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)"}\\Google\\Chrome\\Application\\chrome.exe`
+  ] : ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"];
+  for (const candidate of candidates) {
+    if (candidate.includes("/") || candidate.includes("\\")) {
+      if (existsSync(candidate)) return candidate;
+      continue;
+    }
+    try {
+      return execFileSync2("which", [candidate], { encoding: "utf8" }).trim();
+    } catch {
+    }
+  }
+  throw new Error(
+    "No Chrome/Chromium executable found. Run shadowob voice browser install, pass --install-browser, or set SHADOWOB_BROWSER=/path/to/chrome."
+  );
+}
+async function launchChrome(executable, url, options) {
+  const port = await findFreePort();
+  const userDataDir = await mkdtemp(join(tmpdir(), "shadowob-voice-bridge-"));
+  const args = [
+    `--remote-debugging-port=${port}`,
+    "--remote-debugging-address=127.0.0.1",
+    `--user-data-dir=${userDataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-background-networking",
+    "--autoplay-policy=no-user-gesture-required",
+    "--disable-background-timer-throttling",
+    "--disable-renderer-backgrounding",
+    "--disable-sync",
+    "--disable-component-update",
+    "--disable-breakpad",
+    "--disable-gpu",
+    "--password-store=basic",
+    "--use-mock-keychain"
+  ];
+  if (!options.headful) args.push("--headless=new");
+  args.push(url);
+  const child = spawn(executable, args, { stdio: ["ignore", "pipe", "pipe"] });
+  child.port = port;
+  child.userDataDir = userDataDir;
+  let stderrBuffer = "";
+  child.stderr?.on("data", (chunk) => {
+    stderrBuffer += chunk.toString("utf8");
+    const lines = stderrBuffer.split(/\r?\n/);
+    stderrBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (/ERROR|ERR_|Exception/i.test(line) && !isIgnorableChromeStderr(line)) {
+        process.stderr.write(`${line}
+`);
+      }
+    }
+  });
+  child.on("exit", (code) => {
+    if (code !== 0 && code !== null) {
+      process.stderr.write(`Chrome exited with code ${code}
+`);
+    }
+  });
+  await waitForChrome(port);
+  return child;
+}
+async function attachConsoleInspector(port, state) {
+  try {
+    const pages = await fetchJson(`http://127.0.0.1:${port}/json/list`);
+    const page = pages.find((item) => item.type === "page" && item.url.startsWith(state.baseUrl));
+    if (!page?.webSocketDebuggerUrl) return;
+    const socket = new WebSocket(page.webSocketDebuggerUrl);
+    const requestUrls = /* @__PURE__ */ new Map();
+    let id = 0;
+    socket.addEventListener("open", () => {
+      for (const method of ["Runtime.enable", "Log.enable", "Network.enable"]) {
+        socket.send(JSON.stringify({ id: ++id, method }));
+      }
+    });
+    socket.addEventListener("message", (message) => {
+      const payload = JSON.parse(String(message.data));
+      if (payload.method === "Runtime.exceptionThrown") {
+        emitBridgeEvent(state, {
+          type: "browser:exception",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          detail: payload.params
+        });
+      }
+      if (payload.method === "Log.entryAdded") {
+        const entry = payload.params?.entry;
+        if (entry?.level === "error" && !isIgnorableBrowserDiagnosticUrl(entry.url)) {
+          emitBridgeEvent(state, {
+            type: "browser:console-error",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            message: entry.text,
+            detail: { url: entry.url }
+          });
+        }
+      }
+      if (payload.method === "Network.requestWillBeSent") {
+        const params = payload.params;
+        if (params?.requestId && params.request?.url) {
+          requestUrls.set(params.requestId, params.request.url);
+        }
+      }
+      if (payload.method === "Network.loadingFailed") {
+        const params = payload.params;
+        const url = params?.requestId ? requestUrls.get(params.requestId) : void 0;
+        if (params?.errorText && !params.canceled && !isIgnorableBrowserDiagnosticUrl(url)) {
+          emitBridgeEvent(state, {
+            type: "browser:network-failed",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            message: params.errorText,
+            detail: url ? { url } : void 0
+          });
+        }
+      }
+    });
+  } catch {
+  }
+}
+function isIgnorableBrowserDiagnosticUrl(url) {
+  if (!url) return false;
+  return url.endsWith("/favicon.ico") || url.includes("statscollector") || url.includes("update.googleapis.com") || url.includes("clients4.google.com");
+}
+function isIgnorableChromeStderr(line) {
+  return line.includes("ssl_client_socket_impl.cc") || line.includes("google_apis/gcm") || line.includes("video_capture_service_impl.cc") || line.includes("A BUNDLE group contains a codec collision") || line.includes("Inconsistent congestion control feedback types") || line.includes("task_policy_set TASK_CATEGORY_POLICY") || line.includes("task_policy_set TASK_SUPPRESSION_POLICY");
+}
+async function waitForChrome(port) {
+  const deadline = Date.now() + 3e4;
+  while (Date.now() < deadline) {
+    try {
+      await fetchJson(`http://127.0.0.1:${port}/json/version`);
+      return;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 120));
+    }
+  }
+  throw new Error("Timed out waiting for Chrome remote debugging");
+}
+async function fetchJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  return response.json();
+}
+async function findFreePort() {
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  await new Promise((resolve) => server.close(() => resolve()));
+  if (!address || typeof address === "string") throw new Error("Failed to allocate port");
+  return address.port;
+}
+function startReadingStdinPcm(state) {
+  process.stdin.on("data", (chunk) => {
+    const entry = { index: state.pcmNextIndex++, data: Buffer.from(chunk) };
+    state.pcmChunks.push(entry);
+    if (state.pcmChunks.length > 512) state.pcmChunks.shift();
+    flushPendingPcmRequests(state);
+  });
+  process.stdin.on("end", () => {
+    state.stdinEnded = true;
+    flushPendingPcmRequests(state);
+  });
+  process.stdin.resume();
+}
+function handleInputPcmRequest(state, cursor, res) {
+  const next = state.pcmChunks.find((chunk) => chunk.index >= cursor);
+  if (next) {
+    sendPcmChunk(state, res, next);
+    return;
+  }
+  if (state.stdinEnded) {
+    res.writeHead(204, { "x-input-ended": "true" });
+    res.end();
+    return;
+  }
+  const pending = {
+    cursor,
+    res,
+    timer: setTimeout(() => {
+      state.pendingPcmRequests.delete(pending);
+      if (!res.writableEnded) {
+        res.writeHead(204);
+        res.end();
+      }
+    }, 15e3)
+  };
+  state.pendingPcmRequests.add(pending);
+}
+function flushPendingPcmRequests(state) {
+  for (const pending of [...state.pendingPcmRequests]) {
+    const next = state.pcmChunks.find((chunk) => chunk.index >= pending.cursor);
+    if (!next && !state.stdinEnded) continue;
+    clearTimeout(pending.timer);
+    state.pendingPcmRequests.delete(pending);
+    if (pending.res.writableEnded) continue;
+    if (next) sendPcmChunk(state, pending.res, next);
+    else {
+      pending.res.writeHead(204, { "x-input-ended": "true" });
+      pending.res.end();
+    }
+  }
+}
+function sendPcmChunk(state, res, chunk) {
+  res.writeHead(200, {
+    "content-type": "application/octet-stream",
+    "x-next-cursor": String(chunk.index + 1),
+    "x-sample-rate": String(state.options.stdinSampleRate),
+    "x-channels": String(state.options.stdinChannels)
+  });
+  res.end(chunk.data);
+}
+async function writeAudioChunk(state, uid, chunk, sampleRate, channels) {
+  if (!state.options.audioOutDir || chunk.length === 0) return;
+  await mkdir(state.options.audioOutDir, { recursive: true });
+  let sink = state.audioSinks.get(uid);
+  if (!sink) {
+    const path = join(state.options.audioOutDir, `${uid}-${Date.now()}.wav`);
+    const stream = createWriteStream(path);
+    stream.write(wavHeader(sampleRate, channels, 0));
+    sink = { stream, path, sampleRate, channels, bytes: 0 };
+    state.audioSinks.set(uid, sink);
+    emitBridgeEvent(state, {
+      type: "audio:file-started",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uid,
+      path
+    });
+  }
+  sink.stream.write(chunk);
+  sink.bytes += chunk.length;
+}
+async function writeScreenFrame(state, uid, chunk) {
+  if (!state.options.screenOutDir || chunk.length === 0) return;
+  await mkdir(state.options.screenOutDir, { recursive: true });
+  const seq = (state.screenSeq.get(uid) ?? 0) + 1;
+  state.screenSeq.set(uid, seq);
+  const path = join(state.options.screenOutDir, `${uid}-${String(seq).padStart(6, "0")}.png`);
+  await writeFile2(path, chunk);
+  emitBridgeEvent(state, {
+    type: "screen:frame",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    uid,
+    path
+  });
+}
+async function writeVideoChunk(state, uid, chunk) {
+  if (!state.options.videoOutDir || chunk.length === 0) return;
+  await mkdir(state.options.videoOutDir, { recursive: true });
+  let sink = state.videoSinks.get(uid);
+  if (!sink) {
+    const path = join(state.options.videoOutDir, `${uid}-${Date.now()}.webm`);
+    const stream = createWriteStream(path);
+    sink = { stream, path, bytes: 0 };
+    state.videoSinks.set(uid, sink);
+    emitBridgeEvent(state, {
+      type: "video:file-started",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uid,
+      path
+    });
+  }
+  sink.stream.write(chunk);
+  sink.bytes += chunk.length;
+}
+async function closeAudioSinks(state) {
+  await Promise.all(
+    [...state.audioSinks.values()].map(
+      (sink) => new Promise((resolve) => {
+        sink.stream.end(async () => {
+          const file = await open(sink.path, "r+");
+          try {
+            await file.write(wavHeader(sink.sampleRate, sink.channels, sink.bytes), 0, 44, 0);
+          } finally {
+            await file.close();
+          }
+          emitBridgeEvent(state, {
+            type: "audio:file-finished",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            path: sink.path,
+            detail: { bytes: sink.bytes }
+          });
+          resolve();
+        });
+      })
+    )
+  );
+  state.audioSinks.clear();
+}
+async function closeVideoSinks(state) {
+  await Promise.all(
+    [...state.videoSinks.values()].map(
+      (sink) => new Promise((resolve) => {
+        sink.stream.end(() => {
+          emitBridgeEvent(state, {
+            type: "video:file-finished",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            path: sink.path,
+            detail: { bytes: sink.bytes }
+          });
+          resolve();
+        });
+      })
+    )
+  );
+  state.videoSinks.clear();
+}
+function wavHeader(sampleRate, channels, dataBytes) {
+  const header = Buffer.alloc(44);
+  const byteRate = sampleRate * channels * 2;
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + dataBytes, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(channels, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(byteRate, 28);
+  header.writeUInt16LE(channels * 2, 32);
+  header.writeUInt16LE(16, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(dataBytes, 40);
+  return header;
+}
+async function shutdownBridge(state, server, chrome, options) {
+  if (state.shuttingDown) return;
+  state.shuttingDown = true;
+  if (chrome) await stopBridgePage(chrome.port, state).catch(() => void 0);
+  await options.client.leaveVoiceChannel(options.channelId, { clientId: state.clientId }).catch(() => void 0);
+  await closeAudioSinks(state).catch(() => void 0);
+  await closeVideoSinks(state).catch(() => void 0);
+  for (const pending of state.pendingPcmRequests) {
+    clearTimeout(pending.timer);
+    if (!pending.res.writableEnded) {
+      pending.res.writeHead(204, { "x-input-ended": "true" });
+      pending.res.end();
+    }
+  }
+  state.pendingPcmRequests.clear();
+  if (server) await new Promise((resolve) => server.close(() => resolve()));
+  if (chrome && !options.keepBrowser) {
+    chrome.kill("SIGTERM");
+    if (chrome.userDataDir)
+      await rm(chrome.userDataDir, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function stopBridgePage(port, state) {
+  const pages = await fetchJson(`http://127.0.0.1:${port}/json/list`);
+  const page = pages.find((item) => item.type === "page" && item.url.startsWith(state.baseUrl));
+  if (!page?.webSocketDebuggerUrl) return;
+  const debuggerUrl = page.webSocketDebuggerUrl;
+  await new Promise((resolve) => {
+    const socket = new WebSocket(debuggerUrl);
+    const timer = setTimeout(() => {
+      socket.close();
+      resolve();
+    }, 3e3);
+    const finish = () => {
+      clearTimeout(timer);
+      socket.close();
+      resolve();
+    };
+    socket.addEventListener("open", () => {
+      socket.send(
+        JSON.stringify({
+          id: 1,
+          method: "Runtime.evaluate",
+          params: {
+            expression: "window.__shadowVoiceBridgeStop?.()",
+            awaitPromise: true,
+            returnByValue: true
+          }
+        })
+      );
+    });
+    socket.addEventListener("message", (message) => {
+      const payload = JSON.parse(String(message.data));
+      if (payload.id === 1) finish();
+    });
+    socket.addEventListener("error", finish);
+    socket.addEventListener("close", finish);
+  });
+}
+async function waitForBridgeStop(durationSeconds, chrome) {
+  await new Promise((resolve) => {
+    let timer;
+    const done = () => {
+      if (timer) clearTimeout(timer);
+      process.off("SIGINT", done);
+      process.off("SIGTERM", done);
+      chrome.off("exit", done);
+      resolve();
+    };
+    if (durationSeconds && durationSeconds > 0) {
+      timer = setTimeout(done, durationSeconds * 1e3);
+    }
+    process.once("SIGINT", done);
+    process.once("SIGTERM", done);
+    chrome.once("exit", done);
+  });
+}
+function emitBridgeEvent(state, event) {
+  if (state.options.json) {
+    console.log(JSON.stringify(event));
+    return;
+  }
+  const suffix = event.path ? ` ${event.path}` : event.message ? ` ${event.message}` : "";
+  console.log(`[${event.timestamp}] ${event.type}${event.uid ? ` uid=${event.uid}` : ""}${suffix}`);
+}
+function readRequestBody(req, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    req.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > maxBytes) {
+        reject(new Error("Request body is too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+function sendJson(res, data, status = 200) {
+  sendBuffer(res, Buffer.from(JSON.stringify(data)), "application/json", status);
+}
+function sendHtml(res, html) {
+  sendBuffer(res, Buffer.from(html), "text/html; charset=utf-8");
+}
+function sendJavaScript(res, js) {
+  sendBuffer(res, Buffer.from(js), "application/javascript; charset=utf-8");
+}
+function sendText(res, status, text) {
+  sendBuffer(res, Buffer.from(text), "text/plain; charset=utf-8", status);
+}
+function sendBuffer(res, body, contentType, status = 200) {
+  res.writeHead(status, {
+    "content-type": contentType,
+    "content-length": body.length,
+    "cache-control": "no-store"
+  });
+  res.end(body);
+}
+function sanitizeSegment(value) {
+  return value.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 80) || "unknown";
+}
+function mediaTypeForPath(path) {
+  const name = basename2(path).toLowerCase();
+  if (name.endsWith(".wav")) return "audio/wav";
+  if (name.endsWith(".mp3")) return "audio/mpeg";
+  if (name.endsWith(".ogg")) return "audio/ogg";
+  return "application/octet-stream";
+}
+async function validateVoiceBridgeOptions(options) {
+  if (options.inputFile) {
+    const info = await stat(options.inputFile);
+    if (!info.isFile()) throw new Error(`Input audio path is not a file: ${options.inputFile}`);
+  }
+  if (options.audioOutDir) await mkdir(options.audioOutDir, { recursive: true });
+  if (options.videoOutDir) await mkdir(options.videoOutDir, { recursive: true });
+  if (options.screenOutDir) await mkdir(options.screenOutDir, { recursive: true });
+  if (!Number.isFinite(options.stdinSampleRate) || options.stdinSampleRate < 8e3) {
+    throw new Error("--sample-rate must be at least 8000");
+  }
+  if (![1, 2].includes(options.stdinChannels)) {
+    throw new Error("--channels must be 1 or 2");
+  }
+}
+
+// src/commands/voice.ts
+function resolveProfileOption(options, command) {
+  return options.profile ?? command.optsWithGlobals().profile;
+}
+function createVoiceCommand() {
+  const voice = new Command25("voice").description("Voice channel commands");
+  voice.command("join").description("Join a voice channel and print Agora connection info").argument("<channel-id>", "Voice channel ID").option("--muted", "Join muted").option("--deafened", "Join deafened").option("--watch", "Keep the process attached and print voice events").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (channelId, options, command) => {
+      try {
+        const profile = resolveProfileOption(options, command);
+        const client = await getClient(profile);
+        const clientId = options.watch ? `shadowob-cli-${Date.now()}-${Math.random().toString(36).slice(2)}` : "shadowob-cli";
+        const result = await client.joinVoiceChannel(channelId, {
+          muted: options.muted,
+          deafened: options.deafened,
+          clientId
+        });
+        output(result, { json: options.json });
+        if (!options.watch) return;
+        const socket = await getSocket(profile);
+        socket.on("voice:participant-joined", (event) => output(event, { json: options.json }));
+        socket.on("voice:participant-left", (event) => output(event, { json: options.json }));
+        socket.on("voice:participant-updated", (event) => output(event, { json: options.json }));
+        socket.connect();
+        await socket.waitForConnect();
+        await socket.joinVoiceChannel(channelId, {
+          muted: options.muted,
+          deafened: options.deafened,
+          clientId
+        });
+        process.on("SIGINT", () => {
+          void client.leaveVoiceChannel(channelId, { clientId }).finally(() => process.exit(0));
+        });
+        socket.raw.on("disconnect", () => process.exit(0));
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  voice.command("leave").description("Leave a voice channel").argument("<channel-id>", "Voice channel ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (channelId, options, command) => {
+      try {
+        const client = await getClient(resolveProfileOption(options, command));
+        await client.leaveVoiceChannel(channelId);
+        outputSuccess("Left voice channel", { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  voice.command("status").description("Show voice channel state").argument("<channel-id>", "Voice channel ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (channelId, options, command) => {
+      try {
+        const client = await getClient(resolveProfileOption(options, command));
+        output(await client.getVoiceState(channelId), { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  voice.command("mute").description("Set local voice mute state").argument("<channel-id>", "Voice channel ID").option("--off", "Unmute instead of mute").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (channelId, options, command) => {
+      try {
+        const client = await getClient(resolveProfileOption(options, command));
+        output(await client.updateVoiceState(channelId, { muted: !options.off }), {
+          json: options.json
+        });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  voice.command("bridge").description(
+    "Join a voice channel through a local Chrome/Chromium media bridge for audio and screen data"
+  ).argument("<channel-id>", "Voice channel ID").option("--record-out <dir>", "Record a full media archive with audio WAV and video WebM files").option("--audio-out <dir>", "Record remote audio tracks as per-user WAV files").option("--video-out <dir>", "Record remote video or screen-share tracks as WebM files").option("--screen-out <dir>", "Record remote screen shares as PNG frame sequences").option(
+    "--screen-interval-ms <ms>",
+    "Screen-share capture interval in milliseconds",
+    String(defaultScreenIntervalMs)
+  ).option("--input <file>", "Publish an audio file into the voice channel").option("--stdin-pcm", "Publish raw signed 16-bit little-endian PCM from stdin").option("--sample-rate <hz>", "Sample rate for --stdin-pcm", "24000").option("--channels <count>", "Channel count for --stdin-pcm", "1").option("--browser <path>", "Chrome/Chromium executable path, or set SHADOWOB_BROWSER").option("--install-browser", "Install an isolated test Chromium when no managed browser exists").option(
+    "--agora-sdk <path>",
+    "Agora Web SDK browser bundle path, or set SHADOWOB_AGORA_WEB_SDK"
+  ).option("--headful", "Run Chrome/Chromium with a visible window").option("--keep-browser", "Keep the browser profile open after the bridge exits").option("--duration <seconds>", "Run for a fixed duration, then leave the voice channel").option("--muted", "Join Shadow voice presence as muted").option("--profile <name>", "Profile to use").option("--json", "Output bridge events as JSON lines").action(
+    async (channelId, options, command) => {
+      try {
+        if (options.input && options.stdinPcm) {
+          throw new Error("Use either --input or --stdin-pcm, not both");
+        }
+        const screenIntervalMs = parsePositiveInt(
+          options.screenIntervalMs,
+          "--screen-interval-ms"
+        );
+        const stdinSampleRate = parsePositiveInt(options.sampleRate, "--sample-rate");
+        const stdinChannels = parsePositiveInt(options.channels, "--channels");
+        const durationSeconds = options.duration ? parsePositiveInt(options.duration, "--duration") : void 0;
+        const audioOutDir = options.audioOut ?? (options.recordOut ? join2(options.recordOut, "audio") : void 0);
+        const videoOutDir = options.videoOut ?? (options.recordOut ? join2(options.recordOut, "video") : void 0);
+        await validateVoiceBridgeOptions({
+          audioOutDir,
+          videoOutDir,
+          screenOutDir: options.screenOut,
+          inputFile: options.input,
+          stdinSampleRate,
+          stdinChannels
+        });
+        const client = await getClient(resolveProfileOption(options, command));
+        await runVoiceMediaBridge({
+          client,
+          channelId,
+          muted: options.muted,
+          browser: options.browser,
+          installBrowser: options.installBrowser,
+          agoraSdk: options.agoraSdk,
+          headful: options.headful,
+          keepBrowser: options.keepBrowser,
+          durationSeconds,
+          audioOutDir,
+          videoOutDir,
+          screenOutDir: options.screenOut,
+          screenIntervalMs,
+          inputFile: options.input,
+          stdinPcm: options.stdinPcm,
+          stdinSampleRate,
+          stdinChannels,
+          json: options.json
+        });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  const browser = new Command25("browser").description("Voice bridge browser runtime commands");
+  browser.command("install").description("Install an isolated Chromium runtime for voice bridge tests").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const executable = await installVoiceTestBrowser({ json: options.json });
+      output({ executable }, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), {
+        json: options.json
+      });
+      process.exit(1);
+    }
+  });
+  browser.command("path").description("Show the installed voice bridge test browser path").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const executable = await resolveVoiceTestBrowserPath();
+      if (!executable) {
+        throw new Error("No managed voice bridge browser is installed");
+      }
+      output({ executable }, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), {
+        json: options.json
+      });
+      process.exit(1);
+    }
+  });
+  voice.addCommand(browser);
+  return voice;
+}
+
+// src/commands/voice-enhance.ts
+import { Command as Command26 } from "commander";
+function createVoiceEnhanceCommand() {
+  const voice = new Command26("voice-enhance").description("Voice enhancement commands");
+  voice.command("enhance").description("Enhance a voice transcript").requiredOption("--transcript <text>", "Transcript text to enhance").option("--language <lang>", "Language code (e.g. zh-CN, en-US)").option("--no-self-correction", "Disable self-correction").option("--no-list-formatting", "Disable list formatting").option("--no-filler-removal", "Disable filler word removal").option("--tone-adjustment", "Enable tone adjustment").option("--target-tone <tone>", "Target tone (formal, casual, professional)").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = await getClient(options.profile);
+      const result = await client.enhanceVoice({
+        transcript: options.transcript,
+        language: options.language,
+        options: {
+          enableSelfCorrection: options.selfCorrection !== false,
+          enableListFormatting: options.listFormatting !== false,
+          enableFillerRemoval: options.fillerRemoval !== false,
+          enableToneAdjustment: options.toneAdjustment === true,
+          targetTone: options.targetTone
+        }
+      });
+      output(result, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), {
+        json: options.json
+      });
+      process.exit(1);
+    }
+  });
+  voice.command("config").description("Get voice enhancement config").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = await getClient(options.profile);
+      const config = await client.getVoiceConfig();
+      output(config, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), {
+        json: options.json
+      });
+      process.exit(1);
+    }
+  });
+  return voice;
 }
 
 // src/commands/workspace.ts
-import { readFile } from "fs/promises";
-import { Command as Command24 } from "commander";
+import { readFile as readFile3 } from "fs/promises";
+import { Command as Command27 } from "commander";
 function createWorkspaceCommand() {
-  const workspace = new Command24("workspace").description("Workspace file management commands");
+  const workspace = new Command27("workspace").description("Workspace file management commands");
   workspace.command("get").description("Get workspace info").argument("<server-id>", "Server ID or slug").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (serverId, options) => {
     try {
       const client = await getClient(options.profile);
@@ -2069,7 +4072,7 @@ function createWorkspaceCommand() {
     async (serverId, options) => {
       try {
         const client = await getClient(options.profile);
-        const content = await readFile(options.file);
+        const content = await readFile3(options.file);
         const blob = new Blob([content]);
         const name = options.name ?? options.file.split("/").pop() ?? "upload";
         const result = await client.uploadWorkspaceFile(serverId, blob, name, options.parentId);
@@ -2155,12 +4158,13 @@ function createWorkspaceCommand() {
 }
 
 // src/index.ts
-var program = new Command25();
+var program = new Command28();
 program.name("shadowob").description("Shadow CLI \u2014 command-line interface for Shadow servers").version("0.1.0").configureHelp({
   sortSubcommands: true
 });
 program.option("--profile <name>", "Profile to use (default: current)");
 program.addCommand(createAuthCommand());
+program.addCommand(createAppCommand());
 program.addCommand(createServersCommand());
 program.addCommand(createChannelsCommand());
 program.addCommand(createThreadsCommand());
@@ -2169,6 +4173,7 @@ program.addCommand(createListenCommand());
 program.addCommand(createDirectMessagesCommand());
 program.addCommand(createWorkspaceCommand());
 program.addCommand(createShopCommand());
+program.addCommand(createCommerceCommand());
 program.addCommand(createNotificationsCommand());
 program.addCommand(createFriendsCommand());
 program.addCommand(createInvitesCommand());
@@ -2183,5 +4188,6 @@ program.addCommand(createCloudCommand());
 program.addCommand(createApiTokensCommand());
 program.addCommand(createDiscoverCommand());
 program.addCommand(createProfileCommentsCommand());
+program.addCommand(createVoiceCommand());
 program.addCommand(createVoiceEnhanceCommand());
 program.parse();