@shadowob/cli 0.4.0 → 0.4.1

package/dist/index.js

@@ -0,0 +1,2074 @@
+#!/usr/bin/env node
+import {
+  configManager,
+  getClient,
+  getSocket
+} from "./chunk-T3BKMB7N.js";
+
+// src/index.ts
+import { Command as Command21 } from "commander";
+
+// src/commands/agents.ts
+import { Command } from "commander";
+
+// src/utils/output.ts
+import chalk from "chalk";
+function output(data, options) {
+  if (options.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (data === null || data === void 0) {
+    return;
+  }
+  if (typeof data === "string") {
+    console.log(data);
+    return;
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      console.log(chalk.gray("No results"));
+      return;
+    }
+    formatArray(data);
+    return;
+  }
+  if (typeof data === "object") {
+    formatObject(data);
+    return;
+  }
+  console.log(String(data));
+}
+function outputError(message, options) {
+  if (options.json) {
+    console.log(JSON.stringify({ error: message }, null, 2));
+    return;
+  }
+  console.error(chalk.red(`Error: ${message}`));
+}
+function outputSuccess(message, options) {
+  if (options.json) {
+    console.log(JSON.stringify({ success: true, message }, null, 2));
+    return;
+  }
+  console.log(chalk.green(message));
+}
+function formatArray(items) {
+  if (items.length === 0) return;
+  const first = items[0];
+  if (typeof first !== "object" || first === null) {
+    items.forEach((item) => {
+      console.log(String(item));
+    });
+    return;
+  }
+  const keys = Object.keys(first);
+  const idKey = keys.find((k) => k === "id") || keys[0];
+  const nameKey = keys.find((k) => k === "name" || k === "username" || k === "slug") || keys[1] || idKey;
+  for (const item of items) {
+    const obj = item;
+    const id = String(obj[idKey] ?? "");
+    const name = String(obj[nameKey] ?? "");
+    if (name && name !== id) {
+      console.log(`${chalk.cyan(id)}  ${name}`);
+    } else {
+      console.log(chalk.cyan(id));
+    }
+  }
+}
+function formatObject(obj) {
+  const entries = Object.entries(obj);
+  const maxKeyLength = Math.max(...entries.map(([k]) => k.length));
+  for (const [key, value] of entries) {
+    const formattedKey = key.padEnd(maxKeyLength);
+    let formattedValue;
+    if (value === null || value === void 0) {
+      formattedValue = chalk.gray("null");
+    } else if (typeof value === "boolean") {
+      formattedValue = value ? chalk.green("true") : chalk.red("false");
+    } else if (typeof value === "object") {
+      formattedValue = JSON.stringify(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").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,
+          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;
+}
+
+// src/commands/apps.ts
+import { Command as Command2 } from "commander";
+function createAppsCommand() {
+  const apps = new Command2("apps").description("App management commands");
+  apps.command("list").description("List apps in a server").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);
+      const appsData = await client.listApps(serverId);
+      output(appsData, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  apps.command("get").description("Get app details").argument("<server-id>", "Server ID or slug").argument("<app-id>", "App ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, appId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const app = await client.getApp(serverId, appId);
+        output(app, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  apps.command("create").description("Create an app").argument("<server-id>", "Server ID or slug").requiredOption("--name <name>", "App name").requiredOption("--type <type>", "App type (url, workspace, static)").option("--url <url>", "Source URL for URL apps").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const app = await client.createApp(serverId, {
+          name: options.name,
+          slug: options.name.toLowerCase().replace(/\s+/g, "-"),
+          type: options.type,
+          url: options.url
+        });
+        output(app, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  apps.command("update").description("Update an app").argument("<server-id>", "Server ID or slug").argument("<app-id>", "App ID").option("--name <name>", "New name").option("--url <url>", "New source URL").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, appId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const app = await client.updateApp(serverId, appId, {
+          name: options.name,
+          url: options.url
+        });
+        output(app, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  apps.command("delete").description("Delete an app").argument("<server-id>", "Server ID or slug").argument("<app-id>", "App ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, appId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        await client.deleteApp(serverId, appId);
+        const outputOpts = { json: options.json };
+        outputSuccess("App deleted", outputOpts);
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  apps.command("publish").description("Publish app from workspace").argument("<server-id>", "Server ID or slug").requiredOption("--name <name>", "App name").requiredOption("--slug <slug>", "App slug").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const app = await client.publishApp(serverId, {
+          name: options.name,
+          slug: options.slug
+        });
+        output(app, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  return apps;
+}
+
+// src/commands/auth.ts
+import { Command as Command3 } from "commander";
+import { ShadowClient } from "@shadowob/sdk";
+function createAuthCommand() {
+  const auth = new Command3("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 {
+      const client = new ShadowClient(options.serverUrl, options.token);
+      const user = await client.getMe();
+      await configManager.setProfile(options.profile, {
+        serverUrl: options.serverUrl,
+        token: options.token
+      });
+      await configManager.switchProfile(options.profile);
+      const outputOpts = { json: options.json };
+      if (options.json) {
+        output({ success: true, profile: options.profile, user }, outputOpts);
+      } else {
+        outputSuccess(`Logged in as ${user.username} (${options.profile})`, outputOpts);
+      }
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  auth.command("logout").description("Remove a profile").option("--profile <name>", "Profile name (default: current)").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const profileName = options.profile ?? await configManager.getCurrentProfileName();
+      if (!profileName) {
+        outputError("No profile specified and no current profile", { json: options.json });
+        process.exit(1);
+      }
+      const deleted = await configManager.deleteProfile(profileName);
+      if (!deleted) {
+        outputError(`Profile "${profileName}" not found`, { json: options.json });
+        process.exit(1);
+      }
+      const outputOpts = { json: options.json };
+      outputSuccess(`Logged out (${profileName})`, outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  auth.command("whoami").description("Show current user and profile").option("--profile <name>", "Profile name (default: current)").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const profileName = options.profile ?? await configManager.getCurrentProfileName();
+      const profile = await configManager.getProfile(options.profile);
+      if (!profile) {
+        outputError(
+          profileName ? `Profile "${profileName}" not found` : "Not authenticated. Run: shadowob auth login",
+          { json: options.json }
+        );
+        process.exit(1);
+      }
+      const client = new ShadowClient(profile.serverUrl, profile.token);
+      const user = await client.getMe();
+      const outputOpts = { json: options.json };
+      if (options.json) {
+        output({ profile: profileName, user, serverUrl: profile.serverUrl }, outputOpts);
+      } else {
+        console.log(`Profile: ${profileName}`);
+        console.log(`Server:  ${profile.serverUrl}`);
+        console.log(`User:    ${user.username}`);
+        if (user.displayName && user.displayName !== user.username) {
+          console.log(`Name:    ${user.displayName}`);
+        }
+      }
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  auth.command("switch").description("Switch to a different profile").argument("<profile>", "Profile name").option("--json", "Output as JSON").action(async (profileName, options) => {
+    try {
+      const switched = await configManager.switchProfile(profileName);
+      if (!switched) {
+        outputError(`Profile "${profileName}" not found`, { json: options.json });
+        process.exit(1);
+      }
+      const outputOpts = { json: options.json };
+      outputSuccess(`Switched to profile: ${profileName}`, outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  auth.command("list").description("List all profiles").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const profiles = await configManager.listProfiles();
+      const current = await configManager.getCurrentProfileName();
+      const outputOpts = { json: options.json };
+      if (options.json) {
+        output({ profiles, current }, outputOpts);
+      } else {
+        if (profiles.length === 0) {
+          console.log("No profiles. Run: shadowob auth login");
+          return;
+        }
+        for (const name of profiles) {
+          const marker = name === current ? "* " : "  ";
+          console.log(`${marker}${name}`);
+        }
+      }
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return auth;
+}
+
+// src/commands/channels.ts
+import { Command as Command4 } from "commander";
+function createChannelsCommand() {
+  const channels = new Command4("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);
+      const channels2 = await client.getServerChannels(options.serverId);
+      output(channels2, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  channels.command("get").description("Get channel details").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);
+      const channel = await client.getChannel(channelId);
+      output(channel, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      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(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const channel = await client.createChannel(options.serverId, {
+          name: options.name,
+          type: options.type,
+          description: options.description
+        });
+        output(channel, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  channels.command("delete").description("Delete 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);
+      await client.deleteChannel(channelId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Channel deleted", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  channels.command("messages").description("List messages in a channel").argument("<channel-id>", "Channel ID").option("--limit <n>", "Number of messages", "50").option("--cursor <cursor>", "Pagination cursor").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (channelId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const result = await client.getMessages(
+          channelId,
+          parseInt(options.limit ?? "50", 10),
+          options.cursor
+        );
+        output(result.messages, { json: options.json });
+        if (!options.json && result.hasMore) {
+          console.log("(has more messages)");
+        }
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  channels.command("send").description("Send a message to a channel").argument("<channel-id>", "Channel ID").requiredOption("--content <text>", "Message content").option("--reply-to <id>", "Reply to message ID").option("--thread-id <id>", "Send to thread").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (channelId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const message = await client.sendMessage(channelId, options.content, {
+          replyToId: options.replyTo,
+          threadId: options.threadId
+        });
+        output(message, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  channels.command("edit").description("Edit a message").argument("<message-id>", "Message ID").requiredOption("--content <text>", "New content").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.editMessage(messageId, options.content);
+        output(message, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  channels.command("delete-message").description("Delete a message").argument("<message-id>", "Message ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (messageId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.deleteMessage(messageId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Message deleted", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  channels.command("react").description("Add a reaction to a message").argument("<message-id>", "Message ID").requiredOption("--emoji <emoji>", "Emoji to react with").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (messageId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        await client.addReaction(messageId, options.emoji);
+        const outputOpts = { json: options.json };
+        outputSuccess("Reaction added", outputOpts);
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  channels.command("unreact").description("Remove a reaction from a message").argument("<message-id>", "Message ID").requiredOption("--emoji <emoji>", "Emoji to remove").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (messageId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        await client.removeReaction(messageId, options.emoji);
+        const outputOpts = { json: options.json };
+        outputSuccess("Reaction removed", outputOpts);
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  channels.command("pin").description("Pin a message").argument("<message-id>", "Message ID").option("--channel-id <id>", "Channel ID (if not in channel context)").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (messageId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        await client.pinMessage(messageId, options.channelId);
+        const outputOpts = { json: options.json };
+        outputSuccess("Message pinned", outputOpts);
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  channels.command("unpin").description("Unpin a message").argument("<message-id>", "Message ID").option("--channel-id <id>", "Channel ID (if not in channel context)").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (messageId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        await client.unpinMessage(messageId, options.channelId);
+        const outputOpts = { json: options.json };
+        outputSuccess("Message unpinned", outputOpts);
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  channels.command("pinned").description("List pinned messages 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);
+      const messages = await client.getPinnedMessages(channelId);
+      output(messages, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return channels;
+}
+
+// src/commands/config.ts
+import { Command as Command5 } from "commander";
+function createConfigCommand() {
+  const config = new Command5("config").description("Configuration management commands");
+  config.command("path").description("Show configuration file path").action(() => {
+    console.log(configManager.getConfigPath());
+  });
+  config.command("validate").description("Validate configuration file").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const result = await configManager.validate();
+      const outputOpts = { json: options.json };
+      if (options.json) {
+        output(result, outputOpts);
+        process.exit(result.valid ? 0 : 1);
+        return;
+      }
+      if (result.valid) {
+        outputSuccess("Configuration is valid", outputOpts);
+        if (result.warnings.length > 0) {
+          console.log("\nWarnings:");
+          for (const warning of result.warnings) {
+            console.log(`  - ${warning}`);
+          }
+        }
+        process.exit(0);
+      } else {
+        outputError("Configuration is invalid", outputOpts);
+        if (result.errors.length > 0) {
+          console.log("\nErrors:");
+          for (const error of result.errors) {
+            console.log(`  - ${error}`);
+          }
+        }
+        if (result.warnings.length > 0) {
+          console.log("\nWarnings:");
+          for (const warning of result.warnings) {
+            console.log(`  - ${warning}`);
+          }
+        }
+        process.exit(1);
+      }
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  config.command("fix").description("Fix common configuration issues").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const result = await configManager.fix();
+      const outputOpts = { json: options.json };
+      if (options.json) {
+        output(result, outputOpts);
+        process.exit(0);
+        return;
+      }
+      if (result.fixed) {
+        outputSuccess("Configuration fixed", outputOpts);
+        console.log("\nChanges:");
+        for (const change of result.changes) {
+          console.log(`  - ${change}`);
+        }
+      } else {
+        outputSuccess("No issues found", outputOpts);
+      }
+      process.exit(0);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return config;
+}
+
+// src/commands/dms.ts
+import { Command as Command6 } from "commander";
+function createDmsCommand() {
+  const dms = new Command6("dms").description("Direct message commands");
+  dms.command("list").description("List DM channels").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = await getClient(options.profile);
+      const channels = await client.listDmChannels();
+      output(channels, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  dms.command("get").description("Get DM channel details").argument("<dm-channel-id>", "DM Channel ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (dmChannelId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const channel = await client.getChannel(dmChannelId);
+      output(channel, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  dms.command("create").description("Create a DM channel with a user").requiredOption("--user-id <id>", "User ID to DM with").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.createDmChannel(options.userId);
+      output(channel, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  dms.command("messages").description("List messages in a DM channel").argument("<dm-channel-id>", "DM Channel ID").option("--limit <n>", "Number of messages", "50").option("--cursor <cursor>", "Pagination cursor").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (dmChannelId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const messages = await client.getDmMessages(
+          dmChannelId,
+          parseInt(options.limit ?? "50", 10),
+          options.cursor
+        );
+        output(messages, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  dms.command("send").description("Send a DM message").argument("<dm-channel-id>", "DM Channel ID").requiredOption("--content <text>", "Message content").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (dmChannelId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const message = await client.sendDmMessage(dmChannelId, options.content);
+        output(message, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  dms.command("mark-read").description("Mark DM channel as read").argument("<dm-channel-id>", "DM Channel ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (dmChannelId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.markScopeRead({ channelId: dmChannelId });
+      const outputOpts = { json: options.json };
+      outputSuccess("DM channel marked as read", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return dms;
+}
+
+// src/commands/friends.ts
+import { Command as Command7 } from "commander";
+function createFriendsCommand() {
+  const friends = new Command7("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);
+      const friendsData = await client.listFriends();
+      output(friendsData, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  friends.command("requests").description("List friend requests").option("--incoming", "Show only incoming requests").option("--outgoing", "Show only outgoing requests").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        let requests;
+        if (options.incoming) {
+          requests = await client.listPendingFriendRequests();
+        } else if (options.outgoing) {
+          requests = await client.listSentFriendRequests();
+        } else {
+          const [incoming, outgoing] = await Promise.all([
+            client.listPendingFriendRequests(),
+            client.listSentFriendRequests()
+          ]);
+          requests = [...incoming, ...outgoing];
+        }
+        output(requests, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  friends.command("add").description("Send friend request by username").argument("<username>", "Username to add as friend").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (username, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const result = await client.sendFriendRequest(username);
+      output(result, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), {
+        json: options.json
+      });
+      process.exit(1);
+    }
+  });
+  friends.command("accept").description("Accept friend request").argument("<request-id>", "Friend request ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (requestId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const result = await client.acceptFriendRequest(requestId);
+      output(result, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  friends.command("reject").description("Reject friend request").argument("<request-id>", "Friend request ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (requestId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.rejectFriendRequest(requestId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Friend request rejected", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  friends.command("remove").description("Remove friend").argument("<friendship-id>", "Friendship ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (friendshipId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.removeFriend(friendshipId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Friend removed", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return friends;
+}
+
+// src/commands/invites.ts
+import { Command as Command8 } from "commander";
+function createInvitesCommand() {
+  const invites = new Command8("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);
+      const invitesData = await client.listInvites();
+      output(invitesData, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  invites.command("create").description("Create invite codes").requiredOption("--count <n>", "Number of invites to create", "1").option("--note <text>", "Note for the invites").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const count = Math.min(Math.max(parseInt(options.count ?? "1", 10), 1), 10);
+        const invites2 = await client.createInvites(count, options.note);
+        output(invites2, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  invites.command("deactivate").description("Deactivate invite code").argument("<invite-id>", "Invite ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (inviteId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const invite = await client.deactivateInvite(inviteId);
+      output(invite, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  invites.command("delete").description("Delete invite code").argument("<invite-id>", "Invite ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (inviteId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.deleteInvite(inviteId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Invite deleted", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return invites;
+}
+
+// src/commands/listen.ts
+import { Command as Command9 } from "commander";
+function createListenCommand() {
+  const listen = new Command9("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 client = await getClient2(options.profile);
+          const limit = parseInt(options.last ?? "50", 10);
+          const result = await client.getMessages(channelId, limit);
+          if (options.json) {
+            for (const msg of result.messages) {
+              console.log(JSON.stringify({ type: "message:new", data: msg }));
+            }
+          } else {
+            for (const msg of result.messages) {
+              console.log(
+                `[${msg.createdAt}] ${msg.author?.username ?? "unknown"}: ${msg.content}`
+              );
+            }
+          }
+          return;
+        }
+        const socket = await getSocket(options.profile);
+        const timeoutMs = parseInt(options.timeout ?? "60", 10) * 1e3;
+        const maxCount = options.count ? parseInt(options.count, 10) : void 0;
+        let count = 0;
+        let timeoutId;
+        const cleanup = () => {
+          if (timeoutId) clearTimeout(timeoutId);
+          socket.disconnect();
+        };
+        timeoutId = setTimeout(() => {
+          if (!options.json) {
+            console.error("(timeout reached)");
+          }
+          cleanup();
+          process.exit(0);
+        }, timeoutMs);
+        const shouldOutput = (eventType) => {
+          if (!eventTypes) return true;
+          return eventTypes.includes(eventType);
+        };
+        const outputEvent = (type, data) => {
+          if (!shouldOutput(type)) return;
+          count++;
+          if (options.json) {
+            console.log(JSON.stringify({ type, data, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+          } else {
+            const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+            if (type === "message:new") {
+              const msg = data;
+              console.log(
+                `[${timestamp}] ${msg.author?.username ?? "unknown"}: ${msg.content ?? ""}`
+              );
+            } else {
+              console.log(`[${timestamp}] ${type}:`, JSON.stringify(data));
+            }
+          }
+          if (maxCount && count >= maxCount) {
+            cleanup();
+            process.exit(0);
+          }
+        };
+        socket.on("message:new", ((msg) => {
+          if (msg.channelId === channelId) {
+            outputEvent("message:new", msg);
+          }
+        }));
+        socket.on("message:updated", ((msg) => {
+          if (msg.channelId === channelId) {
+            outputEvent("message:updated", msg);
+          }
+        }));
+        socket.on("message:deleted", ((payload) => {
+          if (payload.channelId === channelId) {
+            outputEvent("message:deleted", payload);
+          }
+        }));
+        socket.on("reaction:add", ((payload) => {
+          outputEvent("reaction:add", payload);
+        }));
+        socket.on("reaction:remove", ((payload) => {
+          outputEvent("reaction:remove", payload);
+        }));
+        socket.on("member:typing", ((payload) => {
+          if (payload.channelId === channelId) {
+            outputEvent("member:typing", payload);
+          }
+        }));
+        socket.on("member:join", ((payload) => {
+          if (payload.channelId === channelId) {
+            outputEvent("member:join", payload);
+          }
+        }));
+        socket.on("member:leave", ((payload) => {
+          if (payload.channelId === channelId) {
+            outputEvent("member:leave", payload);
+          }
+        }));
+        socket.connect();
+        await socket.waitForConnect(5e3);
+        await socket.joinChannel(channelId);
+        if (!options.json) {
+          console.error(`(listening to channel ${channelId}, timeout: ${timeoutMs}ms)`);
+        }
+        await new Promise(() => {
+        });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  listen.command("dm").description("Listen to DM events").argument("<dm-channel-id>", "DM Channel ID").option("--timeout <seconds>", "Timeout in seconds", "60").option("--count <n>", "Stop after N events").option("--profile <name>", "Profile to use").option("--json", "Output as JSON (one per line)").action(
+    async (dmChannelId, options) => {
+      try {
+        const socket = await getSocket(options.profile);
+        const timeoutMs = parseInt(options.timeout ?? "60", 10) * 1e3;
+        const maxCount = options.count ? parseInt(options.count, 10) : void 0;
+        let count = 0;
+        let timeoutId;
+        const cleanup = () => {
+          if (timeoutId) clearTimeout(timeoutId);
+          socket.disconnect();
+        };
+        timeoutId = setTimeout(() => {
+          cleanup();
+          process.exit(0);
+        }, timeoutMs);
+        socket.on("dm:message:new", ((msg) => {
+          if (msg.dmChannelId !== dmChannelId) return;
+          count++;
+          if (options.json) {
+            console.log(JSON.stringify({ type: "dm:message:new", data: msg }));
+          } else {
+            const timestamp = new Date(msg.createdAt ?? Date.now()).toLocaleTimeString();
+            console.log(
+              `[${timestamp}] ${msg.author?.username ?? "unknown"}: ${msg.content ?? ""}`
+            );
+          }
+          if (maxCount && count >= maxCount) {
+            cleanup();
+            process.exit(0);
+          }
+        }));
+        socket.connect();
+        await socket.waitForConnect(5e3);
+        socket.joinDmChannel(dmChannelId);
+        if (!options.json) {
+          console.error(`(listening to DM channel ${dmChannelId}, timeout: ${timeoutMs}ms)`);
+        }
+        await new Promise(() => {
+        });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  return listen;
+}
+
+// src/commands/marketplace.ts
+import { Command as Command10 } from "commander";
+function createMarketplaceCommand() {
+  const marketplace = new Command10("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) => {
+      try {
+        const client = await getClient(options.profile);
+        const params = {};
+        if (options.search) params.search = options.search;
+        if (options.tags) params.tags = options.tags.split(",").map((t) => t.trim());
+        if (options.minPrice) params.minPrice = parseFloat(options.minPrice);
+        if (options.maxPrice) params.maxPrice = parseFloat(options.maxPrice);
+        if (options.limit) params.limit = parseInt(options.limit, 10);
+        if (options.offset) params.offset = parseInt(options.offset, 10);
+        const results = await client.browseListings(params);
+        output(results, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  listings.command("get").description("Get listing details").argument("<listing-id>", "Listing ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (listingId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const listing = await client.getListing(listingId);
+      output(listing, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  listings.command("create").description("Create a listing").requiredOption("--agent-id <id>", "Agent ID").requiredOption("--title <title>", "Listing title").requiredOption("--price <n>", "Price per hour").option("--description <desc>", "Listing description").option("--tags <tags>", "Comma-separated tags").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const listing = await client.createListing({
+          agentId: options.agentId,
+          title: options.title,
+          pricePerHour: parseFloat(options.price),
+          description: options.description ?? "",
+          tags: options.tags?.split(",").map((t) => t.trim())
+        });
+        output(listing, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  listings.command("update").description("Update a listing").argument("<listing-id>", "Listing ID").option("--title <title>", "New title").option("--price <n>", "New price per hour").option("--description <desc>", "New description").option("--tags <tags>", "Comma-separated tags").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (listingId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const data = {};
+        if (options.title) data.title = options.title;
+        if (options.price) data.pricePerHour = parseFloat(options.price);
+        if (options.description) data.description = options.description;
+        if (options.tags) data.tags = options.tags.split(",").map((t) => t.trim());
+        const listing = await client.updateListing(listingId, data);
+        output(listing, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  listings.command("delete").description("Delete a listing").argument("<listing-id>", "Listing ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (listingId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.deleteListing(listingId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Listing deleted", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  const contracts = marketplace.command("contracts").description("Contract commands");
+  contracts.command("list").description("List contracts").option("--as-renter", "Show only contracts where you are the renter").option("--as-owner", "Show only contracts where you are the owner").option("--active-only", "Show only active contracts").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const params = {};
+        if (options.asRenter) params.role = "tenant";
+        else if (options.asOwner) params.role = "owner";
+        if (options.activeOnly) params.status = "active";
+        const results = await client.listContracts(params);
+        output(results, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  contracts.command("get").description("Get contract details").argument("<contract-id>", "Contract ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (contractId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const contract = await client.getContract(contractId);
+      output(contract, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  contracts.command("create").description("Sign a contract for a listing").requiredOption("--listing-id <id>", "Listing ID").requiredOption("--hours <n>", "Number of hours").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const contract = await client.signContract({
+          listingId: options.listingId,
+          hours: parseInt(options.hours, 10)
+        });
+        output(contract, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  contracts.command("cancel").description("Terminate a contract").argument("<contract-id>", "Contract ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (contractId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.terminateContract(contractId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Contract terminated", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return marketplace;
+}
+
+// src/commands/media.ts
+import { readFileSync } from "fs";
+import { Command as Command11 } from "commander";
+function createMediaCommand() {
+  const media = new Command11("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 {
+        const client = await getClient(options.profile);
+        const buffer = readFileSync(options.file);
+        const filename = options.file.split("/").pop() || "file";
+        const ext = filename.split(".").pop()?.toLowerCase();
+        const contentTypeMap = {
+          jpg: "image/jpeg",
+          jpeg: "image/jpeg",
+          png: "image/png",
+          gif: "image/gif",
+          webp: "image/webp",
+          pdf: "application/pdf",
+          txt: "text/plain",
+          json: "application/json"
+        };
+        const contentType = contentTypeMap[ext || ""] || "application/octet-stream";
+        const result = await client.uploadMedia(
+          buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+          filename,
+          contentType,
+          options.messageId
+        );
+        output(result, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  media.command("download").description("Download a file").argument("<file-url>", "File URL or key").option("--output <path>", "Output file path").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (fileUrl, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const result = await client.downloadFile(fileUrl);
+        if (options.output) {
+          const { writeFileSync } = await import("fs");
+          writeFileSync(options.output, Buffer.from(result.buffer));
+          const outputOpts = { json: options.json };
+          outputSuccess(`Downloaded to ${options.output}`, outputOpts);
+        } else {
+          output(
+            {
+              filename: result.filename,
+              contentType: result.contentType,
+              size: result.buffer.byteLength
+            },
+            { json: options.json }
+          );
+        }
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  return media;
+}
+
+// src/commands/notifications.ts
+import { Command as Command12 } from "commander";
+function createNotificationsCommand() {
+  const notifications = new Command12("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 : [];
+        output(notifications2, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  notifications.command("mark-read").description("Mark notification as read").argument("<notification-id>", "Notification ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (notificationId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.markNotificationRead(notificationId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Notification marked as read", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  notifications.command("mark-all-read").description("Mark all notifications as read").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.markAllNotificationsRead();
+      const outputOpts = { json: options.json };
+      outputSuccess("All notifications marked as read", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return notifications;
+}
+
+// src/commands/oauth.ts
+import { Command as Command13 } from "commander";
+function createOAuthCommand() {
+  const oauth = new Command13("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);
+      output([], { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  oauth.command("create").description("Create OAuth app").requiredOption("--name <name>", "App name").requiredOption("--redirect-uris <uris>", "Comma-separated redirect URIs").option("--scopes <scopes>", "Comma-separated scopes").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const app = await client.createOAuthApp({
+          name: options.name,
+          redirectUris: options.redirectUris.split(",").map((u) => u.trim()),
+          scopes: options.scopes?.split(",").map((s) => s.trim())
+        });
+        output(app, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  oauth.command("update").description("Update OAuth app").argument("<app-id>", "App ID").option("--name <name>", "New name").option("--redirect-uris <uris>", "Comma-separated redirect URIs").option("--scopes <scopes>", "Comma-separated scopes").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (appId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const data = {};
+        if (options.name) data.name = options.name;
+        if (options.redirectUris)
+          data.redirectUris = options.redirectUris.split(",").map((u) => u.trim());
+        if (options.scopes) data.scopes = options.scopes.split(",").map((s) => s.trim());
+        const app = await client.updateOAuthApp(appId, data);
+        output(app, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  oauth.command("delete").description("Delete OAuth app").argument("<app-id>", "App ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (appId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.deleteOAuthApp(appId);
+      const outputOpts = { json: options.json };
+      outputSuccess("OAuth app deleted", outputOpts);
+    } 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 Command14 } from "commander";
+function createPingCommand() {
+  const ping = new Command14("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 };
+    try {
+      const client = await getClient(options.profile);
+      const user = await client.getMe();
+      const latency = Date.now() - startTime;
+      const result = {
+        success: true,
+        latency: `${latency}ms`,
+        user: {
+          id: user.id,
+          username: user.username,
+          displayName: user.displayName
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (options.json) {
+        output(result, outputOpts);
+      } else {
+        outputSuccess(`Connected to Shadow server (${latency}ms)`, outputOpts);
+        console.log(`User: ${user.username} (${user.id})`);
+      }
+      process.exit(0);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const result = {
+        success: false,
+        error: errorMessage,
+        latency: `${Date.now() - startTime}ms`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (options.json) {
+        output(result, outputOpts);
+      } else {
+        outputError(`Failed to connect: ${errorMessage}`, outputOpts);
+        console.log("\nTroubleshooting:");
+        console.log("  - Check your server URL");
+        console.log("  - Verify your token is valid");
+        console.log("  - Run: shadowob config validate");
+      }
+      process.exit(1);
+    }
+  });
+  return ping;
+}
+
+// src/commands/search.ts
+import { Command as Command15 } from "commander";
+function createSearchCommand() {
+  const search = new Command15("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 {
+        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,
+          channelId: options.channelId,
+          limit
+        });
+        output(results, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  return search;
+}
+
+// src/commands/servers.ts
+import { Command as Command16 } from "commander";
+function createServersCommand() {
+  const servers = new Command16("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 });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  servers.command("get").description("Get server details").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);
+      const server = await client.getServer(serverId);
+      output(server, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  servers.command("create").description("Create a new server").requiredOption("--name <name>", "Server name").option("--slug <slug>", "Server slug").option("--description <desc>", "Server description").option("--public", "Make server public").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (options) => {
+      try {
+        const client = await getClient(options.profile);
+        const server = await client.createServer({
+          name: options.name,
+          slug: options.slug,
+          description: options.description,
+          isPublic: options.public
+        });
+        output(server, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+        process.exit(1);
+      }
+    }
+  );
+  servers.command("join").description("Join a server").argument("<server-id>", "Server ID or slug").option("--invite-code <code>", "Invite code (if required)").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const result = await client.joinServer(serverId, options.inviteCode);
+        const outputOpts = { json: options.json };
+        if (options.json) {
+          output(result, outputOpts);
+        } else {
+          outputSuccess("Joined server", outputOpts);
+        }
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+        process.exit(1);
+      }
+    }
+  );
+  servers.command("leave").description("Leave a server").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);
+      await client.leaveServer(serverId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Left server", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  servers.command("members").description("List server members").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);
+      const members = await client.getMembers(serverId);
+      output(members, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      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);
+      const servers2 = await client.discoverServers();
+      output(servers2, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return servers;
+}
+
+// src/commands/shop.ts
+import { Command as Command17 } from "commander";
+function createShopCommand() {
+  const shop = new Command17("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);
+      const shopData = await client.getShop(serverId);
+      output(shopData, { 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("--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
+        });
+        process.exit(1);
+      }
+    }
+  );
+  products.command("get").description("Get product details").argument("<server-id>", "Server ID").argument("<product-id>", "Product ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, productId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const product = await client.getProduct(serverId, productId);
+        output(product, { 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 {
+      const client = await getClient(options.profile);
+      const cartData = await client.getCart(serverId);
+      output(cartData, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  const orders = shop.command("orders").description("Order commands");
+  orders.command("list").description("List orders").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);
+      const orders2 = await client.listOrders(serverId);
+      output(orders2, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  orders.command("get").description("Get order details").argument("<server-id>", "Server ID").argument("<order-id>", "Order ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, orderId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const order = await client.getOrder(serverId, orderId);
+        output(order, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  const wallet = shop.command("wallet").description("Wallet commands");
+  wallet.command("balance").description("Get wallet balance").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const client = await getClient(options.profile);
+      const wallet2 = await client.getWallet();
+      output(wallet2, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  return shop;
+}
+
+// src/commands/status.ts
+import { Command as Command18 } from "commander";
+function createStatusCommand() {
+  const status = new Command18("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 {
+      const profileName = options.profile ?? await configManager.getCurrentProfileName();
+      const profile = await configManager.getProfile(options.profile);
+      if (!profile) {
+        outputError(
+          profileName ? `Profile "${profileName}" not found` : "Not authenticated. Run: shadowob auth login",
+          { json: options.json }
+        );
+        process.exit(1);
+      }
+      const client = await getClient(options.profile);
+      const user = await client.getMe();
+      const notifications = await client.listNotifications(1).catch(() => []);
+      const statusInfo = {
+        profile: {
+          name: profileName,
+          serverUrl: profile.serverUrl
+        },
+        user: {
+          id: user.id,
+          username: user.username,
+          displayName: user.displayName,
+          avatarUrl: user.avatarUrl
+        },
+        stats: {
+          unreadNotifications: Array.isArray(notifications) ? notifications.length : 0
+        },
+        connection: {
+          status: "connected",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      if (options.json) {
+        output(statusInfo, outputOpts);
+      } else {
+        outputSuccess(`Connected as ${user.username}`, outputOpts);
+        console.log("");
+        console.log("Profile:");
+        console.log(`  Name: ${profileName}`);
+        console.log(`  Server: ${profile.serverUrl}`);
+        console.log("");
+        console.log("User:");
+        console.log(`  ID: ${user.id}`);
+        console.log(`  Username: ${user.username}`);
+        if (user.displayName && user.displayName !== user.username) {
+          console.log(`  Display Name: ${user.displayName}`);
+        }
+        console.log("");
+        console.log("Stats:");
+        console.log(`  Unread Notifications: ${statusInfo.stats.unreadNotifications}`);
+      }
+      process.exit(0);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (options.json) {
+        output(
+          {
+            error: errorMessage,
+            connection: {
+              status: "disconnected",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          },
+          outputOpts
+        );
+      } else {
+        outputError(errorMessage, outputOpts);
+      }
+      process.exit(1);
+    }
+  });
+  return status;
+}
+
+// src/commands/threads.ts
+import { Command as Command19 } from "commander";
+function createThreadsCommand() {
+  const threads = new Command19("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);
+      const threads2 = await client.listThreads(channelId);
+      output(threads2, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  threads.command("get").description("Get thread details").argument("<thread-id>", "Thread ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (threadId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      const thread = await client.getThread(threadId);
+      output(thread, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  threads.command("create").description("Create a thread").argument("<channel-id>", "Channel ID").requiredOption("--name <name>", "Thread name").requiredOption("--parent-message <id>", "Parent message ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (channelId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const thread = await client.createThread(channelId, options.name, options.parentMessage);
+        output(thread, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  threads.command("delete").description("Delete a thread").argument("<thread-id>", "Thread ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(async (threadId, options) => {
+    try {
+      const client = await getClient(options.profile);
+      await client.deleteThread(threadId);
+      const outputOpts = { json: options.json };
+      outputSuccess("Thread deleted", outputOpts);
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  threads.command("messages").description("List messages in a thread").argument("<thread-id>", "Thread ID").option("--limit <n>", "Number of messages", "50").option("--cursor <cursor>", "Pagination cursor").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (threadId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const messages = await client.getThreadMessages(
+          threadId,
+          parseInt(options.limit ?? "50", 10),
+          options.cursor
+        );
+        output(messages, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  threads.command("send").description("Send a message to a thread").argument("<thread-id>", "Thread ID").requiredOption("--content <text>", "Message content").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (threadId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const message = await client.sendToThread(threadId, options.content);
+        output(message, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  return threads;
+}
+
+// src/commands/workspace.ts
+import { readFile } from "fs/promises";
+import { Command as Command20 } from "commander";
+function createWorkspaceCommand() {
+  const workspace = new Command20("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);
+      const ws = await client.getWorkspace(serverId);
+      output(ws, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  workspace.command("tree").description("Get workspace file tree").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);
+      const tree = await client.getWorkspaceTree(serverId);
+      output(tree, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  workspace.command("stats").description("Get workspace stats").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);
+      const stats = await client.getWorkspaceStats(serverId);
+      output(stats, { json: options.json });
+    } catch (error) {
+      outputError(error instanceof Error ? error.message : String(error), { json: options.json });
+      process.exit(1);
+    }
+  });
+  workspace.command("children").description("List children in a folder").argument("<server-id>", "Server ID or slug").option("--parent-id <id>", "Parent folder ID (omit for root)").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const children = await client.getWorkspaceChildren(serverId, options.parentId ?? null);
+        output(children, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  const files = workspace.command("files").description("File operations");
+  files.command("get").description("Get file details").argument("<server-id>", "Server ID or slug").argument("<file-id>", "File ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, fileId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const file = await client.getWorkspaceFile(serverId, fileId);
+        output(file, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  files.command("update").description("Update a file").argument("<server-id>", "Server ID or slug").argument("<file-id>", "File ID").option("--name <name>", "New name").option("--parent-id <id>", "New parent folder ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, fileId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const file = await client.updateWorkspaceFile(serverId, fileId, {
+          name: options.name,
+          parentId: options.parentId
+        });
+        output(file, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  files.command("delete").description("Delete a file").argument("<server-id>", "Server ID or slug").argument("<file-id>", "File ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, fileId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        await client.deleteWorkspaceFile(serverId, fileId);
+        const outputOpts = { json: options.json };
+        outputSuccess("File deleted", outputOpts);
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  files.command("upload").description("Upload a file").argument("<server-id>", "Server ID or slug").requiredOption("--file <path>", "File path to upload").option("--name <name>", "File name (defaults to filename)").option("--parent-id <id>", "Parent folder ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const content = await readFile(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);
+        output(result, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  files.command("search").description("Search files").argument("<server-id>", "Server ID or slug").option("--search-text <text>", "Search text").option("--ext <ext>", "File extension").option("--parent-id <id>", "Parent folder ID").option("--limit <n>", "Limit results", "50").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const files2 = await client.searchWorkspaceFiles(serverId, {
+          searchText: options.searchText,
+          ext: options.ext,
+          parentId: options.parentId,
+          limit: parseInt(options.limit ?? "50", 10)
+        });
+        output(files2, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  const folders = workspace.command("folders").description("Folder operations");
+  folders.command("create").description("Create a folder").argument("<server-id>", "Server ID or slug").requiredOption("--name <name>", "Folder name").option("--parent-id <id>", "Parent folder ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const folder = await client.createWorkspaceFolder(serverId, {
+          name: options.name,
+          parentId: options.parentId
+        });
+        output(folder, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  folders.command("update").description("Update a folder").argument("<server-id>", "Server ID or slug").argument("<folder-id>", "Folder ID").option("--name <name>", "New name").option("--parent-id <id>", "New parent folder ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, folderId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        const folder = await client.updateWorkspaceFolder(serverId, folderId, {
+          name: options.name,
+          parentId: options.parentId
+        });
+        output(folder, { json: options.json });
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  folders.command("delete").description("Delete a folder").argument("<server-id>", "Server ID or slug").argument("<folder-id>", "Folder ID").option("--profile <name>", "Profile to use").option("--json", "Output as JSON").action(
+    async (serverId, folderId, options) => {
+      try {
+        const client = await getClient(options.profile);
+        await client.deleteWorkspaceFolder(serverId, folderId);
+        const outputOpts = { json: options.json };
+        outputSuccess("Folder deleted", outputOpts);
+      } catch (error) {
+        outputError(error instanceof Error ? error.message : String(error), {
+          json: options.json
+        });
+        process.exit(1);
+      }
+    }
+  );
+  return workspace;
+}
+
+// src/index.ts
+var program = new Command21();
+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(createServersCommand());
+program.addCommand(createChannelsCommand());
+program.addCommand(createThreadsCommand());
+program.addCommand(createAgentsCommand());
+program.addCommand(createListenCommand());
+program.addCommand(createDmsCommand());
+program.addCommand(createWorkspaceCommand());
+program.addCommand(createShopCommand());
+program.addCommand(createAppsCommand());
+program.addCommand(createNotificationsCommand());
+program.addCommand(createFriendsCommand());
+program.addCommand(createInvitesCommand());
+program.addCommand(createOAuthCommand());
+program.addCommand(createMarketplaceCommand());
+program.addCommand(createMediaCommand());
+program.addCommand(createSearchCommand());
+program.addCommand(createConfigCommand());
+program.addCommand(createPingCommand());
+program.addCommand(createStatusCommand());
+program.parse();