@ibbybuilds/discli 0.1.0

package/dist/cli.js

@@ -0,0 +1,867 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/utils/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".discli");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var ENV_FILE = join(CONFIG_DIR, ".env");
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(data) {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2) + "\n");
+}
+function loadToken() {
+  if (!existsSync(ENV_FILE)) return null;
+  const content = readFileSync(ENV_FILE, "utf-8");
+  const match = content.match(/^BOT_TOKEN=(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+function saveToken(token) {
+  ensureConfigDir();
+  writeFileSync(ENV_FILE, `BOT_TOKEN=${token}
+`);
+}
+function getDefaultServer() {
+  return loadConfig().default_server_id ?? null;
+}
+function setDefaultServer(id, name) {
+  const cfg = loadConfig();
+  cfg.default_server_id = id;
+  cfg.default_server_name = name;
+  saveConfig(cfg);
+}
+function requireToken() {
+  const token = loadToken();
+  if (!token) {
+    console.error('Error: Not configured. Run "discli init" first.');
+    process.exit(1);
+  }
+  return token;
+}
+function requireServer(override) {
+  const server = override || getDefaultServer();
+  if (!server) {
+    console.error('Error: No server selected. Run "discli server select" or use --server <id>.');
+    process.exit(1);
+  }
+  return server;
+}
+
+// src/utils/api.ts
+var BASE = "https://discord.com/api/v10";
+var PERMISSION = {
+  view_channel: 1n << 10n,
+  send_messages: 1n << 11n,
+  send_messages_in_threads: 1n << 38n,
+  create_public_threads: 1n << 35n,
+  create_private_threads: 1n << 36n,
+  embed_links: 1n << 14n,
+  attach_files: 1n << 15n,
+  add_reactions: 1n << 6n,
+  use_external_emojis: 1n << 18n,
+  read_message_history: 1n << 16n,
+  mention_everyone: 1n << 17n,
+  manage_messages: 1n << 13n,
+  manage_channels: 1n << 4n,
+  manage_roles: 1n << 28n,
+  connect: 1n << 20n,
+  speak: 1n << 21n,
+  mute_members: 1n << 22n,
+  deafen_members: 1n << 23n,
+  move_members: 1n << 24n,
+  use_voice_activity: 1n << 25n
+};
+var CHANNEL_TYPE = {
+  text: 0,
+  voice: 2,
+  category: 4,
+  announcement: 5,
+  stage: 13,
+  forum: 15
+};
+var CHANNEL_TYPE_NAME = Object.fromEntries(
+  Object.entries(CHANNEL_TYPE).map(([k, v]) => [v, k])
+);
+var DiscordAPI = class {
+  token;
+  constructor(token) {
+    this.token = token;
+  }
+  async request(method, path, body) {
+    const headers = {
+      Authorization: `Bot ${this.token}`
+    };
+    if (body) {
+      headers["Content-Type"] = "application/json";
+    }
+    const res = await fetch(`${BASE}${path}`, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (res.status === 429) {
+      const data = await res.json();
+      console.error(`Rate limited. Retry after ${data.retry_after ?? "?"}s.`);
+      process.exit(1);
+    }
+    if (res.status === 403) {
+      console.error("403 Forbidden \u2014 missing permissions.");
+      process.exit(4);
+    }
+    if (res.status === 404) {
+      console.error("404 Not found.");
+      process.exit(3);
+    }
+    if (res.status >= 400) {
+      const text = await res.text();
+      console.error(`Discord API error ${res.status}: ${text.slice(0, 200)}`);
+      process.exit(1);
+    }
+    if (res.status === 204) return null;
+    return res.json();
+  }
+  // ── Guilds ──
+  async listGuilds() {
+    return await this.request("GET", "/users/@me/guilds");
+  }
+  async getGuild(guildId) {
+    return await this.request("GET", `/guilds/${guildId}?with_counts=true`);
+  }
+  // ── Channels ──
+  async listChannels(guildId) {
+    return await this.request("GET", `/guilds/${guildId}/channels`);
+  }
+  async createChannel(guildId, opts) {
+    return await this.request("POST", `/guilds/${guildId}/channels`, opts);
+  }
+  async deleteChannel(channelId) {
+    await this.request("DELETE", `/channels/${channelId}`);
+  }
+  async modifyChannel(channelId, data) {
+    return await this.request("PATCH", `/channels/${channelId}`, data);
+  }
+  async getChannel(channelId) {
+    return await this.request("GET", `/channels/${channelId}`);
+  }
+  async editChannelPermission(channelId, overwriteId, data) {
+    await this.request("PUT", `/channels/${channelId}/permissions/${overwriteId}`, data);
+  }
+  async deleteChannelPermission(channelId, overwriteId) {
+    await this.request("DELETE", `/channels/${channelId}/permissions/${overwriteId}`);
+  }
+  // ── Roles ──
+  async listRoles(guildId) {
+    return await this.request("GET", `/guilds/${guildId}/roles`);
+  }
+  async createRole(guildId, data) {
+    return await this.request("POST", `/guilds/${guildId}/roles`, data);
+  }
+  async deleteRole(guildId, roleId) {
+    await this.request("DELETE", `/guilds/${guildId}/roles/${roleId}`);
+  }
+  async addRoleToMember(guildId, userId, roleId) {
+    await this.request("PUT", `/guilds/${guildId}/members/${userId}/roles/${roleId}`);
+  }
+  async removeRoleFromMember(guildId, userId, roleId) {
+    await this.request("DELETE", `/guilds/${guildId}/members/${userId}/roles/${roleId}`);
+  }
+  // ── Members ──
+  async listMembers(guildId, limit = 100) {
+    return await this.request("GET", `/guilds/${guildId}/members?limit=${Math.min(limit, 1e3)}`);
+  }
+  async getMember(guildId, userId) {
+    return await this.request("GET", `/guilds/${guildId}/members/${userId}`);
+  }
+  async kickMember(guildId, userId) {
+    await this.request("DELETE", `/guilds/${guildId}/members/${userId}`);
+  }
+  async banMember(guildId, userId) {
+    await this.request("PUT", `/guilds/${guildId}/bans/${userId}`);
+  }
+  async modifyMember(guildId, userId, data) {
+    return await this.request("PATCH", `/guilds/${guildId}/members/${userId}`, data);
+  }
+};
+
+// src/commands/init.ts
+import { readFileSync as readFileSync2 } from "fs";
+function registerInit(program2) {
+  program2.command("init").description("Set up discli with your bot token and default server").option("--token <token>", "Bot token (or reads from stdin)").action(async (opts) => {
+    let token = opts.token;
+    if (!token) {
+      if (!process.stdin.isTTY) {
+        token = readFileSync2(0, "utf-8").trim();
+      }
+    }
+    if (!token) {
+      const existing = loadToken();
+      if (existing) {
+        console.log("Already configured. Use --token to update.");
+        token = existing;
+      } else {
+        console.error("Usage: discli init --token <your-bot-token>");
+        console.error("  Get your token from https://discord.com/developers/applications");
+        process.exit(2);
+      }
+    }
+    const api = new DiscordAPI(token);
+    let guilds;
+    try {
+      guilds = await api.listGuilds();
+    } catch {
+      console.error("Invalid token or cannot connect to Discord.");
+      process.exit(1);
+    }
+    saveToken(token);
+    console.log(`Token saved to ~/.discli/.env`);
+    if (guilds.length === 0) {
+      console.log("Bot is not in any servers yet. Add it to a server first.");
+      return;
+    }
+    console.log("\nServers:");
+    guilds.forEach((g, i) => {
+      console.log(`  ${i + 1}. ${g.name} (${g.id})`);
+    });
+    if (guilds.length === 1) {
+      setDefaultServer(guilds[0].id, guilds[0].name);
+      console.log(`
+Default server: ${guilds[0].name}`);
+    } else {
+      console.log(`
+Set default with: discli server select <id>`);
+    }
+    console.log("\nReady! Try: discli server info");
+  });
+}
+
+// src/utils/output.ts
+import { stringify as yamlStringify } from "yaml";
+function resolveFormat(explicit) {
+  if (explicit !== "auto") return explicit;
+  return process.stdout.isTTY ? "table" : "yaml";
+}
+function printResult(data, format) {
+  const fmt = resolveFormat(format);
+  if (fmt === "json") {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (fmt === "yaml") {
+    console.log(yamlStringify(data, { indent: 2 }).trimEnd());
+    return;
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      console.log("  (none)");
+      return;
+    }
+    if (typeof data[0] === "object") {
+      printTable(data);
+    } else {
+      data.forEach((item) => console.log(`  ${item}`));
+    }
+    return;
+  }
+  if (typeof data === "object" && data !== null) {
+    const obj = data;
+    const maxKey = Math.max(...Object.keys(obj).map((k) => k.length));
+    for (const [k, v] of Object.entries(obj)) {
+      console.log(`  ${k.padEnd(maxKey)}  ${v}`);
+    }
+    return;
+  }
+  console.log(String(data));
+}
+function printTable(rows, columns) {
+  if (rows.length === 0) {
+    console.log("  (none)");
+    return;
+  }
+  const cols = columns ?? Object.keys(rows[0]);
+  const widths = {};
+  for (const col of cols) {
+    widths[col] = col.length;
+  }
+  for (const row of rows) {
+    for (const col of cols) {
+      widths[col] = Math.max(widths[col], String(row[col] ?? "").length);
+    }
+  }
+  const header = cols.map((c) => c.toUpperCase().padEnd(widths[c])).join("  ");
+  const sep = cols.map((c) => "\u2500".repeat(widths[c])).join("  ");
+  console.log(`  ${header}`);
+  console.log(`  ${sep}`);
+  for (const row of rows) {
+    const line = cols.map((c) => String(row[c] ?? "").padEnd(widths[c])).join("  ");
+    console.log(`  ${line}`);
+  }
+}
+
+// src/commands/server.ts
+function registerServer(program2) {
+  const server = program2.command("server").description("Manage and inspect servers");
+  server.command("list").description("List all servers the bot is in").action(async () => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guilds = await api.listGuilds();
+    if (fmt !== "table") {
+      printResult(guilds, fmt);
+      return;
+    }
+    const rows = guilds.map((g) => ({
+      id: g.id,
+      name: g.name,
+      owner: g.owner ? "yes" : "no"
+    }));
+    console.log("\nServers");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    printResult(rows, fmt);
+  });
+  server.command("select").description("Set the default server").argument("<id>", "Server ID").action(async (id) => {
+    const api = new DiscordAPI(requireToken());
+    const guild = await api.getGuild(id);
+    setDefaultServer(guild.id, guild.name);
+    console.log(`Default server set to: ${guild.name} (${guild.id})`);
+  });
+  server.command("info").description("Show server details").action(async () => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const guild = await api.getGuild(guildId);
+    if (fmt !== "table") {
+      printResult(guild, fmt);
+      return;
+    }
+    const info = {
+      name: guild.name,
+      id: guild.id,
+      description: guild.description || "(none)",
+      members: guild.approximate_member_count ?? "?",
+      online: guild.approximate_presence_count ?? "?",
+      boosts: guild.premium_subscription_count,
+      boost_tier: guild.premium_tier
+    };
+    console.log(`
+${guild.name}`);
+    console.log("\u2500".repeat(guild.name.length));
+    printResult(info, fmt);
+  });
+}
+
+// src/utils/resolve.ts
+async function resolveChannel(api, guildId, name) {
+  const channels = await api.listChannels(guildId);
+  const byId = channels.find((c) => c.id === name);
+  if (byId) return byId;
+  const clean = name.replace(/^#/, "");
+  const matches = channels.filter((c) => c.name.toLowerCase() === clean.toLowerCase());
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    const names = matches.map((m) => `#${m.name} (${CHANNEL_TYPE_NAME[m.type] ?? "?"})`).join(", ");
+    console.error(`Ambiguous channel "${clean}". Matches: ${names}`);
+    process.exit(1);
+  }
+  console.error(`Channel "${name}" not found.`);
+  process.exit(3);
+}
+async function resolveCategory(api, guildId, name) {
+  const channels = await api.listChannels(guildId);
+  const byId = channels.find((c) => c.id === name && c.type === 4);
+  if (byId) return byId;
+  const matches = channels.filter(
+    (c) => c.type === 4 && c.name.toLowerCase() === name.toLowerCase()
+  );
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    console.error(`Ambiguous category "${name}".`);
+    process.exit(1);
+  }
+  console.error(`Category "${name}" not found.`);
+  process.exit(3);
+}
+async function resolveRole(api, guildId, name) {
+  const roles = await api.listRoles(guildId);
+  const byId = roles.find((r) => r.id === name);
+  if (byId) return byId;
+  const clean = name.replace(/^@/, "");
+  const matches = roles.filter((r) => r.name.toLowerCase() === clean.toLowerCase());
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    const names = matches.map((m) => `@${m.name}`).join(", ");
+    console.error(`Ambiguous role "${clean}". Matches: ${names}`);
+    process.exit(1);
+  }
+  console.error(`Role "${name}" not found.`);
+  process.exit(3);
+}
+async function resolveMember(api, guildId, name) {
+  if (/^\d+$/.test(name)) {
+    try {
+      return await api.getMember(guildId, name);
+    } catch {
+    }
+  }
+  const members = await api.listMembers(guildId, 1e3);
+  const clean = name.replace(/^@/, "").toLowerCase();
+  const matches = members.filter((m) => {
+    const username = m.user?.username?.toLowerCase() ?? "";
+    const globalName = m.user?.global_name?.toLowerCase() ?? "";
+    const nick = m.nick?.toLowerCase() ?? "";
+    return username === clean || globalName === clean || nick === clean;
+  });
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    const names = matches.map((m) => m.user?.username).join(", ");
+    console.error(`Ambiguous user "${name}". Matches: ${names}`);
+    process.exit(1);
+  }
+  console.error(`Member "${name}" not found.`);
+  process.exit(3);
+}
+
+// src/commands/channel.ts
+function registerChannel(program2) {
+  const channel = program2.command("channel").description("Manage server channels");
+  channel.command("list").description("List all channels grouped by category").option("-n <count>", "Limit number of channels shown", parseInt).action(async (opts) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    let channels = await api.listChannels(guildId);
+    if (opts.n) channels = channels.slice(0, opts.n);
+    if (fmt !== "table") {
+      printResult(channels, fmt);
+      return;
+    }
+    const categories = channels.filter((c) => c.type === 4).sort((a, b) => a.position - b.position);
+    const uncategorized = channels.filter(
+      (c) => c.type !== 4 && !c.parent_id
+    );
+    if (uncategorized.length > 0) {
+      console.log("\n  (no category)");
+      for (const ch of uncategorized.sort((a, b) => a.position - b.position)) {
+        const type = CHANNEL_TYPE_NAME[ch.type] ?? "?";
+        console.log(`    ${type === "text" ? "#" : "\u{1F50A}"} ${ch.name}`);
+      }
+    }
+    for (const cat of categories) {
+      console.log(`
+  ${cat.name.toUpperCase()}`);
+      const children = channels.filter((c) => c.parent_id === cat.id && c.type !== 4).sort((a, b) => a.position - b.position);
+      for (const ch of children) {
+        const type = CHANNEL_TYPE_NAME[ch.type] ?? "?";
+        const prefix = type === "voice" || type === "stage" ? "\u{1F50A}" : "#";
+        const topic = ch.topic ? ` \u2014 ${ch.topic}` : "";
+        console.log(`    ${prefix} ${ch.name}${topic}`);
+      }
+    }
+    console.log();
+  });
+  channel.command("create").description("Create a new channel").argument("<name>", "Channel name").option("--type <type>", "Channel type: text, voice, category, announcement, stage, forum", "text").option("--category <name>", "Parent category name or ID").option("--topic <topic>", "Channel topic").option("--dry-run", "Show what would be created without creating it").action(async (name, opts) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const channelType = CHANNEL_TYPE[opts.type];
+    if (channelType === void 0) {
+      console.error(`Unknown channel type: ${opts.type}. Use: ${Object.keys(CHANNEL_TYPE).join(", ")}`);
+      process.exit(2);
+    }
+    let parentId;
+    if (opts.category) {
+      const cat = await resolveCategory(api, guildId, opts.category);
+      parentId = cat.id;
+    }
+    if (opts.dryRun) {
+      const result = { action: "create_channel", name, type: opts.type, category: opts.category ?? null, topic: opts.topic ?? null };
+      printResult(result, fmt);
+      return;
+    }
+    const ch = await api.createChannel(guildId, {
+      name,
+      type: channelType,
+      parent_id: parentId,
+      topic: opts.topic
+    });
+    if (fmt !== "table") {
+      printResult(ch, fmt);
+    } else {
+      console.log(`Created #${ch.name} (${CHANNEL_TYPE_NAME[ch.type] ?? "?"}) \u2014 ${ch.id}`);
+    }
+  });
+  channel.command("delete").description("Delete a channel").argument("<name>", "Channel name or ID").option("--confirm", "Required to actually delete").action(async (name, opts) => {
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const ch = await resolveChannel(api, guildId, name);
+    if (!opts.confirm) {
+      console.error(`This will delete #${ch.name} (${ch.id}). Add --confirm to proceed.`);
+      process.exit(2);
+    }
+    await api.deleteChannel(ch.id);
+    console.log(`Deleted #${ch.name}`);
+  });
+  channel.command("rename").description("Rename a channel").argument("<channel>", "Channel name or ID").argument("<new-name>", "New channel name").option("--dry-run", "Show what would change").action(async (channelName, newName, opts) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const ch = await resolveChannel(api, guildId, channelName);
+    if (opts.dryRun) {
+      printResult({ action: "rename_channel", from: ch.name, to: newName, id: ch.id }, fmt);
+      return;
+    }
+    await api.modifyChannel(ch.id, { name: newName });
+    console.log(`Renamed #${ch.name} \u2192 #${newName}`);
+  });
+  channel.command("topic").description("Set a channel topic").argument("<channel>", "Channel name or ID").argument("<topic>", "New topic text").action(async (channelName, topic) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const ch = await resolveChannel(api, guildId, channelName);
+    const updated = await api.modifyChannel(ch.id, { topic });
+    if (fmt !== "table") {
+      printResult(updated, fmt);
+    } else {
+      console.log(`Set topic for #${ch.name}: ${topic}`);
+    }
+  });
+  channel.command("move").description("Move a channel to a category").argument("<channel>", "Channel name or ID").option("--category <name>", "Target category name or ID").option("--position <n>", "Position within category", parseInt).action(async (channelName, opts) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const ch = await resolveChannel(api, guildId, channelName);
+    const update = {};
+    if (opts.category) {
+      const cat = await resolveCategory(api, guildId, opts.category);
+      update.parent_id = cat.id;
+    }
+    if (opts.position !== void 0) {
+      update.position = opts.position;
+    }
+    if (Object.keys(update).length === 0) {
+      console.error("Specify --category and/or --position.");
+      process.exit(2);
+    }
+    const updated = await api.modifyChannel(ch.id, update);
+    if (fmt !== "table") {
+      printResult(updated, fmt);
+    } else {
+      console.log(`Moved #${ch.name}${opts.category ? ` \u2192 ${opts.category}` : ""}${opts.position !== void 0 ? ` (position ${opts.position})` : ""}`);
+    }
+  });
+}
+
+// src/commands/role.ts
+function registerRole(program2) {
+  const role = program2.command("role").description("Manage server roles");
+  role.command("list").description("List all roles").option("-n <count>", "Limit number of roles shown", parseInt).action(async (opts) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const roles = await api.listRoles(guildId);
+    const sorted = roles.sort((a, b) => b.position - a.position).slice(0, opts.n ?? roles.length);
+    if (fmt !== "table") {
+      printResult(sorted, fmt);
+      return;
+    }
+    const rows = sorted.map((r) => ({
+      name: r.name,
+      id: r.id,
+      color: r.color ? `#${r.color.toString(16).padStart(6, "0")}` : "(none)",
+      managed: r.managed ? "bot" : "",
+      position: r.position
+    }));
+    console.log("\nRoles");
+    console.log("\u2500\u2500\u2500\u2500\u2500");
+    printResult(rows, fmt);
+  });
+  role.command("create").description("Create a new role").argument("<name>", "Role name").option("--color <hex>", "Color hex (e.g. #ff5733)").option("--mentionable", "Allow anyone to mention this role").option("--dry-run", "Show what would be created").action(async (name, opts) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const data = { name };
+    if (opts.color) {
+      data.color = parseInt(opts.color.replace("#", ""), 16);
+    }
+    if (opts.mentionable) {
+      data.mentionable = true;
+    }
+    if (opts.dryRun) {
+      printResult({ action: "create_role", ...data }, fmt);
+      return;
+    }
+    const r = await api.createRole(guildId, data);
+    if (fmt !== "table") {
+      printResult(r, fmt);
+    } else {
+      console.log(`Created role @${r.name} \u2014 ${r.id}`);
+    }
+  });
+  role.command("delete").description("Delete a role").argument("<name>", "Role name or ID").option("--confirm", "Required to actually delete").action(async (name, opts) => {
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const r = await resolveRole(api, guildId, name);
+    if (!opts.confirm) {
+      console.error(`This will delete @${r.name} (${r.id}). Add --confirm to proceed.`);
+      process.exit(2);
+    }
+    await api.deleteRole(guildId, r.id);
+    console.log(`Deleted role @${r.name}`);
+  });
+  role.command("assign").description("Assign a role to a member").argument("<role>", "Role name or ID").argument("<user>", "Username or ID").action(async (roleName, userName) => {
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const r = await resolveRole(api, guildId, roleName);
+    const m = await resolveMember(api, guildId, userName);
+    await api.addRoleToMember(guildId, m.user.id, r.id);
+    console.log(`Assigned @${r.name} to ${m.user.username}`);
+  });
+  role.command("remove").description("Remove a role from a member").argument("<role>", "Role name or ID").argument("<user>", "Username or ID").action(async (roleName, userName) => {
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const r = await resolveRole(api, guildId, roleName);
+    const m = await resolveMember(api, guildId, userName);
+    await api.removeRoleFromMember(guildId, m.user.id, r.id);
+    console.log(`Removed @${r.name} from ${m.user.username}`);
+  });
+}
+
+// src/commands/member.ts
+function registerMember(program2) {
+  const member = program2.command("member").description("Manage server members");
+  member.command("list").description("List server members").option("-n, --limit <n>", "Max members to show", "100").action(async (opts) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const members = await api.listMembers(guildId, parseInt(opts.limit));
+    if (fmt !== "table") {
+      printResult(members, fmt);
+      return;
+    }
+    const rows = members.map((m) => ({
+      username: m.user?.username ?? "?",
+      display: m.user?.global_name ?? m.nick ?? "",
+      nick: m.nick ?? "",
+      roles: m.roles.length,
+      joined: m.joined_at?.slice(0, 10) ?? "?"
+    }));
+    console.log(`
+Members (${members.length})`);
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    printResult(rows, fmt);
+  });
+  member.command("info").description("Show member details").argument("<user>", "Username or ID").action(async (userName) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const m = await resolveMember(api, guildId, userName);
+    if (fmt !== "table") {
+      printResult(m, fmt);
+      return;
+    }
+    const roles = await api.listRoles(guildId);
+    const memberRoles = m.roles.map((rid) => roles.find((r) => r.id === rid)?.name ?? rid).join(", ");
+    const info = {
+      username: m.user?.username ?? "?",
+      display_name: m.user?.global_name ?? "(none)",
+      nickname: m.nick ?? "(none)",
+      id: m.user?.id ?? "?",
+      roles: memberRoles || "(none)",
+      joined: m.joined_at?.slice(0, 10) ?? "?"
+    };
+    console.log(`
+${m.user?.username ?? "Member"}`);
+    console.log("\u2500".repeat((m.user?.username ?? "Member").length));
+    printResult(info, fmt);
+  });
+  member.command("kick").description("Kick a member from the server").argument("<user>", "Username or ID").option("--reason <text>", "Reason for kick").option("--confirm", "Required to actually kick").action(async (userName, opts) => {
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const m = await resolveMember(api, guildId, userName);
+    if (!opts.confirm) {
+      console.error(`This will kick ${m.user.username} (${m.user.id}). Add --confirm to proceed.`);
+      process.exit(2);
+    }
+    await api.kickMember(guildId, m.user.id);
+    console.log(`Kicked ${m.user.username}${opts.reason ? ` \u2014 ${opts.reason}` : ""}`);
+  });
+  member.command("ban").description("Ban a member from the server").argument("<user>", "Username or ID").option("--reason <text>", "Reason for ban").option("--confirm", "Required to actually ban").action(async (userName, opts) => {
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const m = await resolveMember(api, guildId, userName);
+    if (!opts.confirm) {
+      console.error(`This will BAN ${m.user.username} (${m.user.id}). Add --confirm to proceed.`);
+      process.exit(2);
+    }
+    await api.banMember(guildId, m.user.id);
+    console.log(`Banned ${m.user.username}${opts.reason ? ` \u2014 ${opts.reason}` : ""}`);
+  });
+  member.command("nick").description("Change a member's nickname").argument("<user>", "Username or ID").argument("<nickname>", "New nickname").action(async (userName, nickname) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const m = await resolveMember(api, guildId, userName);
+    await api.modifyMember(guildId, m.user.id, { nick: nickname });
+    if (fmt !== "table") {
+      printResult({ action: "nick", user: m.user.username, nick: nickname }, fmt);
+    } else {
+      console.log(`Set nickname for ${m.user.username} \u2192 ${nickname}`);
+    }
+  });
+}
+
+// src/commands/permission.ts
+function parsePermissions(perms) {
+  let bits = 0n;
+  for (const p of perms.split(",")) {
+    const name = p.trim().toLowerCase();
+    const val = PERMISSION[name];
+    if (val === void 0) {
+      console.error(`Unknown permission: ${name}`);
+      console.error(`Available: ${Object.keys(PERMISSION).join(", ")}`);
+      process.exit(2);
+    }
+    bits |= val;
+  }
+  return bits;
+}
+function describePermissions(bitfield) {
+  const bits = BigInt(bitfield);
+  if (bits === 0n) return [];
+  return Object.entries(PERMISSION).filter(([, val]) => (bits & val) === val).map(([name]) => name);
+}
+function registerPermission(program2) {
+  const perm = program2.command("permission").alias("perm").description("Manage channel permissions");
+  perm.command("view").description("View permission overwrites for a channel").argument("<channel>", "Channel name or ID").action(async (channelName) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const ch = await resolveChannel(api, guildId, channelName);
+    const full = await api.getChannel(ch.id);
+    const overwrites = full.permission_overwrites ?? [];
+    const roles = await api.listRoles(guildId);
+    if (fmt !== "table") {
+      printResult(overwrites, fmt);
+      return;
+    }
+    if (overwrites.length === 0) {
+      console.log(`
+#${ch.name}: no permission overwrites (inherits from category/server)`);
+      return;
+    }
+    console.log(`
+#${ch.name} \u2014 Permission Overwrites`);
+    console.log("\u2500".repeat(40));
+    for (const ow of overwrites) {
+      const target = ow.type === 0 ? roles.find((r) => r.id === ow.id)?.name ?? ow.id : `member:${ow.id}`;
+      const allowed = describePermissions(ow.allow);
+      const denied = describePermissions(ow.deny);
+      console.log(`
+  @${target} (${ow.type === 0 ? "role" : "member"})`);
+      if (allowed.length > 0) console.log(`    \u2705 allow: ${allowed.join(", ")}`);
+      if (denied.length > 0) console.log(`    \u274C deny:  ${denied.join(", ")}`);
+      if (allowed.length === 0 && denied.length === 0) console.log(`    (neutral)`);
+    }
+    console.log();
+  });
+  perm.command("set").description("Set permission overwrite for a role on a channel").argument("<channel>", "Channel name or ID").argument("<role>", "Role name or ID").option("--allow <perms>", "Comma-separated permissions to allow").option("--deny <perms>", "Comma-separated permissions to deny").option("--dry-run", "Show what would change").action(async (channelName, roleName, opts) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const ch = await resolveChannel(api, guildId, channelName);
+    const role = await resolveRole(api, guildId, roleName);
+    if (!opts.allow && !opts.deny) {
+      console.error("Specify --allow and/or --deny with comma-separated permissions.");
+      console.error(`Available: ${Object.keys(PERMISSION).join(", ")}`);
+      process.exit(2);
+    }
+    const allow = opts.allow ? parsePermissions(opts.allow) : 0n;
+    const deny = opts.deny ? parsePermissions(opts.deny) : 0n;
+    if (opts.dryRun) {
+      printResult({
+        action: "set_permission",
+        channel: ch.name,
+        role: role.name,
+        allow: opts.allow ?? "(none)",
+        deny: opts.deny ?? "(none)"
+      }, fmt);
+      return;
+    }
+    await api.editChannelPermission(ch.id, role.id, {
+      allow: allow.toString(),
+      deny: deny.toString(),
+      type: 0
+      // role
+    });
+    if (fmt !== "table") {
+      printResult({ channel: ch.name, role: role.name, allow: allow.toString(), deny: deny.toString() }, fmt);
+    } else {
+      console.log(`Set permissions on #${ch.name} for @${role.name}`);
+      if (opts.allow) console.log(`  \u2705 allow: ${opts.allow}`);
+      if (opts.deny) console.log(`  \u274C deny:  ${opts.deny}`);
+    }
+  });
+  perm.command("lock").description("Make a channel read-only for @everyone").argument("<channel>", "Channel name or ID").option("--dry-run", "Show what would change").action(async (channelName, opts) => {
+    const fmt = resolveFormat(program2.opts().format);
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const ch = await resolveChannel(api, guildId, channelName);
+    const deny = PERMISSION.send_messages | PERMISSION.send_messages_in_threads | PERMISSION.create_public_threads;
+    if (opts.dryRun) {
+      printResult({ action: "lock", channel: ch.name, deny_for: "@everyone" }, fmt);
+      return;
+    }
+    await api.editChannelPermission(ch.id, guildId, {
+      allow: "0",
+      deny: deny.toString(),
+      type: 0
+    });
+    console.log(`Locked #${ch.name} \u2014 read-only for @everyone`);
+  });
+  perm.command("unlock").description("Remove read-only restriction for @everyone").argument("<channel>", "Channel name or ID").action(async (channelName) => {
+    const api = new DiscordAPI(requireToken());
+    const guildId = requireServer(program2.opts().server);
+    const ch = await resolveChannel(api, guildId, channelName);
+    await api.deleteChannelPermission(ch.id, guildId);
+    console.log(`Unlocked #${ch.name} \u2014 @everyone can send messages`);
+  });
+  perm.command("list").description("List all available permission names").action(() => {
+    const fmt = resolveFormat(program2.opts().format);
+    if (fmt !== "table") {
+      const perms = Object.entries(PERMISSION).map(([name, val]) => ({ name, bit: val.toString() }));
+      printResult(perms, fmt);
+    } else {
+      console.log("\nAvailable Permissions");
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      for (const name of Object.keys(PERMISSION)) {
+        console.log(`  ${name}`);
+      }
+    }
+  });
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("discli").description("discli \u2014 Discord server management CLI").version("0.1.0").option("--format <fmt>", "Output format: json, yaml, table, auto (auto = yaml when piped, table in terminal)", "auto").option("--server <id>", "Server ID override");
+registerInit(program);
+registerServer(program);
+registerChannel(program);
+registerRole(program);
+registerMember(program);
+registerPermission(program);
+program.parse();
+//# sourceMappingURL=cli.js.map