@shadowob/cli 1.1.6 → 1.1.8

package/dist/index.js

@@ -4,13 +4,14 @@ import {
   getClient,
   getClientWithToken,
   getSocket,
-  parsePositiveInt
-} from "./chunk-E364BDQO.js";
+  parsePositiveInt,
+  resolveServerFlag
+} from "./chunk-S6XCO6ZW.js";
 
 // src/index.ts
-import { Command as Command28 } from "commander";
+import { Command as Command29 } from "commander";
 
-// src/commands/agents.ts
+// src/commands/api-tokens.ts
 import { Command } from "commander";
 
 // src/utils/output.ts
@@ -88,139 +89,32 @@ function formatObject(obj) {
       formattedValue = chalk.gray("null");
     } else if (typeof value === "boolean") {
       formattedValue = value ? chalk.green("true") : chalk.red("false");
-    } else if (typeof value === "object") {
+    } else if (Array.isArray(value)) {
+      if (value.length > 0 && typeof value[0] === "object" && value[0] !== null) {
+        console.log(chalk.gray(formattedKey));
+        formatArray(value);
+        continue;
+      }
       formattedValue = JSON.stringify(value);
+    } else if (typeof value === "object") {
+      formattedValue = formatNestedValue(value);
     } else {
       formattedValue = String(value);
     }
     console.log(`${chalk.gray(formattedKey)}  ${formattedValue}`);
   }
 }
-
-// src/commands/agents.ts
-function createAgentsCommand() {
-  const agents = new Command("agents").description("Agent management commands");
-  agents.command("list").description("List your agents").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
-    try {
-      const client = await getClient(options.profile);
-      const agents2 = await client.listAgents();
-      output(agents2, { json: options.json });
-    } catch (error) {
-      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
-      process.exit(1);
-    }
-  });
-  agents.command("get").description("Get agent details").argument("<agent-id>", "Agent ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (agentId, options) => {
-    try {
-      const client = await getClient(options.profile);
-      const agent = await client.getAgent(agentId);
-      output(agent, { json: options.json });
-    } catch (error) {
-      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
-      process.exit(1);
-    }
-  });
-  agents.command("create").description("Create a new agent").requiredOption("--name <name>", "Agent name").requiredOption("--username <username>", "Agent username").option("--display-name <name>", "Display name").option("--avatar-url <url>", "Avatar URL").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
-    async (options) => {
-      try {
-        const client = await getClient(options.profile);
-        const agent = await client.createAgent({
-          name: options.name,
-          username: options.username,
-          displayName: options.displayName,
-          avatarUrl: options.avatarUrl
-        });
-        output(agent, { json: options.json });
-      } catch (error) {
-        outputError(error instanceof Error ? error.message : String(error), {
-          json: options.json
-        });
-        process.exit(1);
-      }
-    }
-  );
-  agents.command("update").description("Update an agent").argument("<agent-id>", "Agent ID").option("--name <name>", "New name").option("--display-name <name>", "New display name").option("--avatar-url <url>", "New avatar URL").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
-    async (agentId, options) => {
-      try {
-        const client = await getClient(options.profile);
-        const agent = await client.updateAgent(agentId, {
-          name: options.name,
-          displayName: options.displayName,
-          avatarUrl: options.avatarUrl
-        });
-        output(agent, { json: options.json });
-      } catch (error) {
-        outputError(error instanceof Error ? error.message : String(error), {
-          json: options.json
-        });
-        process.exit(1);
-      }
-    }
-  );
-  agents.command("delete").description("Delete an agent").argument("<agent-id>", "Agent ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (agentId, options) => {
-    try {
-      const client = await getClient(options.profile);
-      await client.deleteAgent(agentId);
-      const outputOpts = { json: options.json };
-      outputSuccess("Agent deleted", outputOpts);
-    } catch (error) {
-      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
-      process.exit(1);
-    }
-  });
-  agents.command("start").description("Start an agent").argument("<agent-id>", "Agent ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (agentId, options) => {
-    try {
-      const client = await getClient(options.profile);
-      await client.startAgent(agentId);
-      const outputOpts = { json: options.json };
-      outputSuccess("Agent started", outputOpts);
-    } catch (error) {
-      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
-      process.exit(1);
-    }
-  });
-  agents.command("stop").description("Stop an agent").argument("<agent-id>", "Agent ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (agentId, options) => {
-    try {
-      const client = await getClient(options.profile);
-      await client.stopAgent(agentId);
-      const outputOpts = { json: options.json };
-      outputSuccess("Agent stopped", outputOpts);
-    } catch (error) {
-      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
-      process.exit(1);
-    }
-  });
-  agents.command("token").description("Generate a new token for an agent").argument("<agent-id>", "Agent ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (agentId, options) => {
-    try {
-      const client = await getClient(options.profile);
-      const result = await client.generateAgentToken(agentId);
-      if (options.json) {
-        output(result, { json: true });
-      } else {
-        console.log(result.token);
-      }
-    } catch (error) {
-      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
-      process.exit(1);
-    }
-  });
-  agents.command("config").description("Get agent remote config").argument("<agent-id>", "Agent ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (agentId, options) => {
-    try {
-      const client = await getClient(options.profile);
-      const config = await client.getAgentConfig(agentId);
-      output(config, { json: options.json });
-    } catch (error) {
-      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
-      process.exit(1);
-    }
-  });
-  return agents;
+function formatNestedValue(obj) {
+  const username = obj.username || obj.name || obj.displayName;
+  if (username) {
+    return username;
+  }
+  return JSON.stringify(obj);
 }
 
 // src/commands/api-tokens.ts
-import { Command as Command2 } from "commander";
 function createApiTokensCommand() {
-  const tokens = new Command2("api-tokens").description("API token management commands");
+  const tokens = new Command("api-tokens").description("API token management commands");
   tokens.command("list").description("List all API tokens").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient(options.profile);
@@ -270,12 +164,7 @@ function createApiTokensCommand() {
 // 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;
-}
+import { Command as Command2 } from "commander";
 function parseJsonInput(value) {
   if (!value) return {};
   const parsed = JSON.parse(value);
@@ -287,16 +176,135 @@ function parseJsonInput(value) {
 async function readJsonFile(path) {
   return JSON.parse(await readFile(path, "utf8"));
 }
+function parsePermissions(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
 function commandHandlerError(error, json) {
   outputError(error instanceof Error ? error.message : String(error), { json });
   process.exit(1);
 }
+function prettyJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+function commandSummary(command) {
+  return command.help?.summary ?? command.description ?? command.title ?? command.permission;
+}
+function formatAppCommandHelp(input) {
+  const { appKey, serverId, manifest, commandName } = input;
+  const command = commandName ? manifest.commands.find((item) => item.name === commandName) : void 0;
+  if (commandName && !command) throw new Error(`App command not found: ${commandName}`);
+  if (!command) {
+    const lines2 = [
+      `${manifest.name} (${appKey})`,
+      manifest.description ?? "",
+      manifest.help?.overview ?? "",
+      "",
+      "Usage:",
+      `  shadowob app call ${appKey} <command> --server "${serverId}" --json-input '<input-json>' --json`,
+      `  shadowob app call ${appKey} <command> --server "${serverId}" --help`,
+      manifest.binary?.supported ? `  shadowob app call ${appKey} <command> --server "${serverId}" --file ./asset.png --json-input '<input-json>' --json` : "",
+      "",
+      "Commands:",
+      ...manifest.commands.map((item) => `  ${item.name.padEnd(24)} ${commandSummary(item)}`),
+      manifest.realtime ? [
+        "",
+        "Realtime:",
+        `  shadowob app events ${appKey} --server "${serverId}" --json`,
+        manifest.realtime.subscribe?.help ?? "",
+        manifest.realtime.publish?.help ?? ""
+      ].join("\n") : ""
+    ];
+    return lines2.filter(Boolean).join("\n");
+  }
+  const help = command.help;
+  const usage = help?.usage ?? `shadowob app call ${appKey} ${command.name} --server "${serverId}" --json-input '<input-json>' --json`;
+  const lines = [
+    `${manifest.name} ${command.name}`,
+    commandSummary(command),
+    "",
+    "Usage:",
+    `  ${usage}`,
+    command.binary?.supported || command.input === "multipart" ? `  shadowob app call ${appKey} ${command.name} --server "${serverId}" --file ./asset.png --json-input '<input-json>' --json` : "",
+    help?.details ? ["", help.details].join("\n") : "",
+    help?.examples?.length ? [
+      "",
+      "Examples:",
+      ...help.examples.flatMap((example) => {
+        const rendered = example.command ? [`  ${example.command}`] : example.input !== void 0 ? [`  ${prettyJson(example.input).replace(/\n/g, "\n  ")}`] : [];
+        return example.title ? [`  # ${example.title}`, ...rendered] : rendered;
+      })
+    ].join("\n") : "",
+    command.inputSchema ? ["", "Input schema:", prettyJson(command.inputSchema)].join("\n") : ""
+  ];
+  return lines.filter(Boolean).join("\n");
+}
+function parseSseEvents(chunk, carry) {
+  const frames = `${carry}${chunk}`.split(/\r?\n\r?\n/u);
+  return {
+    complete: frames.slice(0, -1),
+    carry: frames.at(-1) ?? ""
+  };
+}
+function decodeSseFrame(frame) {
+  let event = "message";
+  const data = [];
+  for (const line of frame.split(/\r?\n/u)) {
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    if (line.startsWith("data:")) data.push(line.slice(5).trimStart());
+  }
+  return { event, data: data.join("\n") };
+}
+async function streamServerAppEvents(input) {
+  const response = await fetch(input.url, { headers: { Accept: "text/event-stream" } });
+  if (!response.ok || !response.body) {
+    throw new Error(`Event stream failed (${response.status})`);
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let carry = "";
+  let count = 0;
+  const stop = () => reader.cancel().catch(() => void 0);
+  process.once("SIGINT", stop);
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      const parsed = parseSseEvents(decoder.decode(next.value, { stream: true }), carry);
+      carry = parsed.carry;
+      for (const frame of parsed.complete) {
+        const decoded = decodeSseFrame(frame);
+        if (!decoded.data || input.event && decoded.event !== input.event) continue;
+        let payload = decoded.data;
+        try {
+          payload = JSON.parse(decoded.data);
+        } catch {
+        }
+        if (input.json) console.log(JSON.stringify({ event: decoded.event, data: payload }));
+        else
+          console.log(
+            `[${decoded.event}] ${typeof payload === "string" ? payload : prettyJson(payload)}`
+          );
+        count += 1;
+        if (input.limit && count >= input.limit) return;
+      }
+    }
+  } finally {
+    process.off("SIGINT", stop);
+  }
+}
 function createAppCommand() {
-  const app = new Command3("app").description("Server App integration commands");
+  const app = new Command2("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 });
+      const apps = await client.listServerApps(resolveServerFlag(options.server));
+      output(
+        apps.map((entry) => ({
+          id: entry.id,
+          name: `${entry.appKey} (${entry.name})`
+        })),
+        { json: options.json }
+      );
     } catch (error) {
       commandHandlerError(error, options.json);
     }
@@ -310,7 +318,7 @@ function createAppCommand() {
         const client = await getClient(options.profile);
         const manifest = options.manifestFile ? await readJsonFile(options.manifestFile) : void 0;
         output(
-          await client.discoverServerApp(resolveServer(options.server), {
+          await client.discoverServerApp(resolveServerFlag(options.server), {
             manifestUrl: options.manifestUrl,
             manifest
           }),
@@ -329,7 +337,7 @@ function createAppCommand() {
         }
         const client = await getClient(options.profile);
         const manifest = options.manifestFile ? await readJsonFile(options.manifestFile) : void 0;
-        const result = await client.installServerApp(resolveServer(options.server), {
+        const result = await client.installServerApp(resolveServerFlag(options.server), {
           manifestUrl: options.manifestUrl,
           manifest
         });
@@ -343,7 +351,7 @@ function createAppCommand() {
     async (appKey, options) => {
       try {
         const client = await getClient(options.profile);
-        output(await client.getServerApp(resolveServer(options.server), appKey), {
+        output(await client.getServerApp(resolveServerFlag(options.server), appKey), {
           json: options.json
         });
       } catch (error) {
@@ -351,16 +359,57 @@ function createAppCommand() {
       }
     }
   );
-  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(
+  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 <buddy-id>", "Buddy 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
-        });
+        const permissions = parsePermissions(options.permissions);
+        const result = await client.grantServerAppToBuddy(
+          resolveServerFlag(options.server),
+          appKey,
+          {
+            buddyAgentId: options.buddy,
+            permissions,
+            approvalMode: options.approvalMode
+          }
+        );
+        output(result, { json: options.json });
+      } catch (error) {
+        commandHandlerError(error, options.json);
+      }
+    }
+  );
+  app.command("defaults").description("Set default app permissions that members and Buddies can use without prompting").argument("<app-key>", "App key").requiredOption("--server <server>", "Server ID or slug").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 result = await client.updateServerAppAccessPolicy(
+          resolveServerFlag(options.server),
+          appKey,
+          {
+            defaultPermissions: parsePermissions(options.permissions),
+            defaultApprovalMode: options.approvalMode
+          }
+        );
+        output(result, { json: options.json });
+      } catch (error) {
+        commandHandlerError(error, options.json);
+      }
+    }
+  );
+  app.command("approve").description("Approve one app command for yourself or a Buddy after a first-use prompt").argument("<app-key>", "App key").argument("<command>", "Command name").requiredOption("--server <server>", "Server ID or slug").option("--buddy <buddy-id>", "Buddy ID to approve for").option("--no-remember", "Approve only the immediate retry window").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (appKey, commandName, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const result = await client.approveServerAppCommand(
+          resolveServerFlag(options.server),
+          appKey,
+          {
+            commandName,
+            buddyAgentId: options.buddy,
+            remember: options.remember
+          }
+        );
         output(result, { json: options.json });
       } catch (error) {
         commandHandlerError(error, options.json);
@@ -370,7 +419,7 @@ function createAppCommand() {
   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 server = resolveServerFlag(options.server);
       const apps = await client.listServerApps(server);
       const docs = await Promise.all(
         apps.map((entry) => client.getServerAppSkills(server, entry.appKey))
@@ -388,7 +437,7 @@ function createAppCommand() {
     async (appKey, options) => {
       try {
         const client = await getClient(options.profile);
-        const result = await client.getServerAppSkills(resolveServer(options.server), appKey);
+        const result = await client.getServerAppSkills(resolveServerFlag(options.server), appKey);
         if (options.json) output(result, { json: true });
         else console.log(result.markdown);
       } catch (error) {
@@ -396,18 +445,81 @@ function createAppCommand() {
       }
     }
   );
-  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(
+  app.command("events").description("Subscribe to an installed server App event stream").argument("<app-key>", "App key").requiredOption("--server <server>", "Server ID or slug").option("--event <event>", "Only print one event type").option("--limit <count>", "Stop after this many matching events").option("--profile <name>", "Profile to use").option("--json", "Output as JSON lines").action(
+    async (appKey, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const launch = await client.createServerAppLaunch(
+          resolveServerFlag(options.server),
+          appKey
+        );
+        const limit = options.limit ? Number.parseInt(options.limit, 10) : void 0;
+        if (limit !== void 0 && (!Number.isFinite(limit) || limit < 1)) {
+          throw new Error("--limit must be a positive integer");
+        }
+        await streamServerAppEvents({
+          url: client.serverAppEventStreamUrl(launch.eventStreamPath),
+          event: options.event,
+          limit,
+          json: options.json
+        });
+      } catch (error) {
+        commandHandlerError(error, options.json);
+      }
+    }
+  );
+  app.command("call").description("Call a server App command").helpOption(false).argument("[app-key]", "App key").argument("[command]", "Command name").option("--server <server>", "Server ID or slug").option("--json-input <json>", "JSON command input").option("--input-file <path>", "Read JSON command input from file").option("--channel-id <id>", "Current Shadow channel ID for approval prompts and app context").option("--task-message-id <id>", "Inbox task message ID to bind this app command to").option("--task-card-id <id>", "Inbox task card ID to bind this app command to").option("--task-claim-id <id>", "Inbox task claim ID to bind this app command to").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").option("-h, --help", "Show app or command help from the installed manifest").action(
     async (appKey, commandName, options) => {
       try {
+        if (options.help) {
+          if (!appKey) {
+            console.log(
+              [
+                "Usage:",
+                "  shadowob app call <app-key> <command> --server <server> --json-input '<input-json>' --json",
+                "  shadowob app call <app-key> <command> --server <server> --help"
+              ].join("\n")
+            );
+            return;
+          }
+          const client2 = await getClient(options.profile);
+          const server2 = resolveServerFlag(options.server);
+          const app2 = await client2.getServerApp(server2, appKey);
+          console.log(
+            formatAppCommandHelp({
+              appKey,
+              serverId: app2.serverId,
+              manifest: app2.manifest,
+              commandName
+            })
+          );
+          return;
+        }
+        if (!appKey) throw new Error("Missing app key");
+        if (!commandName) throw new Error("Missing command name");
         const client = await getClient(options.profile);
         const input = options.inputFile ? await readJsonFile(options.inputFile) : parseJsonInput(options.jsonInput);
-        const server = resolveServer(options.server);
+        const server = resolveServerFlag(options.server);
+        if ((options.taskMessageId || options.taskCardId || options.taskClaimId) && !(options.taskMessageId && options.taskCardId)) {
+          throw new Error("--task-message-id and --task-card-id are required together");
+        }
+        const task = options.taskMessageId && options.taskCardId ? {
+          messageId: options.taskMessageId,
+          cardId: options.taskCardId,
+          ...options.taskClaimId ? { claimId: options.taskClaimId } : {}
+        } : void 0;
         const result = options.file ? await client.callServerAppCommandMultipart(server, appKey, commandName, {
           input,
+          channelId: options.channelId,
+          task,
           file: new Blob([await readFile(options.file)]),
           filename: basename(options.file),
           field: options.field
-        }) : await client.callServerAppCommand(server, appKey, commandName, { input });
+        }) : await client.callServerAppCommand(server, appKey, commandName, {
+          input,
+          channelId: options.channelId,
+          task
+        });
         if (options.output && result && typeof result === "object" && "dataBase64" in result && typeof result.dataBase64 === "string") {
           await writeFile(
             options.output,
@@ -422,15 +534,28 @@ function createAppCommand() {
       }
     }
   );
+  app.command("uninstall").description("Uninstall a 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);
+        await client.deleteServerApp(resolveServerFlag(options.server), appKey);
+        const outputOpts = { json: options.json };
+        if (options.json) output({ ok: true }, outputOpts);
+        else outputSuccess(`Uninstalled ${appKey}`, outputOpts);
+      } catch (error) {
+        commandHandlerError(error, options.json);
+      }
+    }
+  );
   return app;
 }
 
 // src/commands/auth.ts
 import { ShadowClient } from "@shadowob/sdk";
-import { Command as Command4 } from "commander";
+import { Command as Command3 } from "commander";
 function createAuthCommand() {
-  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(
+  const auth = new Command3("auth").description("Authentication commands");
+  auth.command("login").description("Authenticate with a Shadow server").option("--server-url <url>", "Shadow server URL", "https://shadowob.com").requiredOption("--token <token>", "JWT token").option("--profile <name>", "Profile name", "default").option("--json", "Output as JSON").action(
     async (options) => {
       try {
         const client = new ShadowClient(options.serverUrl, options.token);
@@ -541,14 +666,135 @@ function createAuthCommand() {
   return auth;
 }
 
+// src/commands/buddies.ts
+import { Command as Command4 } from "commander";
+function createBuddiesCommand() {
+  const buddies = new Command4("buddies").description("Buddy management commands");
+  buddies.command("list").description("List your buddies").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = await getClient(options.profile);
+      const agents = await client.listAgents();
+      output(agents, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  buddies.command("get").description("Get buddy details").argument("<buddy-id>", "Buddy ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (buddyId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const agent = await client.getAgent(buddyId);
+      output(agent, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  buddies.command("create").description("Create a new buddy").requiredOption("--name <name>", "Buddy name").requiredOption("--username <username>", "Buddy username").option("--display-name <name>", "Display name").option("--avatar-url <url>", "Avatar URL").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const agent = await client.createAgent({
+          name: options.name,
+          username: options.username,
+          displayName: options.displayName,
+          avatarUrl: options.avatarUrl
+        });
+        output(agent, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  buddies.command("update").description("Update a buddy").argument("<buddy-id>", "Buddy ID").option("--name <name>", "New name").option("--display-name <name>", "New display name").option("--avatar-url <url>", "New avatar URL").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (buddyId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const agent = await client.updateAgent(buddyId, {
+          name: options.name,
+          displayName: options.displayName,
+          avatarUrl: options.avatarUrl
+        });
+        output(agent, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  buddies.command("delete").description("Delete a buddy").argument("<buddy-id>", "Buddy ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (buddyId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.deleteAgent(buddyId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Buddy deleted", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  buddies.command("start").description("Start a buddy").argument("<buddy-id>", "Buddy ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (buddyId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.startAgent(buddyId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Buddy started", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  buddies.command("stop").description("Stop a buddy").argument("<buddy-id>", "Buddy ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (buddyId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.stopAgent(buddyId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Buddy stopped", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  buddies.command("token").description("Generate a new token for a buddy").argument("<buddy-id>", "Buddy ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (buddyId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const result = await client.generateAgentToken(buddyId);
+      if (options.json) {
+        output(result, { json: true });
+      } else {
+        console.log(result.token);
+      }
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  buddies.command("config").description("Get buddy remote config").argument("<buddy-id>", "Buddy ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (buddyId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const config = await client.getAgentConfig(buddyId);
+      output(config, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return buddies;
+}
+
 // src/commands/channels.ts
 import { Command as Command5 } from "commander";
 function createChannelsCommand() {
   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) => {
+  channels.command("list").description("List channels 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);
-      const channels2 = await client.getServerChannels(options.serverId);
+      const channels2 = await client.getServerChannels(resolveServerFlag(options.server));
       output(channels2, { json: options.json });
     } catch (error) {
       outputError(error instanceof Error ? error.message : String(error), { json: options.json });
@@ -565,11 +811,11 @@ function createChannelsCommand() {
       process.exit(1);
     }
   });
-  channels.command("create").description("Create a channel").requiredOption("--server-id <id>", "Server ID").requiredOption("--name <name>", "Channel name").option("--type <type>", "Channel type", "text").option("--description <desc>", "Channel description").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+  channels.command("create").description("Create a channel").requiredOption("--server <server>", "Server ID or slug").requiredOption("--name <name>", "Channel name").option("--type <type>", "Channel type", "text").option("--description <desc>", "Channel description").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
     async (options) => {
       try {
         const client = await getClient(options.profile);
-        const channel = await client.createChannel(options.serverId, {
+        const channel = await client.createChannel(resolveServerFlag(options.server), {
           name: options.name,
           type: options.type,
           description: options.description
@@ -840,10 +1086,10 @@ function createCommerceCommand() {
     })
   );
   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(
+  entitlements.command("list").description("List my purchase entitlements").option("--server <server>", "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();
+      return options.server ? client.getEntitlements(resolveServerFlag(options.server)) : 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(
@@ -1242,10 +1488,213 @@ function createFriendsCommand() {
   return friends;
 }
 
-// src/commands/invites.ts
+// src/commands/inbox.ts
 import { Command as Command12 } from "commander";
+var TASK_STATUSES = /* @__PURE__ */ new Set([
+  "queued",
+  "claimed",
+  "running",
+  "completed",
+  "failed",
+  "canceled",
+  "transferred"
+]);
+function parseTaskStatus(value) {
+  if (!TASK_STATUSES.has(value)) {
+    throw new Error(`Invalid task status: ${value}`);
+  }
+  return value;
+}
+function parseJsonOption(value, label) {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`Invalid JSON for ${label}`);
+  }
+}
+function parseTaskSourceOption(value) {
+  const source = parseJsonOption(value, "source-json");
+  if (!source) return void 0;
+  if (typeof source.kind !== "string" || !source.kind.trim()) {
+    throw new Error("Invalid source-json: kind is required");
+  }
+  return source;
+}
+function createInboxCommand() {
+  const inbox = new Command12("inbox").description("Buddy Inbox task-card commands");
+  inbox.command("list").description("List Buddy Inbox entries").option("--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 result = options.server ? await client.listServerBuddyInboxes(resolveServerFlag(options.server)) : await client.listBuddyInboxes();
+      output(result, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), {
+        json: options.json
+      });
+      process.exit(1);
+    }
+  });
+  inbox.command("ensure").description("Create or repair a Buddy Inbox channel").requiredOption("--server <server>", "Server ID or slug").requiredOption("--agent <agent-id>", "Buddy agent ID").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.ensureBuddyInbox(
+          resolveServerFlag(options.server),
+          options.agent
+        );
+        output(result, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  inbox.command("enqueue").description("Enqueue a new task card into a Buddy Inbox").requiredOption("--title <title>", "Task title").option("--body <text>", "Task body").option("--priority <priority>", "low|normal|high|urgent").option("--idempotency-key <key>", "Idempotency key").option("--server <server>", "Server ID or slug; required with --agent").option("--agent <agent-id>", "Buddy agent ID").option("--channel <channel-id>", "Buddy Inbox channel ID").option("--source-json <json>", "Task source JSON").option("--data-json <json>", "Task data JSON").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const task = {
+          title: options.title
+        };
+        if (options.body) task.body = options.body;
+        if (options.priority) task.priority = options.priority;
+        if (options.idempotencyKey) task.idempotencyKey = options.idempotencyKey;
+        const source = parseTaskSourceOption(options.sourceJson);
+        if (source) task.source = source;
+        const data = parseJsonOption(options.dataJson, "data-json");
+        if (data) task.data = data;
+        const result = options.channel ? await client.enqueueInboxTask(options.channel, task) : options.server && options.agent ? await client.enqueueInboxTaskForAgent(
+          resolveServerFlag(options.server),
+          options.agent,
+          task
+        ) : null;
+        if (!result) throw new Error("Provide either --channel or both --server and --agent");
+        output(result, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  inbox.command("policy").description("Read or update a Buddy Inbox admission policy").requiredOption("--server <server>", "Server ID or slug").requiredOption("--agent <agent-id>", "Buddy agent ID").option("--set-json <json>", "Admission policy JSON to write").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const server = resolveServerFlag(options.server);
+        const policy = options.setJson ? parseJsonOption(options.setJson, "set-json") : null;
+        const result = options.setJson ? await client.updateBuddyInboxAdmissionPolicy(server, options.agent, policy) : await client.getBuddyInboxAdmissionPolicy(server, options.agent);
+        output(result, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  inbox.command("claim").description("Claim an Inbox task card by message/card id").argument("<message-id>", "Message ID containing the task card").argument("<card-id>", "Task card ID").option("--ttl-seconds <n>", "Claim TTL in seconds", "3600").option("--note <text>", "Progress note").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (messageId, cardId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const message = await client.claimTaskCard(messageId, cardId, {
+          ttlSeconds: parsePositiveInt(options.ttlSeconds ?? "3600", "ttl-seconds"),
+          note: options.note
+        });
+        output(message, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  inbox.command("update").description("Update an Inbox task card status").argument("<message-id>", "Message ID containing the task card").argument("<card-id>", "Task card ID").requiredOption(
+    "--status <status>",
+    "queued|claimed|running|completed|failed|canceled|transferred"
+  ).option("--note <text>", "Progress note").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (messageId, cardId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const message = await client.updateTaskCard(messageId, cardId, {
+          status: parseTaskStatus(options.status),
+          note: options.note
+        });
+        output(message, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  inbox.command("retry").description("Copy a failed task card into a new queued task and mark the original transferred").argument("<message-id>", "Message ID containing the task card").argument("<card-id>", "Task card ID").option("--note <text>", "Transfer note").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (messageId, cardId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const result = await client.retryTaskCard(messageId, cardId, { note: options.note });
+        output(result, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  inbox.command("claim-next").description("Claim the next available task in a Buddy Inbox").requiredOption("--server <server>", "Server ID or slug").requiredOption("--agent <agent-id>", "Buddy agent ID").option("--ttl-seconds <n>", "Claim TTL in seconds", "3600").option("--note <text>", "Progress note").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.claimNextInboxTask(
+          resolveServerFlag(options.server),
+          options.agent,
+          {
+            ttlSeconds: parsePositiveInt(options.ttlSeconds ?? "3600", "ttl-seconds"),
+            note: options.note
+          }
+        );
+        output(result, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  inbox.command("promote").description("Promote a chat message into a Buddy Inbox task").argument("<message-id>", "Source message ID").requiredOption("--server <server>", "Server ID or slug").requiredOption("--agent <agent-id>", "Buddy agent ID").option("--title <title>", "Task title override").option("--priority <priority>", "low|normal|high|urgent").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (messageId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const message = await client.promoteMessageToInboxTask(messageId, {
+          serverId: resolveServerFlag(options.server),
+          agentId: options.agent,
+          title: options.title,
+          priority: options.priority
+        });
+        output(message, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  return inbox;
+}
+
+// src/commands/invites.ts
+import { Command as Command13 } from "commander";
 function createInvitesCommand() {
-  const invites = new Command12("invites").description("Invite code management commands");
+  const invites = new Command13("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);
@@ -1296,15 +1745,15 @@ function createInvitesCommand() {
 }
 
 // src/commands/listen.ts
-import { Command as Command13 } from "commander";
+import { Command as Command14 } from "commander";
 function createListenCommand() {
-  const listen = new Command13("listen").description("Listen to real-time events");
+  const listen = new Command14("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-ZIUDIQPZ.js");
+          const { getClient: getClient2 } = await import("./client-VR35GYUZ.js");
           const client = await getClient2(options.profile);
           const limit = parseInt(options.last ?? "50", 10);
           const result = await client.getMessages(channelId, limit);
@@ -1418,9 +1867,9 @@ function createListenCommand() {
 }
 
 // src/commands/marketplace.ts
-import { Command as Command14 } from "commander";
+import { Command as Command15 } from "commander";
 function createMarketplaceCommand() {
-  const marketplace = new Command14("marketplace").description("Marketplace commands");
+  const marketplace = new Command15("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) => {
@@ -1565,9 +2014,9 @@ function createMarketplaceCommand() {
 
 // src/commands/media.ts
 import { readFileSync } from "fs";
-import { Command as Command15 } from "commander";
+import { Command as Command16 } from "commander";
 function createMediaCommand() {
-  const media = new Command15("media").description("Media management commands");
+  const media = new Command16("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 {
@@ -1633,9 +2082,9 @@ function createMediaCommand() {
 }
 
 // src/commands/notifications.ts
-import { Command as Command16 } from "commander";
+import { Command as Command17 } from "commander";
 function createNotificationsCommand() {
-  const notifications = new Command16("notifications").description("Notification commands");
+  const notifications = new Command17("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 {
@@ -1714,7 +2163,7 @@ function splitIds(value) {
 }
 
 // src/commands/oauth.ts
-import { Command as Command17 } from "commander";
+import { Command as Command18 } from "commander";
 function resolveOAuthAccessToken(options) {
   const token = options.accessToken || process.env.SHADOWOB_OAUTH_TOKEN;
   if (!token) {
@@ -1731,7 +2180,7 @@ function parseMetadata2(value) {
   return parsed;
 }
 function createOAuthCommand() {
-  const oauth = new Command17("oauth").description("OAuth management commands");
+  const oauth = new Command18("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);
@@ -1864,9 +2313,9 @@ function createOAuthCommand() {
 }
 
 // src/commands/ping.ts
-import { Command as Command18 } from "commander";
+import { Command as Command19 } from "commander";
 function createPingCommand() {
-  const ping = new Command18("ping").description("Test connection to Shadow server");
+  const ping = new Command19("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 };
@@ -1915,9 +2364,9 @@ function createPingCommand() {
 }
 
 // src/commands/profile-comments.ts
-import { Command as Command19 } from "commander";
+import { Command as Command20 } from "commander";
 function createProfileCommentsCommand() {
-  const comments = new Command19("profile-comments").description(
+  const comments = new Command20("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) => {
@@ -1967,17 +2416,17 @@ function createProfileCommentsCommand() {
 }
 
 // src/commands/search.ts
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 function createSearchCommand() {
-  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(
+  const search = new Command21("search").description("Search commands");
+  search.command("messages").description("Search messages").requiredOption("--query <text>", "Search query").option("--server <server>", "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 {
         const client = await getClient(options.profile);
         const limit = Math.min(Math.max(parseInt(options.limit ?? "20", 10), 1), 100);
         const results = await client.searchMessages({
           q: options.query,
-          serverId: options.serverId,
+          serverId: options.server ? resolveServerFlag(options.server) : void 0,
           channelId: options.channelId,
           limit
         });
@@ -1994,14 +2443,17 @@ function createSearchCommand() {
 }
 
 // src/commands/servers.ts
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 function createServersCommand() {
-  const servers = new Command21("servers").description("Server management commands");
+  const servers = new Command22("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);
       const servers2 = await client.listServers();
-      output(servers2, { json: options.json });
+      output(
+        servers2.map((s) => s.server),
+        { json: options.json }
+      );
     } catch (error) {
       outputError(error instanceof Error ? error.message : String(error), { json: options.json });
       process.exit(1);
@@ -2070,7 +2522,17 @@ function createServersCommand() {
     try {
       const client = await getClient(options.profile);
       const members = await client.getMembers(serverId);
-      output(members, { json: options.json });
+      output(
+        members.map(
+          (m) => ({
+            id: m.id,
+            userId: m.userId,
+            username: m.user?.username ?? m.nickname ?? m.uid ?? "",
+            role: m.role
+          })
+        ),
+        { json: options.json }
+      );
     } catch (error) {
       outputError(error instanceof Error ? error.message : String(error), { json: options.json });
       process.exit(1);
@@ -2090,7 +2552,7 @@ function createServersCommand() {
 }
 
 // src/commands/shop.ts
-import { Command as Command22 } from "commander";
+import { Command as Command23 } from "commander";
 function parseJsonObject(value, optionName) {
   if (!value) return {};
   const parsed = JSON.parse(value);
@@ -2108,7 +2570,7 @@ function parseOptionalNumber(value, optionName) {
   return parsed;
 }
 function createShopCommand() {
-  const shop = new Command22("shop").description("Shop commands");
+  const shop = new Command23("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);
@@ -2208,17 +2670,6 @@ 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);
@@ -2461,9 +2912,9 @@ function createShopCommand() {
 }
 
 // src/commands/status.ts
-import { Command as Command23 } from "commander";
+import { Command as Command24 } from "commander";
 function createStatusCommand() {
-  const status = new Command23("status").description("Show detailed status information");
+  const status = new Command24("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 {
@@ -2541,9 +2992,9 @@ function createStatusCommand() {
 }
 
 // src/commands/threads.ts
-import { Command as Command24 } from "commander";
+import { Command as Command25 } from "commander";
 function createThreadsCommand() {
-  const threads = new Command24("threads").description("Thread commands");
+  const threads = new Command25("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);
@@ -2626,7 +3077,7 @@ function createThreadsCommand() {
 
 // src/commands/voice.ts
 import { join as join2 } from "path";
-import { Command as Command25 } from "commander";
+import { Command as Command26 } from "commander";
 
 // src/utils/voice-media-bridge.ts
 import { execFileSync as execFileSync2, spawn } from "child_process";
@@ -3761,7 +4212,7 @@ function resolveProfileOption(options, command) {
   return options.profile ?? command.optsWithGlobals().profile;
 }
 function createVoiceCommand() {
-  const voice = new Command25("voice").description("Voice channel commands");
+  const voice = new Command26("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 {
@@ -3901,7 +4352,7 @@ function createVoiceCommand() {
       }
     }
   );
-  const browser = new Command25("browser").description("Voice bridge browser runtime commands");
+  const browser = new Command26("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 });
@@ -3932,9 +4383,9 @@ function createVoiceCommand() {
 }
 
 // src/commands/voice-enhance.ts
-import { Command as Command26 } from "commander";
+import { Command as Command27 } from "commander";
 function createVoiceEnhanceCommand() {
-  const voice = new Command26("voice-enhance").description("Voice enhancement commands");
+  const voice = new Command27("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);
@@ -3974,9 +4425,9 @@ function createVoiceEnhanceCommand() {
 
 // src/commands/workspace.ts
 import { readFile as readFile3 } from "fs/promises";
-import { Command as Command27 } from "commander";
+import { Command as Command28 } from "commander";
 function createWorkspaceCommand() {
-  const workspace = new Command27("workspace").description("Workspace file management commands");
+  const workspace = new Command28("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);
@@ -4158,7 +4609,7 @@ function createWorkspaceCommand() {
 }
 
 // src/index.ts
-var program = new Command28();
+var program = new Command29();
 program.name("shadowob").description("Shadow CLI \u2014 command-line interface for Shadow servers").version("0.1.0").configureHelp({
   sortSubcommands: true
 });
@@ -4168,7 +4619,8 @@ program.addCommand(createAppCommand());
 program.addCommand(createServersCommand());
 program.addCommand(createChannelsCommand());
 program.addCommand(createThreadsCommand());
-program.addCommand(createAgentsCommand());
+program.addCommand(createBuddiesCommand());
+program.addCommand(createInboxCommand());
 program.addCommand(createListenCommand());
 program.addCommand(createDirectMessagesCommand());
 program.addCommand(createWorkspaceCommand());