agentcord 0.1.7 → 0.1.8

package/dist/{bot-G6464LRS.js → bot-MUOL7CRV.js}

@@ -69,11 +69,33 @@ function getCommandDefinitions() {
     { name: "General", value: "general" }
   ))).addSubcommand((sub) => sub.setName("list").setDescription("List available agent personas")).addSubcommand((sub) => sub.setName("clear").setDescription("Clear agent persona"));
   const project = new SlashCommandBuilder().setName("project").setDescription("Configure project settings").addSubcommand((sub) => sub.setName("personality").setDescription("Set a custom personality for this project").addStringOption((opt) => opt.setName("prompt").setDescription("System prompt for the project").setRequired(true))).addSubcommand((sub) => sub.setName("personality-show").setDescription("Show the current project personality")).addSubcommand((sub) => sub.setName("personality-clear").setDescription("Clear the project personality")).addSubcommand((sub) => sub.setName("skill-add").setDescription("Add a skill (prompt template) to this project").addStringOption((opt) => opt.setName("name").setDescription("Skill name").setRequired(true)).addStringOption((opt) => opt.setName("prompt").setDescription("Prompt template (use {input} for placeholder)").setRequired(true))).addSubcommand((sub) => sub.setName("skill-remove").setDescription("Remove a skill").addStringOption((opt) => opt.setName("name").setDescription("Skill name").setRequired(true))).addSubcommand((sub) => sub.setName("skill-list").setDescription("List all skills for this project")).addSubcommand((sub) => sub.setName("skill-run").setDescription("Execute a skill").addStringOption((opt) => opt.setName("name").setDescription("Skill name").setRequired(true)).addStringOption((opt) => opt.setName("input").setDescription("Input to pass to the skill template"))).addSubcommand((sub) => sub.setName("mcp-add").setDescription("Add an MCP server to this project").addStringOption((opt) => opt.setName("name").setDescription("Server name").setRequired(true)).addStringOption((opt) => opt.setName("command").setDescription("Command to run (e.g. npx my-mcp-server)").setRequired(true)).addStringOption((opt) => opt.setName("args").setDescription("Arguments (comma-separated)"))).addSubcommand((sub) => sub.setName("mcp-remove").setDescription("Remove an MCP server").addStringOption((opt) => opt.setName("name").setDescription("Server name").setRequired(true))).addSubcommand((sub) => sub.setName("mcp-list").setDescription("List configured MCP servers")).addSubcommand((sub) => sub.setName("info").setDescription("Show project configuration"));
+  const plugin = new SlashCommandBuilder().setName("plugin").setDescription("Manage Claude Code plugins").addSubcommand((sub) => sub.setName("browse").setDescription("Browse available plugins from marketplaces").addStringOption((opt) => opt.setName("search").setDescription("Filter by name or keyword"))).addSubcommand((sub) => sub.setName("install").setDescription("Install a plugin").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin name (e.g. feature-dev@claude-plugins-official)").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("scope").setDescription("Installation scope (default: user)").addChoices(
+    { name: "User \u2014 available everywhere", value: "user" },
+    { name: "Project \u2014 this project only", value: "project" },
+    { name: "Local \u2014 this directory only", value: "local" }
+  ))).addSubcommand((sub) => sub.setName("remove").setDescription("Uninstall a plugin").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin ID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("scope").setDescription("Scope to uninstall from (default: user)").addChoices(
+    { name: "User", value: "user" },
+    { name: "Project", value: "project" },
+    { name: "Local", value: "local" }
+  ))).addSubcommand((sub) => sub.setName("list").setDescription("List installed plugins")).addSubcommand((sub) => sub.setName("info").setDescription("Show detailed info for a plugin").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin name or ID").setRequired(true).setAutocomplete(true))).addSubcommand((sub) => sub.setName("enable").setDescription("Enable a disabled plugin").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin ID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("scope").setDescription("Scope (default: user)").addChoices(
+    { name: "User", value: "user" },
+    { name: "Project", value: "project" },
+    { name: "Local", value: "local" }
+  ))).addSubcommand((sub) => sub.setName("disable").setDescription("Disable a plugin").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin ID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("scope").setDescription("Scope (default: user)").addChoices(
+    { name: "User", value: "user" },
+    { name: "Project", value: "project" },
+    { name: "Local", value: "local" }
+  ))).addSubcommand((sub) => sub.setName("update").setDescription("Update a plugin to latest version").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin ID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("scope").setDescription("Scope (default: user)").addChoices(
+    { name: "User", value: "user" },
+    { name: "Project", value: "project" },
+    { name: "Local", value: "local" }
+  ))).addSubcommand((sub) => sub.setName("marketplace-add").setDescription("Add a plugin marketplace").addStringOption((opt) => opt.setName("source").setDescription("GitHub repo (owner/repo) or git URL").setRequired(true))).addSubcommand((sub) => sub.setName("marketplace-remove").setDescription("Remove a marketplace").addStringOption((opt) => opt.setName("name").setDescription("Marketplace name").setRequired(true).setAutocomplete(true))).addSubcommand((sub) => sub.setName("marketplace-list").setDescription("List registered marketplaces")).addSubcommand((sub) => sub.setName("marketplace-update").setDescription("Update marketplace catalogs").addStringOption((opt) => opt.setName("name").setDescription("Specific marketplace (or all if omitted)").setAutocomplete(true)));
   return [
     claude.toJSON(),
     shell.toJSON(),
     agent.toJSON(),
-    project.toJSON()
+    project.toJSON(),
+    plugin.toJSON()
   ];
 }
 async function registerCommands() {
@@ -104,8 +126,8 @@ import {
   ChannelType
 } from "discord.js";
 import { readdirSync, statSync, createReadStream } from "fs";
-import { join as join3, basename } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join4, basename } from "path";
+import { homedir as homedir3 } from "os";
 import { createInterface } from "readline";
 
 // src/session-manager.ts
@@ -245,6 +267,9 @@ async function saveProjects() {
 function getProject(name) {
   return projects[name];
 }
+function getProjectByCategoryId(categoryId) {
+  return Object.values(projects).find((p) => p.categoryId === categoryId);
+}
 function getOrCreateProject(name, directory, categoryId) {
   if (!projects[name]) {
     projects[name] = {
@@ -431,14 +456,19 @@ function detectNumberedOptions(text) {
   const options = [];
   const optionRegex = /^\s*(\d+)[.)]\s+(.+)$/;
   let firstOptionLine = -1;
+  let lastOptionLine = -1;
   for (let i = 0; i < lines.length; i++) {
     const match = lines[i].match(optionRegex);
     if (match) {
       if (firstOptionLine === -1) firstOptionLine = i;
+      lastOptionLine = i;
       options.push(match[2].trim());
     }
   }
   if (options.length < 2 || options.length > 6) return null;
+  if (options.some((o) => o.length > 80)) return null;
+  const linesAfter = lines.slice(lastOptionLine + 1).filter((l) => l.trim()).length;
+  if (linesAfter > 3) return null;
   const preamble = lines.slice(0, firstOptionLine).join(" ").toLowerCase();
   const hasQuestion = /\?\s*$/.test(preamble.trim()) || /\b(which|choose|select|pick|prefer|would you like|how would you|what approach|option)\b/.test(preamble);
   return hasQuestion ? options : null;
@@ -651,9 +681,23 @@ async function* sendPrompt(sessionId, prompt) {
   session.isGenerating = true;
   session.lastActivity = Date.now();
   const systemPrompt = buildSystemPrompt(session);
+  let queryPrompt;
+  if (typeof prompt === "string") {
+    queryPrompt = prompt;
+  } else {
+    const userMessage = {
+      type: "user",
+      message: { role: "user", content: prompt },
+      parent_tool_use_id: null,
+      session_id: ""
+    };
+    queryPrompt = (async function* () {
+      yield userMessage;
+    })();
+  }
   try {
     const stream = query({
-      prompt,
+      prompt: queryPrompt,
       options: {
         cwd: session.directory,
         resume: session.claudeSessionId,
@@ -777,16 +821,158 @@ async function listTmuxSessions() {
   }
 }
 
+// src/plugin-manager.ts
+import { execFile as execFile2 } from "child_process";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+var PLUGINS_DIR = join3(homedir2(), ".claude", "plugins");
+var MARKETPLACES_DIR = join3(PLUGINS_DIR, "marketplaces");
+function runClaude(args, cwd) {
+  return new Promise((resolve2) => {
+    execFile2("claude", args, {
+      cwd: cwd || process.cwd(),
+      timeout: 12e4,
+      env: { ...process.env }
+    }, (error, stdout, stderr) => {
+      resolve2({
+        stdout: stdout || "",
+        stderr: stderr || "",
+        code: error ? error.code ?? 1 : 0
+      });
+    });
+  });
+}
+var CACHE_TTL_MS = 3e4;
+var installedCache = null;
+var availableCache = null;
+var marketplaceCache = null;
+function invalidateCache() {
+  installedCache = null;
+  availableCache = null;
+  marketplaceCache = null;
+}
+async function listInstalled() {
+  if (installedCache && Date.now() - installedCache.ts < CACHE_TTL_MS) {
+    return installedCache.data;
+  }
+  const result = await runClaude(["plugin", "list", "--json"]);
+  if (result.code !== 0) throw new Error(`Failed to list plugins: ${result.stderr}`);
+  const data = JSON.parse(result.stdout);
+  installedCache = { data, ts: Date.now() };
+  return data;
+}
+async function listAvailable() {
+  if (availableCache && Date.now() - availableCache.ts < CACHE_TTL_MS) {
+    return availableCache.data;
+  }
+  const result = await runClaude(["plugin", "list", "--available", "--json"]);
+  if (result.code !== 0) throw new Error(`Failed to list available plugins: ${result.stderr}`);
+  const data = JSON.parse(result.stdout);
+  availableCache = { data, ts: Date.now() };
+  return data;
+}
+async function installPlugin(pluginId, scope, cwd) {
+  const result = await runClaude(["plugin", "install", pluginId, "-s", scope], cwd);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Install failed");
+  return result.stdout.trim() || "Plugin installed successfully.";
+}
+async function uninstallPlugin(pluginId, scope, cwd) {
+  const result = await runClaude(["plugin", "uninstall", pluginId, "-s", scope], cwd);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Uninstall failed");
+  return result.stdout.trim() || "Plugin uninstalled successfully.";
+}
+async function enablePlugin(pluginId, scope, cwd) {
+  const result = await runClaude(["plugin", "enable", pluginId, "-s", scope], cwd);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Enable failed");
+  return result.stdout.trim() || "Plugin enabled.";
+}
+async function disablePlugin(pluginId, scope, cwd) {
+  const result = await runClaude(["plugin", "disable", pluginId, "-s", scope], cwd);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Disable failed");
+  return result.stdout.trim() || "Plugin disabled.";
+}
+async function updatePlugin(pluginId, scope, cwd) {
+  const result = await runClaude(["plugin", "update", pluginId, "-s", scope], cwd);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Update failed");
+  return result.stdout.trim() || "Plugin updated.";
+}
+async function listMarketplaces() {
+  if (marketplaceCache && Date.now() - marketplaceCache.ts < CACHE_TTL_MS) {
+    return marketplaceCache.data;
+  }
+  const result = await runClaude(["plugin", "marketplace", "list", "--json"]);
+  if (result.code !== 0) throw new Error(`Failed to list marketplaces: ${result.stderr}`);
+  const data = JSON.parse(result.stdout);
+  marketplaceCache = { data, ts: Date.now() };
+  return data;
+}
+async function addMarketplace(source) {
+  const result = await runClaude(["plugin", "marketplace", "add", source]);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Add marketplace failed");
+  return result.stdout.trim() || "Marketplace added.";
+}
+async function removeMarketplace(name) {
+  const result = await runClaude(["plugin", "marketplace", "remove", name]);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Remove marketplace failed");
+  return result.stdout.trim() || "Marketplace removed.";
+}
+async function updateMarketplaces(name) {
+  const args = ["plugin", "marketplace", "update"];
+  if (name) args.push(name);
+  const result = await runClaude(args);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Update marketplace failed");
+  return result.stdout.trim() || "Marketplace(s) updated.";
+}
+async function getPluginDetail(pluginName, marketplaceName) {
+  try {
+    const marketplacePath = join3(MARKETPLACES_DIR, marketplaceName, ".claude-plugin", "marketplace.json");
+    const raw = await readFile3(marketplacePath, "utf-8");
+    const catalog = JSON.parse(raw);
+    return catalog.plugins.find((p) => p.name === pluginName) || null;
+  } catch {
+    return null;
+  }
+}
+
 // src/output-handler.ts
 import {
+  AttachmentBuilder,
   EmbedBuilder,
   ActionRowBuilder,
   ButtonBuilder,
   ButtonStyle,
   StringSelectMenuBuilder
 } from "discord.js";
+import { existsSync as existsSync4 } from "fs";
 var expandableStore = /* @__PURE__ */ new Map();
 var expandCounter = 0;
+var pendingAnswersStore = /* @__PURE__ */ new Map();
+var questionCountStore = /* @__PURE__ */ new Map();
+function setPendingAnswer(sessionId, questionIndex, answer) {
+  if (!pendingAnswersStore.has(sessionId)) {
+    pendingAnswersStore.set(sessionId, /* @__PURE__ */ new Map());
+  }
+  pendingAnswersStore.get(sessionId).set(questionIndex, answer);
+}
+function getPendingAnswers(sessionId) {
+  return pendingAnswersStore.get(sessionId);
+}
+function clearPendingAnswers(sessionId) {
+  pendingAnswersStore.delete(sessionId);
+  questionCountStore.delete(sessionId);
+}
+function getQuestionCount(sessionId) {
+  return questionCountStore.get(sessionId) || 0;
+}
 setInterval(() => {
   const now = Date.now();
   const TTL = 10 * 60 * 1e3;
@@ -966,6 +1152,20 @@ var MessageStreamer = class {
     }
   }
 };
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp"]);
+function extractImagePath(toolName, toolInput) {
+  try {
+    const data = JSON.parse(toolInput);
+    if (toolName === "Write" || toolName === "Read") {
+      const filePath = data.file_path;
+      if (filePath && IMAGE_EXTENSIONS.has(filePath.slice(filePath.lastIndexOf(".")).toLowerCase())) {
+        return filePath;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
 var USER_FACING_TOOLS = /* @__PURE__ */ new Set([
   "AskUserQuestion",
   "EnterPlanMode",
@@ -992,21 +1192,29 @@ function renderAskUserQuestion(toolInput, sessionId) {
     const data = JSON.parse(toolInput);
     const questions = data.questions;
     if (!questions?.length) return null;
+    const isMulti = questions.length > 1;
+    if (isMulti) {
+      clearPendingAnswers(sessionId);
+      questionCountStore.set(sessionId, questions.length);
+    }
     const embeds = [];
     const components = [];
-    for (const q of questions) {
+    const btnPrefix = isMulti ? "pick" : "answer";
+    const selectPrefix = isMulti ? "pick-select" : "answer-select";
+    for (let qi = 0; qi < questions.length; qi++) {
+      const q = questions[qi];
       const embed = new EmbedBuilder().setColor(15965202).setTitle(q.header || "Question").setDescription(q.question);
       if (q.options?.length) {
         if (q.options.length <= 4) {
           const row = new ActionRowBuilder();
           for (let i = 0; i < q.options.length; i++) {
             row.addComponents(
-              new ButtonBuilder().setCustomId(`answer:${sessionId}:${q.options[i].label}`).setLabel(q.options[i].label.slice(0, 80)).setStyle(i === 0 ? ButtonStyle.Primary : ButtonStyle.Secondary)
+              new ButtonBuilder().setCustomId(`${btnPrefix}:${sessionId}:${qi}:${q.options[i].label}`).setLabel(q.options[i].label.slice(0, 80)).setStyle(i === 0 ? ButtonStyle.Primary : ButtonStyle.Secondary)
             );
           }
           components.push(row);
         } else {
-          const menu = new StringSelectMenuBuilder().setCustomId(`answer-select:${sessionId}`).setPlaceholder("Select an option...");
+          const menu = new StringSelectMenuBuilder().setCustomId(`${selectPrefix}:${sessionId}:${qi}`).setPlaceholder("Select an option...");
           for (const opt of q.options) {
             menu.addOptions({
               label: opt.label.slice(0, 100),
@@ -1021,6 +1229,13 @@ function renderAskUserQuestion(toolInput, sessionId) {
       }
       embeds.push(embed);
     }
+    if (isMulti) {
+      components.push(
+        new ActionRowBuilder().addComponents(
+          new ButtonBuilder().setCustomId(`submit-answers:${sessionId}`).setLabel("Submit Answers").setStyle(ButtonStyle.Success)
+        )
+      );
+    }
     return { embeds, components };
   } catch {
     return null;
@@ -1061,6 +1276,7 @@ async function handleOutputStream(stream, channel, sessionId, verbose = false, m
   let currentToolName = null;
   let currentToolInput = "";
   let lastFinishedToolName = null;
+  let pendingImagePath = null;
   channel.sendTyping().catch(() => {
   });
   const typingInterval = setInterval(() => {
@@ -1122,6 +1338,7 @@ ${displayInput}
                 await channel.send({ embeds: [embed], components });
               }
             }
+            pendingImagePath = extractImagePath(currentToolName, currentToolInput);
             lastFinishedToolName = currentToolName;
             currentToolName = null;
             currentToolInput = "";
@@ -1129,6 +1346,17 @@ ${displayInput}
         }
       }
       if (message.type === "user") {
+        if (pendingImagePath && existsSync4(pendingImagePath)) {
+          try {
+            await streamer.finalize();
+            const attachment = new AttachmentBuilder(pendingImagePath);
+            await channel.send({ files: [attachment] });
+          } catch {
+          }
+          pendingImagePath = null;
+        } else {
+          pendingImagePath = null;
+        }
         const showResult = verbose || lastFinishedToolName !== null && TASK_TOOLS.has(lastFinishedToolName);
         if (!showResult) continue;
         await streamer.finalize();
@@ -1382,7 +1610,15 @@ async function handleClaude(interaction) {
 }
 async function handleClaudeNew(interaction) {
   const name = interaction.options.getString("name", true);
-  const directory = interaction.options.getString("directory") || config.defaultDirectory;
+  let directory = interaction.options.getString("directory");
+  if (!directory) {
+    const parentId = interaction.channel?.parentId;
+    if (parentId) {
+      const project = getProjectByCategoryId(parentId);
+      if (project) directory = project.directory;
+    }
+    directory = directory || config.defaultDirectory;
+  }
   await interaction.deferReply();
   let channel;
   try {
@@ -1424,7 +1660,7 @@ async function handleClaudeNew(interaction) {
   }
 }
 function discoverLocalSessions() {
-  const claudeDir = join3(homedir2(), ".claude", "projects");
+  const claudeDir = join4(homedir3(), ".claude", "projects");
   const results = [];
   let projectDirs;
   try {
@@ -1433,7 +1669,7 @@ function discoverLocalSessions() {
     return [];
   }
   for (const projDir of projectDirs) {
-    const projPath = join3(claudeDir, projDir);
+    const projPath = join4(claudeDir, projDir);
     let files;
     try {
       files = readdirSync(projPath);
@@ -1447,7 +1683,7 @@ function discoverLocalSessions() {
       const sessionId = file.replace(".jsonl", "");
       if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId)) continue;
       try {
-        const mtime = statSync(join3(projPath, file)).mtimeMs;
+        const mtime = statSync(join4(projPath, file)).mtimeMs;
         results.push({ id: sessionId, project, mtime, firstMessage: "" });
       } catch {
         continue;
@@ -1458,7 +1694,7 @@ function discoverLocalSessions() {
   return results;
 }
 async function getFirstUserMessage(sessionId) {
-  const claudeDir = join3(homedir2(), ".claude", "projects");
+  const claudeDir = join4(homedir3(), ".claude", "projects");
   let projectDirs;
   try {
     projectDirs = readdirSync(claudeDir);
@@ -1466,7 +1702,7 @@ async function getFirstUserMessage(sessionId) {
     return "";
   }
   for (const projDir of projectDirs) {
-    const filePath = join3(claudeDir, projDir, `${sessionId}.jsonl`);
+    const filePath = join4(claudeDir, projDir, `${sessionId}.jsonl`);
     try {
       statSync(filePath);
     } catch {
@@ -1986,9 +2222,377 @@ ${list}`, ephemeral: true });
     }
   }
 }
+async function handlePlugin(interaction) {
+  if (!isUserAllowed(interaction.user.id, config.allowedUsers, config.allowAllUsers)) {
+    await interaction.reply({ content: "You are not authorized.", ephemeral: true });
+    return;
+  }
+  const sub = interaction.options.getSubcommand();
+  switch (sub) {
+    case "browse":
+      return handlePluginBrowse(interaction);
+    case "install":
+      return handlePluginInstall(interaction);
+    case "remove":
+      return handlePluginRemove(interaction);
+    case "list":
+      return handlePluginList(interaction);
+    case "info":
+      return handlePluginInfo(interaction);
+    case "enable":
+      return handlePluginEnable(interaction);
+    case "disable":
+      return handlePluginDisable(interaction);
+    case "update":
+      return handlePluginUpdate(interaction);
+    case "marketplace-add":
+      return handleMarketplaceAdd(interaction);
+    case "marketplace-remove":
+      return handleMarketplaceRemove(interaction);
+    case "marketplace-list":
+      return handleMarketplaceList(interaction);
+    case "marketplace-update":
+      return handleMarketplaceUpdate(interaction);
+    default:
+      await interaction.reply({ content: `Unknown subcommand: ${sub}`, ephemeral: true });
+  }
+}
+function resolveScopeAndCwd(interaction) {
+  const scope = interaction.options.getString("scope") || "user";
+  if (scope === "user") return { scope };
+  const session = getSessionByChannel(interaction.channelId);
+  if (!session) {
+    return { scope, error: `Scope \`${scope}\` requires an active session. Run this from a session channel, or use \`user\` scope.` };
+  }
+  return { scope, cwd: session.directory };
+}
+async function handlePluginBrowse(interaction) {
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const search = interaction.options.getString("search")?.toLowerCase();
+    const { installed, available } = await listAvailable();
+    const installedIds = new Set(installed.map((p) => p.id));
+    let filtered = available;
+    if (search) {
+      filtered = available.filter((p) => p.name.toLowerCase().includes(search) || p.description.toLowerCase().includes(search) || p.marketplaceName.toLowerCase().includes(search));
+    }
+    filtered.sort((a, b) => (b.installCount ?? 0) - (a.installCount ?? 0));
+    if (filtered.length === 0) {
+      await interaction.editReply("No plugins found matching your search.");
+      return;
+    }
+    const shown = filtered.slice(0, 15);
+    const embed = new EmbedBuilder2().setColor(8141549).setTitle("Available Plugins").setDescription(`Showing ${shown.length} of ${filtered.length} plugins. Use \`/plugin install\` to install.`);
+    for (const p of shown) {
+      const status = installedIds.has(p.pluginId) ? " \u2705" : "";
+      const count = p.installCount ? ` | ${p.installCount.toLocaleString()} installs` : "";
+      embed.addFields({
+        name: `${p.name}${status}`,
+        value: `${truncate(p.description, 150)}
+*${p.marketplaceName}*${count}`
+      });
+    }
+    await interaction.editReply({ embeds: [embed] });
+  } catch (err) {
+    await interaction.editReply(`Error: ${err.message}`);
+  }
+}
+async function handlePluginInstall(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  const { scope, cwd, error } = resolveScopeAndCwd(interaction);
+  if (error) {
+    await interaction.reply({ content: error, ephemeral: true });
+    return;
+  }
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await installPlugin(pluginId, scope, cwd);
+    const embed = new EmbedBuilder2().setColor(3066993).setTitle("Plugin Installed").setDescription(`**${pluginId}** installed with \`${scope}\` scope.`).addFields({ name: "Output", value: truncate(result, 1e3) || "Done." });
+    await interaction.editReply({ embeds: [embed] });
+    log(`Plugin "${pluginId}" installed (scope=${scope}) by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to install: ${err.message}`);
+  }
+}
+async function handlePluginRemove(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  const { scope, cwd, error } = resolveScopeAndCwd(interaction);
+  if (error) {
+    await interaction.reply({ content: error, ephemeral: true });
+    return;
+  }
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await uninstallPlugin(pluginId, scope, cwd);
+    await interaction.editReply(`Plugin **${pluginId}** removed.
+${truncate(result, 500)}`);
+    log(`Plugin "${pluginId}" removed (scope=${scope}) by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to remove: ${err.message}`);
+  }
+}
+async function handlePluginList(interaction) {
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const plugins = await listInstalled();
+    if (plugins.length === 0) {
+      await interaction.editReply("No plugins installed.");
+      return;
+    }
+    const embed = new EmbedBuilder2().setColor(3447003).setTitle(`Installed Plugins (${plugins.length})`);
+    for (const p of plugins) {
+      const icon = p.enabled ? "\u2705" : "\u274C";
+      const scopeLabel = p.scope.charAt(0).toUpperCase() + p.scope.slice(1);
+      const project = p.projectPath ? `
+Project: \`${p.projectPath}\`` : "";
+      embed.addFields({
+        name: `${icon} ${p.id}`,
+        value: `v${p.version} | ${scopeLabel} scope${project}`
+      });
+    }
+    await interaction.editReply({ embeds: [embed] });
+  } catch (err) {
+    await interaction.editReply(`Error: ${err.message}`);
+  }
+}
+async function handlePluginInfo(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const parts = pluginId.split("@");
+    const pluginName = parts[0];
+    const marketplaceName = parts[1];
+    const installed = await listInstalled();
+    const installedEntry = installed.find((p) => p.id === pluginId);
+    let detail = null;
+    if (marketplaceName) {
+      detail = await getPluginDetail(pluginName, marketplaceName);
+    }
+    const embed = new EmbedBuilder2().setColor(15965202).setTitle(`Plugin: ${pluginName}`);
+    if (detail) {
+      embed.setDescription(detail.description);
+      if (detail.author) {
+        embed.addFields({ name: "Author", value: detail.author.name, inline: true });
+      }
+      if (detail.category) {
+        embed.addFields({ name: "Category", value: detail.category, inline: true });
+      }
+      if (detail.version) {
+        embed.addFields({ name: "Version", value: detail.version, inline: true });
+      }
+      if (detail.tags?.length) {
+        embed.addFields({ name: "Tags", value: detail.tags.join(", "), inline: false });
+      }
+      if (detail.homepage) {
+        embed.addFields({ name: "Homepage", value: detail.homepage, inline: false });
+      }
+      if (detail.lspServers) {
+        embed.addFields({ name: "LSP Servers", value: Object.keys(detail.lspServers).join(", "), inline: true });
+      }
+      if (detail.mcpServers) {
+        embed.addFields({ name: "MCP Servers", value: Object.keys(detail.mcpServers).join(", "), inline: true });
+      }
+    }
+    if (installedEntry) {
+      const icon = installedEntry.enabled ? "\u2705 Enabled" : "\u274C Disabled";
+      embed.addFields(
+        { name: "Status", value: `${icon} | v${installedEntry.version}`, inline: true },
+        { name: "Scope", value: installedEntry.scope, inline: true },
+        { name: "Installed", value: new Date(installedEntry.installedAt).toLocaleDateString(), inline: true }
+      );
+    } else {
+      embed.addFields({ name: "Status", value: "Not installed", inline: true });
+    }
+    if (marketplaceName) {
+      embed.setFooter({ text: `Marketplace: ${marketplaceName}` });
+    }
+    await interaction.editReply({ embeds: [embed] });
+  } catch (err) {
+    await interaction.editReply(`Error: ${err.message}`);
+  }
+}
+async function handlePluginEnable(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  const { scope, cwd, error } = resolveScopeAndCwd(interaction);
+  if (error) {
+    await interaction.reply({ content: error, ephemeral: true });
+    return;
+  }
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    await enablePlugin(pluginId, scope, cwd);
+    await interaction.editReply(`Plugin **${pluginId}** enabled (\`${scope}\` scope).`);
+    log(`Plugin "${pluginId}" enabled (scope=${scope}) by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to enable: ${err.message}`);
+  }
+}
+async function handlePluginDisable(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  const { scope, cwd, error } = resolveScopeAndCwd(interaction);
+  if (error) {
+    await interaction.reply({ content: error, ephemeral: true });
+    return;
+  }
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    await disablePlugin(pluginId, scope, cwd);
+    await interaction.editReply(`Plugin **${pluginId}** disabled (\`${scope}\` scope).`);
+    log(`Plugin "${pluginId}" disabled (scope=${scope}) by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to disable: ${err.message}`);
+  }
+}
+async function handlePluginUpdate(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  const { scope, cwd, error } = resolveScopeAndCwd(interaction);
+  if (error) {
+    await interaction.reply({ content: error, ephemeral: true });
+    return;
+  }
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await updatePlugin(pluginId, scope, cwd);
+    await interaction.editReply(`Plugin **${pluginId}** updated.
+${truncate(result, 500)}`);
+    log(`Plugin "${pluginId}" updated (scope=${scope}) by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to update: ${err.message}`);
+  }
+}
+async function handleMarketplaceAdd(interaction) {
+  const source = interaction.options.getString("source", true);
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await addMarketplace(source);
+    await interaction.editReply(`Marketplace added from \`${source}\`.
+${truncate(result, 500)}`);
+    log(`Marketplace "${source}" added by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to add marketplace: ${err.message}`);
+  }
+}
+async function handleMarketplaceRemove(interaction) {
+  const name = interaction.options.getString("name", true);
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await removeMarketplace(name);
+    await interaction.editReply(`Marketplace **${name}** removed.
+${truncate(result, 500)}`);
+    log(`Marketplace "${name}" removed by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to remove marketplace: ${err.message}`);
+  }
+}
+async function handleMarketplaceList(interaction) {
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const marketplaces = await listMarketplaces();
+    if (marketplaces.length === 0) {
+      await interaction.editReply("No marketplaces registered.");
+      return;
+    }
+    const embed = new EmbedBuilder2().setColor(10181046).setTitle(`Marketplaces (${marketplaces.length})`);
+    for (const m of marketplaces) {
+      const source = m.repo || m.url || m.source;
+      embed.addFields({
+        name: m.name,
+        value: `Source: \`${source}\`
+Path: \`${m.installLocation}\``
+      });
+    }
+    await interaction.editReply({ embeds: [embed] });
+  } catch (err) {
+    await interaction.editReply(`Error: ${err.message}`);
+  }
+}
+async function handleMarketplaceUpdate(interaction) {
+  const name = interaction.options.getString("name") || void 0;
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await updateMarketplaces(name);
+    await interaction.editReply(`Marketplace${name ? ` **${name}**` : "s"} updated.
+${truncate(result, 500)}`);
+    log(`Marketplace${name ? ` "${name}"` : "s"} updated by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to update: ${err.message}`);
+  }
+}
+async function handlePluginAutocomplete(interaction) {
+  const sub = interaction.options.getSubcommand();
+  const focused = interaction.options.getFocused().toLowerCase();
+  try {
+    if (sub === "install" || sub === "info" && !focused.includes("@")) {
+      const { available } = await listAvailable();
+      const filtered = focused ? available.filter((p) => p.name.toLowerCase().includes(focused) || p.pluginId.toLowerCase().includes(focused) || p.description.toLowerCase().includes(focused)) : available;
+      filtered.sort((a, b) => (b.installCount ?? 0) - (a.installCount ?? 0));
+      const choices = filtered.slice(0, 25).map((p) => ({
+        name: `${p.name} (${p.marketplaceName})`.slice(0, 100),
+        value: p.pluginId
+      }));
+      await interaction.respond(choices);
+    } else if (["remove", "enable", "disable", "update", "info"].includes(sub)) {
+      const installed = await listInstalled();
+      const filtered = focused ? installed.filter((p) => p.id.toLowerCase().includes(focused)) : installed;
+      const choices = filtered.slice(0, 25).map((p) => ({
+        name: `${p.id} (v${p.version}, ${p.scope})`.slice(0, 100),
+        value: p.id
+      }));
+      await interaction.respond(choices);
+    } else if (sub === "marketplace-remove" || sub === "marketplace-update") {
+      const marketplaces = await listMarketplaces();
+      const filtered = focused ? marketplaces.filter((m) => m.name.toLowerCase().includes(focused)) : marketplaces;
+      const choices = filtered.slice(0, 25).map((m) => ({
+        name: m.name,
+        value: m.name
+      }));
+      await interaction.respond(choices);
+    } else {
+      await interaction.respond([]);
+    }
+  } catch {
+    await interaction.respond([]);
+  }
+}
 
 // src/message-handler.ts
+import sharp from "sharp";
+var SUPPORTED_IMAGE_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+var MAX_IMAGE_SIZE = 20 * 1024 * 1024;
+var MAX_BASE64_BYTES = 5 * 1024 * 1024;
 var userLastMessage = /* @__PURE__ */ new Map();
+async function resizeImageToFit(buf, mediaType) {
+  if (buf.length <= MAX_BASE64_BYTES) return buf;
+  const isJpeg = mediaType === "image/jpeg";
+  const format = isJpeg ? "jpeg" : "webp";
+  let img = sharp(buf);
+  const meta = await img.metadata();
+  const width = meta.width || 1;
+  const height = meta.height || 1;
+  let scale = 1;
+  for (let i = 0; i < 5; i++) {
+    scale *= 0.7;
+    const resized = await sharp(buf).resize(Math.round(width * scale), Math.round(height * scale), { fit: "inside" })[format]({ quality: 80 }).toBuffer();
+    if (resized.length <= MAX_BASE64_BYTES) return resized;
+  }
+  return sharp(buf).resize(Math.round(width * scale * 0.5), Math.round(height * scale * 0.5), { fit: "inside" }).jpeg({ quality: 60 }).toBuffer();
+}
+async function fetchImageAsBase64(url, mediaType) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to download image: ${res.status}`);
+  let buf = Buffer.from(await res.arrayBuffer());
+  if (buf.length > MAX_BASE64_BYTES) {
+    buf = await resizeImageToFit(buf, mediaType);
+    const newType = mediaType === "image/jpeg" ? "image/jpeg" : "image/webp";
+    return { data: buf.toString("base64"), mediaType: newType };
+  }
+  return { data: buf.toString("base64"), mediaType };
+}
 async function handleMessage(message) {
   if (message.author.bot) return;
   const session = getSessionByChannel(message.channelId);
@@ -2017,11 +2621,41 @@ async function handleMessage(message) {
       return;
     }
   }
-  const content = message.content.trim();
-  if (!content) return;
+  const text = message.content.trim();
+  const imageAttachments = message.attachments.filter(
+    (a) => a.contentType && SUPPORTED_IMAGE_TYPES.has(a.contentType) && a.size <= MAX_IMAGE_SIZE
+  );
+  if (!text && imageAttachments.size === 0) return;
   try {
     const channel = message.channel;
-    const stream = sendPrompt(session.id, content);
+    let prompt;
+    if (imageAttachments.size === 0) {
+      prompt = text;
+    } else {
+      const blocks = [];
+      const imageResults = await Promise.allSettled(
+        imageAttachments.map((a) => fetchImageAsBase64(a.url, a.contentType))
+      );
+      for (const result of imageResults) {
+        if (result.status === "fulfilled") {
+          blocks.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: result.value.mediaType,
+              data: result.value.data
+            }
+          });
+        }
+      }
+      if (text) {
+        blocks.push({ type: "text", text });
+      } else if (blocks.length > 0) {
+        blocks.push({ type: "text", text: "What is in this image?" });
+      }
+      prompt = blocks;
+    }
+    const stream = sendPrompt(session.id, prompt);
     await handleOutputStream(stream, channel, session.id, session.verbose, session.mode);
   } catch (err) {
     await message.reply({
@@ -2032,6 +2666,12 @@ async function handleMessage(message) {
 }
 
 // src/button-handler.ts
+import {
+  ActionRowBuilder as ActionRowBuilder2,
+  ButtonBuilder as ButtonBuilder2,
+  ButtonStyle as ButtonStyle2,
+  StringSelectMenuBuilder as StringSelectMenuBuilder2
+} from "discord.js";
 async function handleButton(interaction) {
   if (!isUserAllowed(interaction.user.id, config.allowedUsers, config.allowAllUsers)) {
     await interaction.reply({ content: "Not authorized.", ephemeral: true });
@@ -2103,10 +2743,83 @@ ${display}
     }
     return;
   }
+  if (customId.startsWith("pick:")) {
+    const parts = customId.split(":");
+    const sessionId = parts[1];
+    const questionIndex = parseInt(parts[2], 10);
+    const answer = parts.slice(3).join(":");
+    const session = getSession(sessionId);
+    if (!session) {
+      await interaction.reply({ content: "Session not found.", ephemeral: true });
+      return;
+    }
+    setPendingAnswer(sessionId, questionIndex, answer);
+    const totalQuestions = getQuestionCount(sessionId);
+    const pending = getPendingAnswers(sessionId);
+    const answeredCount = pending?.size || 0;
+    try {
+      const original = interaction.message;
+      const updatedComponents = original.components.map((row) => {
+        const firstComponent = row.components?.[0];
+        if (!firstComponent?.customId?.startsWith("pick:")) return row;
+        const rowQi = parseInt(firstComponent.customId.split(":")[2], 10);
+        if (rowQi !== questionIndex) return row;
+        const newRow = new ActionRowBuilder2();
+        for (const btn of row.components) {
+          const btnAnswer = btn.customId.split(":").slice(3).join(":");
+          const isSelected = btnAnswer === answer;
+          newRow.addComponents(
+            new ButtonBuilder2().setCustomId(btn.customId).setLabel(btn.label).setStyle(isSelected ? ButtonStyle2.Success : ButtonStyle2.Secondary)
+          );
+        }
+        return newRow;
+      });
+      await original.edit({ components: updatedComponents });
+    } catch {
+    }
+    await interaction.reply({
+      content: `Selected for Q${questionIndex + 1}: **${truncate(answer, 100)}** (${answeredCount}/${totalQuestions} answered)`,
+      ephemeral: true
+    });
+    return;
+  }
+  if (customId.startsWith("submit-answers:")) {
+    const sessionId = customId.slice(15);
+    const session = getSession(sessionId);
+    if (!session) {
+      await interaction.reply({ content: "Session not found.", ephemeral: true });
+      return;
+    }
+    const totalQuestions = getQuestionCount(sessionId);
+    const pending = getPendingAnswers(sessionId);
+    if (!pending || pending.size === 0) {
+      await interaction.reply({ content: "No answers selected yet. Pick an answer for each question first.", ephemeral: true });
+      return;
+    }
+    const answerLines = [];
+    for (let i = 0; i < totalQuestions; i++) {
+      const ans = pending.get(i);
+      answerLines.push(`Q${i + 1}: ${ans || "(no answer)"}`);
+    }
+    const combined = answerLines.join("\n");
+    clearPendingAnswers(sessionId);
+    await interaction.deferReply();
+    try {
+      const channel = interaction.channel;
+      const stream = sendPrompt(sessionId, combined);
+      await interaction.editReply(`Submitted answers:
+${combined}`);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode);
+    } catch (err) {
+      await interaction.editReply(`Error: ${err.message}`);
+    }
+    return;
+  }
   if (customId.startsWith("answer:")) {
     const parts = customId.split(":");
     const sessionId = parts[1];
-    const answer = parts.slice(2).join(":");
+    const hasQuestionIndex = /^\d+$/.test(parts[2]);
+    const answer = hasQuestionIndex ? parts.slice(3).join(":") : parts.slice(2).join(":");
     const session = getSession(sessionId);
     if (!session) {
       await interaction.reply({ content: "Session not found.", ephemeral: true });
@@ -2184,8 +2897,48 @@ async function handleSelectMenu(interaction) {
     return;
   }
   const customId = interaction.customId;
+  if (customId.startsWith("pick-select:")) {
+    const parts = customId.split(":");
+    const sessionId = parts[1];
+    const questionIndex = parseInt(parts[2], 10);
+    const selected = interaction.values[0];
+    const session = getSession(sessionId);
+    if (!session) {
+      await interaction.reply({ content: "Session not found.", ephemeral: true });
+      return;
+    }
+    setPendingAnswer(sessionId, questionIndex, selected);
+    const totalQuestions = getQuestionCount(sessionId);
+    const pending = getPendingAnswers(sessionId);
+    const answeredCount = pending?.size || 0;
+    try {
+      const original = interaction.message;
+      const updatedComponents = original.components.map((row) => {
+        const comp = row.components?.[0];
+        if (comp?.customId !== customId) return row;
+        const menu = new StringSelectMenuBuilder2().setCustomId(customId).setPlaceholder(`Selected: ${selected.slice(0, 80)}`);
+        for (const opt of comp.options) {
+          menu.addOptions({
+            label: opt.label,
+            description: opt.description || void 0,
+            value: opt.value,
+            default: opt.value === selected
+          });
+        }
+        return new ActionRowBuilder2().addComponents(menu);
+      });
+      await original.edit({ components: updatedComponents });
+    } catch {
+    }
+    await interaction.reply({
+      content: `Selected for Q${questionIndex + 1}: **${truncate(selected, 100)}** (${answeredCount}/${totalQuestions} answered)`,
+      ephemeral: true
+    });
+    return;
+  }
   if (customId.startsWith("answer-select:")) {
-    const sessionId = customId.slice(14);
+    const afterPrefix = customId.slice(14);
+    const sessionId = afterPrefix.includes(":") ? afterPrefix.split(":")[0] : afterPrefix;
     const selected = interaction.values[0];
     const session = getSession(sessionId);
     if (!session) {
@@ -2301,12 +3054,17 @@ async function startBot() {
             return await handleAgent(interaction);
           case "project":
             return await handleProject(interaction);
+          case "plugin":
+            return await handlePlugin(interaction);
         }
       }
       if (interaction.isAutocomplete()) {
         if (interaction.commandName === "claude") {
           return await handleClaudeAutocomplete(interaction);
         }
+        if (interaction.commandName === "plugin") {
+          return await handlePluginAutocomplete(interaction);
+        }
       }
       if (interaction.isButton()) {
         return await handleButton(interaction);

package/dist/cli.js

@@ -18,7 +18,7 @@ switch (command) {
       console.log("Run \x1B[36magentcord setup\x1B[0m to configure.\n");
       process.exit(1);
     }
-    const { startBot } = await import("./bot-G6464LRS.js");
+    const { startBot } = await import("./bot-MUOL7CRV.js");
     console.log("agentcord starting...");
     await startBot();
     break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentcord",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "type": "module",
   "description": "Discord bot for managing AI coding agent sessions (Claude Code, Codex, and more)",
   "bin": {
@@ -50,7 +50,8 @@
     "@anthropic-ai/claude-agent-sdk": "^0.2.36",
     "@clack/prompts": "^1.0.0",
     "discord.js": "^14.16.3",
-    "dotenv": "^17.2.4"
+    "dotenv": "^17.2.4",
+    "sharp": "^0.34.5"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",