@robota-sdk/agent-cli 3.0.0-beta.24 → 3.0.0-beta.25

package/dist/node/bin.cjs

@@ -25,10 +25,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/cli.ts
 var import_node_fs3 = require("fs");
-var import_node_path3 = require("path");
+var import_node_path5 = require("path");
 var import_node_url = require("url");
-var import_agent_sdk2 = require("@robota-sdk/agent-sdk");
-var import_agent_sdk3 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk4 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk5 = require("@robota-sdk/agent-sdk");
 
 // src/utils/cli-args.ts
 var import_node_util = require("util");
@@ -166,7 +166,7 @@ var PrintTerminal = class {
 var import_ink11 = require("ink");
 
 // src/ui/App.tsx
-var import_react11 = require("react");
+var import_react12 = require("react");
 var import_ink10 = require("ink");
 var import_agent_core3 = require("@robota-sdk/agent-core");
 
@@ -386,7 +386,122 @@ function handleReset(addMessage) {
   }
   return { handled: true, exitRequested: true };
 }
-async function executeSlashCommand(cmd, args, session, addMessage, clearMessages, registry) {
+async function handlePluginCommand(args, addMessage, callbacks) {
+  const parts = args.trim().split(/\s+/);
+  const subcommand = parts[0] ?? "";
+  const subArgs = parts.slice(1).join(" ").trim();
+  try {
+    switch (subcommand) {
+      case "":
+      case void 0: {
+        const plugins = await callbacks.listInstalled();
+        if (plugins.length === 0) {
+          addMessage({ role: "system", content: "No plugins installed." });
+        } else {
+          const lines = plugins.map(
+            (p) => `  ${p.name} \u2014 ${p.description} [${p.enabled ? "enabled" : "disabled"}]`
+          );
+          addMessage({ role: "system", content: `Installed plugins:
+${lines.join("\n")}` });
+        }
+        return { handled: true };
+      }
+      case "install": {
+        if (!subArgs) {
+          addMessage({ role: "system", content: "Usage: /plugin install <name>@<marketplace>" });
+          return { handled: true };
+        }
+        await callbacks.install(subArgs);
+        addMessage({ role: "system", content: `Installed plugin: ${subArgs}` });
+        return { handled: true };
+      }
+      case "uninstall": {
+        if (!subArgs) {
+          addMessage({ role: "system", content: "Usage: /plugin uninstall <name>@<marketplace>" });
+          return { handled: true };
+        }
+        await callbacks.uninstall(subArgs);
+        addMessage({ role: "system", content: `Uninstalled plugin: ${subArgs}` });
+        return { handled: true };
+      }
+      case "enable": {
+        if (!subArgs) {
+          addMessage({ role: "system", content: "Usage: /plugin enable <name>@<marketplace>" });
+          return { handled: true };
+        }
+        await callbacks.enable(subArgs);
+        addMessage({ role: "system", content: `Enabled plugin: ${subArgs}` });
+        return { handled: true };
+      }
+      case "disable": {
+        if (!subArgs) {
+          addMessage({ role: "system", content: "Usage: /plugin disable <name>@<marketplace>" });
+          return { handled: true };
+        }
+        await callbacks.disable(subArgs);
+        addMessage({ role: "system", content: `Disabled plugin: ${subArgs}` });
+        return { handled: true };
+      }
+      case "marketplace": {
+        const mpParts = subArgs.split(/\s+/);
+        const mpSubcommand = mpParts[0] ?? "";
+        const mpArgs = mpParts.slice(1).join(" ").trim();
+        if (mpSubcommand === "add" && mpArgs) {
+          const registeredName = await callbacks.marketplaceAdd(mpArgs);
+          addMessage({
+            role: "system",
+            content: `Added marketplace: "${registeredName}" (from ${mpArgs})
+Install plugins with: /plugin install <name>@${registeredName}`
+          });
+          return { handled: true };
+        } else if (mpSubcommand === "remove" && mpArgs) {
+          await callbacks.marketplaceRemove(mpArgs);
+          addMessage({
+            role: "system",
+            content: `Removed marketplace "${mpArgs}" and uninstalled its plugins.`
+          });
+          return { handled: true };
+        } else if (mpSubcommand === "update" && mpArgs) {
+          await callbacks.marketplaceUpdate(mpArgs);
+          addMessage({
+            role: "system",
+            content: `Updated marketplace "${mpArgs}".`
+          });
+          return { handled: true };
+        } else if (mpSubcommand === "list") {
+          const sources = await callbacks.marketplaceList();
+          if (sources.length === 0) {
+            addMessage({ role: "system", content: "No marketplace sources configured." });
+          } else {
+            const lines = sources.map((s) => `  ${s.name} (${s.type})`);
+            addMessage({ role: "system", content: `Marketplace sources:
+${lines.join("\n")}` });
+          }
+          return { handled: true };
+        } else {
+          addMessage({
+            role: "system",
+            content: "Usage: /plugin marketplace add <source> | remove <name> | update <name> | list"
+          });
+          return { handled: true };
+        }
+      }
+      default:
+        addMessage({ role: "system", content: `Unknown plugin subcommand: ${subcommand}` });
+        return { handled: true };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    addMessage({ role: "system", content: `Plugin error: ${message}` });
+    return { handled: true };
+  }
+}
+async function handleReloadPlugins(addMessage, callbacks) {
+  await callbacks.reloadPlugins();
+  addMessage({ role: "system", content: "Plugins reload complete." });
+  return { handled: true };
+}
+async function executeSlashCommand(cmd, args, session, addMessage, clearMessages, registry, pluginCallbacks) {
   switch (cmd) {
     case "help":
       return handleHelp(addMessage);
@@ -410,10 +525,22 @@ async function executeSlashCommand(cmd, args, session, addMessage, clearMessages
       return handleReset(addMessage);
     case "exit":
       return { handled: true, exitRequested: true };
+    case "plugin":
+      if (pluginCallbacks) {
+        return handlePluginCommand(args, addMessage, pluginCallbacks);
+      }
+      addMessage({ role: "system", content: "Plugin management is not available." });
+      return { handled: true };
+    case "reload-plugins":
+      if (pluginCallbacks) {
+        return handleReloadPlugins(addMessage, pluginCallbacks);
+      }
+      addMessage({ role: "system", content: "Plugin management is not available." });
+      return { handled: true };
     default: {
-      const skillCmd = registry.getCommands().find((c) => c.name === cmd && c.source === "skill");
-      if (skillCmd) {
-        addMessage({ role: "system", content: `Invoking skill: ${cmd}` });
+      const dynamicCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
+      if (dynamicCmd) {
+        addMessage({ role: "system", content: `Invoking ${dynamicCmd.source}: ${cmd}` });
         return { handled: false };
       }
       addMessage({ role: "system", content: `Unknown command "/${cmd}". Type /help for help.` });
@@ -424,14 +551,22 @@ async function executeSlashCommand(cmd, args, session, addMessage, clearMessages
 
 // src/ui/hooks/useSlashCommands.ts
 var EXIT_DELAY_MS = 500;
-function useSlashCommands(session, addMessage, setMessages, exit, registry, pendingModelChangeRef, setPendingModelId) {
+function useSlashCommands(session, addMessage, setMessages, exit, registry, pendingModelChangeRef, setPendingModelId, pluginCallbacks) {
   return (0, import_react3.useCallback)(
     async (input) => {
       const parts = input.slice(1).split(/\s+/);
       const cmd = parts[0]?.toLowerCase() ?? "";
       const args = parts.slice(1).join(" ");
       const clearMessages = () => setMessages([]);
-      const result = await executeSlashCommand(cmd, args, session, addMessage, clearMessages, registry);
+      const result = await executeSlashCommand(
+        cmd,
+        args,
+        session,
+        addMessage,
+        clearMessages,
+        registry,
+        pluginCallbacks
+      );
       if (result.pendingModelId) {
         pendingModelChangeRef.current = result.pendingModelId;
         setPendingModelId(result.pendingModelId);
@@ -441,7 +576,16 @@ function useSlashCommands(session, addMessage, setMessages, exit, registry, pend
       }
       return result.handled;
     },
-    [session, addMessage, setMessages, exit, registry, pendingModelChangeRef, setPendingModelId]
+    [
+      session,
+      addMessage,
+      setMessages,
+      exit,
+      registry,
+      pendingModelChangeRef,
+      setPendingModelId,
+      pluginCallbacks
+    ]
   );
 }
 
@@ -476,16 +620,60 @@ function parseFirstArgValue(argsJson) {
 }
 
 // src/utils/skill-prompt.ts
-function buildSkillPrompt(input, registry) {
+var import_node_child_process = require("child_process");
+function substituteVariables(content, args, context) {
+  const argParts = args ? args.split(/\s+/) : [];
+  let result = content;
+  result = result.replace(/\$ARGUMENTS\[(\d+)]/g, (_match, index) => {
+    return argParts[Number(index)] ?? "";
+  });
+  result = result.replace(/\$ARGUMENTS/g, args);
+  result = result.replace(/\$(\d)(?!\d|\w|\[)/g, (_match, digit) => {
+    return argParts[Number(digit)] ?? "";
+  });
+  result = result.replace(/\$\{CLAUDE_SESSION_ID}/g, context?.sessionId ?? "");
+  result = result.replace(/\$\{CLAUDE_SKILL_DIR}/g, context?.skillDir ?? "");
+  return result;
+}
+async function preprocessShellCommands(content) {
+  const shellPattern = /!`([^`]+)`/g;
+  if (!shellPattern.test(content)) {
+    return content;
+  }
+  shellPattern.lastIndex = 0;
+  let result = content;
+  let match;
+  const matches = [];
+  while ((match = shellPattern.exec(content)) !== null) {
+    matches.push({ full: match[0], command: match[1] });
+  }
+  for (const { full, command } of matches) {
+    let output = "";
+    try {
+      output = (0, import_node_child_process.execSync)(command, {
+        timeout: 5e3,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trimEnd();
+    } catch {
+      output = "";
+    }
+    result = result.replace(full, output);
+  }
+  return result;
+}
+async function buildSkillPrompt(input, registry, context) {
   const parts = input.slice(1).split(/\s+/);
   const cmd = parts[0]?.toLowerCase() ?? "";
-  const skillCmd = registry.getCommands().find((c) => c.name === cmd && c.source === "skill");
+  const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
   if (!skillCmd) return null;
   const args = parts.slice(1).join(" ").trim();
   const userInstruction = args || skillCmd.description;
   if (skillCmd.skillContent) {
+    let processed = await preprocessShellCommands(skillCmd.skillContent);
+    processed = substituteVariables(processed, args, context);
     return `<skill name="${cmd}">
-${skillCmd.skillContent}
+${processed}
 </skill>
 
 Execute the "${cmd}" skill: ${userInstruction}`;
@@ -498,12 +686,12 @@ function syncContextState(session, setter) {
   const ctx = session.getContextState();
   setter({ percentage: ctx.usedPercentage, usedTokens: ctx.usedTokens, maxTokens: ctx.maxTokens });
 }
-async function runSessionPrompt(prompt, session, addMessage, clearStreamingText, setIsThinking, setContextState) {
+async function runSessionPrompt(prompt, session, addMessage, clearStreamingText, setIsThinking, setContextState, rawInput) {
   setIsThinking(true);
   clearStreamingText();
   const historyBefore = session.getHistory().length;
   try {
-    const response = await session.run(prompt);
+    const response = await session.run(prompt, rawInput);
     clearStreamingText();
     const history = session.getHistory();
     const toolLines = extractToolCalls(
@@ -511,7 +699,11 @@ async function runSessionPrompt(prompt, session, addMessage, clearStreamingText,
       historyBefore
     );
     if (toolLines.length > 0) {
-      addMessage({ role: "tool", content: toolLines.join("\n"), toolName: `${toolLines.length} tools` });
+      addMessage({
+        role: "tool",
+        content: toolLines.join("\n"),
+        toolName: `${toolLines.length} tools`
+      });
     }
     addMessage({ role: "assistant", content: response || "(empty response)" });
     syncContextState(session, setContextState);
@@ -536,19 +728,45 @@ function useSubmitHandler(session, addMessage, handleSlashCommand, clearStreamin
           syncContextState(session, setContextState);
           return;
         }
-        const prompt = buildSkillPrompt(input, registry);
+        const prompt = await buildSkillPrompt(input, registry);
         if (!prompt) return;
-        return runSessionPrompt(prompt, session, addMessage, clearStreamingText, setIsThinking, setContextState);
+        return runSessionPrompt(
+          prompt,
+          session,
+          addMessage,
+          clearStreamingText,
+          setIsThinking,
+          setContextState,
+          input
+        );
       }
       addMessage({ role: "user", content: input });
-      return runSessionPrompt(input, session, addMessage, clearStreamingText, setIsThinking, setContextState);
+      return runSessionPrompt(
+        input,
+        session,
+        addMessage,
+        clearStreamingText,
+        setIsThinking,
+        setContextState
+      );
     },
-    [session, addMessage, handleSlashCommand, clearStreamingText, setIsThinking, setContextState, registry]
+    [
+      session,
+      addMessage,
+      handleSlashCommand,
+      clearStreamingText,
+      setIsThinking,
+      setContextState,
+      registry
+    ]
   );
 }
 
 // src/ui/hooks/useCommandRegistry.ts
 var import_react5 = require("react");
+var import_node_os2 = require("os");
+var import_node_path3 = require("path");
+var import_agent_sdk2 = require("@robota-sdk/agent-sdk");
 
 // src/commands/command-registry.ts
 var CommandRegistry = class {
@@ -632,6 +850,23 @@ function createBuiltinCommands() {
     { name: "cost", description: "Show session info", source: "builtin" },
     { name: "context", description: "Context window info", source: "builtin" },
     { name: "permissions", description: "Permission rules", source: "builtin" },
+    {
+      name: "plugin",
+      description: "Manage plugins",
+      source: "builtin",
+      subcommands: [
+        { name: "install", description: "Install a plugin (name@marketplace)", source: "builtin" },
+        {
+          name: "uninstall",
+          description: "Uninstall a plugin (name@marketplace)",
+          source: "builtin"
+        },
+        { name: "enable", description: "Enable a plugin (name@marketplace)", source: "builtin" },
+        { name: "disable", description: "Disable a plugin (name@marketplace)", source: "builtin" },
+        { name: "marketplace", description: "Manage marketplace sources", source: "builtin" }
+      ]
+    },
+    { name: "reload-plugins", description: "Reload all plugin resources", source: "builtin" },
     { name: "reset", description: "Delete settings and exit", source: "builtin" },
     { name: "exit", description: "Exit CLI", source: "builtin" }
   ];
@@ -651,25 +886,50 @@ var BuiltinCommandSource = class {
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
 var import_node_os = require("os");
+var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
+var LIST_KEYS = /* @__PURE__ */ new Set(["allowed-tools"]);
+function kebabToCamel(key) {
+  return key.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
 function parseFrontmatter(content) {
   const lines = content.split("\n");
   if (lines[0]?.trim() !== "---") return null;
-  let name = "";
-  let description = "";
+  const result = {};
   for (let i = 1; i < lines.length; i++) {
     const line = lines[i];
     if (line.trim() === "---") break;
-    const nameMatch = line.match(/^name:\s*(.+)/);
-    if (nameMatch) {
-      name = nameMatch[1].trim();
-      continue;
-    }
-    const descMatch = line.match(/^description:\s*(.+)/);
-    if (descMatch) {
-      description = descMatch[1].trim();
+    const match = line.match(/^([a-z][a-z0-9-]*):\s*(.+)/);
+    if (!match) continue;
+    const key = match[1];
+    const rawValue = match[2].trim();
+    const camelKey = kebabToCamel(key);
+    if (BOOLEAN_KEYS.has(key)) {
+      result[camelKey] = rawValue === "true";
+    } else if (LIST_KEYS.has(key)) {
+      result[camelKey] = rawValue.split(",").map((s) => s.trim());
+    } else {
+      result[camelKey] = rawValue;
     }
   }
-  return name ? { name, description } : null;
+  return Object.keys(result).length > 0 ? result : null;
+}
+function buildCommand(frontmatter, content, fallbackName) {
+  const cmd = {
+    name: frontmatter?.name ?? fallbackName,
+    description: frontmatter?.description ?? `Skill: ${fallbackName}`,
+    source: "skill",
+    skillContent: content
+  };
+  if (frontmatter?.argumentHint !== void 0) cmd.argumentHint = frontmatter.argumentHint;
+  if (frontmatter?.disableModelInvocation !== void 0)
+    cmd.disableModelInvocation = frontmatter.disableModelInvocation;
+  if (frontmatter?.userInvocable !== void 0) cmd.userInvocable = frontmatter.userInvocable;
+  if (frontmatter?.allowedTools !== void 0) cmd.allowedTools = frontmatter.allowedTools;
+  if (frontmatter?.model !== void 0) cmd.model = frontmatter.model;
+  if (frontmatter?.effort !== void 0) cmd.effort = frontmatter.effort;
+  if (frontmatter?.context !== void 0) cmd.context = frontmatter.context;
+  if (frontmatter?.agent !== void 0) cmd.agent = frontmatter.agent;
+  return cmd;
 }
 function scanSkillsDir(skillsDir) {
   if (!(0, import_node_fs2.existsSync)(skillsDir)) return [];
@@ -681,48 +941,246 @@ function scanSkillsDir(skillsDir) {
     if (!(0, import_node_fs2.existsSync)(skillFile)) continue;
     const content = (0, import_node_fs2.readFileSync)(skillFile, "utf-8");
     const frontmatter = parseFrontmatter(content);
-    commands.push({
-      name: frontmatter?.name ?? entry.name,
-      description: frontmatter?.description ?? `Skill: ${entry.name}`,
-      source: "skill",
-      skillContent: content
-    });
+    commands.push(buildCommand(frontmatter, content, entry.name));
+  }
+  return commands;
+}
+function scanCommandsDir(commandsDir) {
+  if (!(0, import_node_fs2.existsSync)(commandsDir)) return [];
+  const commands = [];
+  const entries = (0, import_node_fs2.readdirSync)(commandsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filePath = (0, import_node_path2.join)(commandsDir, entry.name);
+    const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+    const frontmatter = parseFrontmatter(content);
+    const fallbackName = (0, import_node_path2.basename)(entry.name, ".md");
+    commands.push(buildCommand(frontmatter, content, fallbackName));
   }
   return commands;
 }
 var SkillCommandSource = class {
   name = "skill";
   cwd;
+  home;
   cachedCommands = null;
-  constructor(cwd) {
+  constructor(cwd, home) {
     this.cwd = cwd;
+    this.home = home ?? (0, import_node_os.homedir)();
   }
   getCommands() {
     if (this.cachedCommands) return this.cachedCommands;
-    const projectSkills = scanSkillsDir((0, import_node_path2.join)(this.cwd, ".agents", "skills"));
-    const userSkills = scanSkillsDir((0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "skills"));
-    const seen = new Set(projectSkills.map((cmd) => cmd.name));
-    const merged = [...projectSkills];
-    for (const cmd of userSkills) {
-      if (!seen.has(cmd.name)) {
-        merged.push(cmd);
+    const sources = [
+      scanSkillsDir((0, import_node_path2.join)(this.cwd, ".claude", "skills")),
+      // 1. project .claude/skills
+      scanCommandsDir((0, import_node_path2.join)(this.cwd, ".claude", "commands")),
+      // 2. project .claude/commands (legacy)
+      scanSkillsDir((0, import_node_path2.join)(this.home, ".robota", "skills")),
+      // 3. user ~/.robota/skills
+      scanSkillsDir((0, import_node_path2.join)(this.cwd, ".agents", "skills"))
+      // 4. project .agents/skills
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const commands of sources) {
+      for (const cmd of commands) {
+        if (!seen.has(cmd.name)) {
+          seen.add(cmd.name);
+          merged.push(cmd);
+        }
       }
     }
     this.cachedCommands = merged;
     return this.cachedCommands;
   }
+  /** Get skills that models can invoke (excludes disableModelInvocation: true) */
+  getModelInvocableSkills() {
+    return this.getCommands().filter((cmd) => cmd.disableModelInvocation !== true);
+  }
+  /** Get skills that users can invoke (excludes userInvocable: false) */
+  getUserInvocableSkills() {
+    return this.getCommands().filter((cmd) => cmd.userInvocable !== false);
+  }
+};
+
+// src/commands/plugin-source.ts
+var PluginCommandSource = class {
+  name = "plugin";
+  plugins;
+  constructor(plugins) {
+    this.plugins = plugins;
+  }
+  getCommands() {
+    const commands = [];
+    for (const plugin of this.plugins) {
+      for (const skill of plugin.skills) {
+        const baseName = skill.name.includes("@") ? skill.name.split("@")[0] : skill.name;
+        commands.push({
+          name: baseName,
+          description: `${skill.description} (${plugin.manifest.name})`,
+          source: "plugin",
+          skillContent: skill.skillContent,
+          pluginDir: plugin.pluginDir
+        });
+      }
+      for (const cmd of plugin.commands) {
+        commands.push({
+          name: cmd.name,
+          description: cmd.description,
+          source: "plugin",
+          skillContent: cmd.skillContent,
+          pluginDir: plugin.pluginDir
+        });
+      }
+    }
+    return commands;
+  }
 };
 
 // src/ui/hooks/useCommandRegistry.ts
+function buildPluginEnv(plugin) {
+  const dataDir = (0, import_node_path3.join)((0, import_node_path3.dirname)((0, import_node_path3.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
+  return {
+    CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
+    CLAUDE_PLUGIN_PATH: plugin.pluginDir,
+    CLAUDE_PLUGIN_DATA: dataDir
+  };
+}
+function mergePluginHooks(plugins) {
+  const merged = {};
+  for (const plugin of plugins) {
+    const hooksObj = plugin.hooks;
+    if (!hooksObj) continue;
+    const pluginEnv = buildPluginEnv(plugin);
+    const innerHooks = hooksObj.hooks ?? hooksObj;
+    for (const [event, groups] of Object.entries(innerHooks)) {
+      if (!Array.isArray(groups)) continue;
+      if (!merged[event]) merged[event] = [];
+      const resolved = groups.map((group) => {
+        const resolved2 = resolvePluginRoot(group, plugin.pluginDir);
+        if (typeof resolved2 === "object" && resolved2 !== null) {
+          resolved2.env = pluginEnv;
+        }
+        return resolved2;
+      });
+      merged[event].push(...resolved);
+    }
+  }
+  return merged;
+}
+function resolvePluginRoot(group, pluginDir) {
+  if (typeof group !== "object" || group === null) return group;
+  const obj = group;
+  if (Array.isArray(obj.hooks)) {
+    return {
+      ...obj,
+      hooks: obj.hooks.map((h) => {
+        if (typeof h !== "object" || h === null) return h;
+        const hook = h;
+        if (typeof hook.command === "string") {
+          return {
+            ...hook,
+            command: hook.command.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginDir)
+          };
+        }
+        return hook;
+      })
+    };
+  }
+  return group;
+}
 function useCommandRegistry(cwd) {
-  const registryRef = (0, import_react5.useRef)(null);
-  if (registryRef.current === null) {
+  const resultRef = (0, import_react5.useRef)(null);
+  if (resultRef.current === null) {
     const registry = new CommandRegistry();
     registry.addSource(new BuiltinCommandSource());
     registry.addSource(new SkillCommandSource(cwd));
-    registryRef.current = registry;
+    let pluginHooks = {};
+    const pluginsDir = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".robota", "plugins");
+    const loader = new import_agent_sdk2.BundlePluginLoader(pluginsDir);
+    try {
+      const plugins = loader.loadPluginsSync();
+      if (plugins.length > 0) {
+        registry.addSource(new PluginCommandSource(plugins));
+        pluginHooks = mergePluginHooks(plugins);
+      }
+    } catch {
+    }
+    resultRef.current = { registry, pluginHooks };
   }
-  return registryRef.current;
+  return resultRef.current;
+}
+
+// src/ui/hooks/usePluginCallbacks.ts
+var import_react6 = require("react");
+var import_node_os3 = require("os");
+var import_node_path4 = require("path");
+var import_agent_sdk3 = require("@robota-sdk/agent-sdk");
+function usePluginCallbacks(cwd) {
+  return (0, import_react6.useMemo)(() => {
+    const home = (0, import_node_os3.homedir)();
+    const pluginsDir = (0, import_node_path4.join)(home, ".robota", "plugins");
+    const userSettingsPath = (0, import_node_path4.join)(home, ".robota", "settings.json");
+    const settingsStore = new import_agent_sdk3.PluginSettingsStore(userSettingsPath);
+    const marketplace = new import_agent_sdk3.MarketplaceClient({ pluginsDir });
+    const installer = new import_agent_sdk3.BundlePluginInstaller({
+      pluginsDir,
+      settingsStore,
+      marketplaceClient: marketplace
+    });
+    const loader = new import_agent_sdk3.BundlePluginLoader(pluginsDir);
+    return {
+      listInstalled: async () => {
+        const plugins = await loader.loadAll();
+        return plugins.map((p) => ({
+          name: p.manifest.name,
+          description: p.manifest.description,
+          enabled: true
+        }));
+      },
+      install: async (pluginId) => {
+        const [name, marketplaceName] = pluginId.split("@");
+        if (!name || !marketplaceName) {
+          throw new Error("Plugin ID must be in format: name@marketplace");
+        }
+        await installer.install(name, marketplaceName);
+      },
+      uninstall: async (pluginId) => {
+        await installer.uninstall(pluginId);
+      },
+      enable: async (pluginId) => {
+        await installer.enable(pluginId);
+      },
+      disable: async (pluginId) => {
+        await installer.disable(pluginId);
+      },
+      marketplaceAdd: async (source) => {
+        if (source.includes("/") && !source.includes(":")) {
+          return marketplace.addMarketplace({ type: "github", repo: source });
+        } else {
+          return marketplace.addMarketplace({ type: "git", url: source });
+        }
+      },
+      marketplaceRemove: async (name) => {
+        const installedFromMarketplace = installer.getPluginsByMarketplace(name);
+        for (const record of installedFromMarketplace) {
+          await installer.uninstall(`${record.pluginName}@${record.marketplace}`);
+        }
+        marketplace.removeMarketplace(name);
+      },
+      marketplaceUpdate: async (name) => {
+        marketplace.updateMarketplace(name);
+      },
+      marketplaceList: async () => {
+        return marketplace.listMarketplaces().map((m) => ({
+          name: m.name,
+          type: m.source.type
+        }));
+      },
+      reloadPlugins: async () => {
+      }
+    };
+  }, [cwd]);
 }
 
 // src/ui/MessageList.tsx
@@ -845,11 +1303,11 @@ function StatusBar({
 }
 
 // src/ui/InputArea.tsx
-var import_react8 = __toESM(require("react"), 1);
+var import_react9 = __toESM(require("react"), 1);
 var import_ink6 = require("ink");
 
 // src/ui/CjkTextInput.tsx
-var import_react6 = require("react");
+var import_react7 = require("react");
 var import_ink3 = require("ink");
 var import_chalk = __toESM(require("chalk"), 1);
 var import_jsx_runtime3 = require("react/jsx-runtime");
@@ -869,9 +1327,9 @@ function CjkTextInput({
   focus = true,
   showCursor = true
 }) {
-  const valueRef = (0, import_react6.useRef)(value);
-  const cursorRef = (0, import_react6.useRef)(value.length);
-  const [, forceRender] = (0, import_react6.useState)(0);
+  const valueRef = (0, import_react7.useRef)(value);
+  const cursorRef = (0, import_react7.useRef)(value.length);
+  const [, forceRender] = (0, import_react7.useState)(0);
   if (value !== valueRef.current) {
     valueRef.current = value;
     if (cursorRef.current > value.length) {
@@ -948,15 +1406,15 @@ function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
 }
 
 // src/ui/WaveText.tsx
-var import_react7 = require("react");
+var import_react8 = require("react");
 var import_ink4 = require("ink");
 var import_jsx_runtime4 = require("react/jsx-runtime");
 var WAVE_COLORS = ["#666666", "#888888", "#aaaaaa", "#888888"];
 var INTERVAL_MS = 400;
 var CHARS_PER_GROUP = 4;
 function WaveText({ text }) {
-  const [tick, setTick] = (0, import_react7.useState)(0);
-  (0, import_react7.useEffect)(() => {
+  const [tick, setTick] = (0, import_react8.useState)(0);
+  (0, import_react8.useEffect)(() => {
     const timer = setInterval(() => {
       setTick((prev) => prev + 1);
     }, INTERVAL_MS);
@@ -1022,16 +1480,16 @@ function parseSlashInput(value) {
   return { isSlash: true, parentCommand: parent, filter: rest };
 }
 function useAutocomplete(value, registry) {
-  const [selectedIndex, setSelectedIndex] = (0, import_react8.useState)(0);
-  const [dismissed, setDismissed] = (0, import_react8.useState)(false);
-  const prevValueRef = import_react8.default.useRef(value);
+  const [selectedIndex, setSelectedIndex] = (0, import_react9.useState)(0);
+  const [dismissed, setDismissed] = (0, import_react9.useState)(false);
+  const prevValueRef = import_react9.default.useRef(value);
   if (prevValueRef.current !== value) {
     prevValueRef.current = value;
     if (dismissed) setDismissed(false);
   }
   const parsed = parseSlashInput(value);
   const isSubcommandMode = parsed.isSlash && parsed.parentCommand.length > 0;
-  const filteredCommands = (0, import_react8.useMemo)(() => {
+  const filteredCommands = (0, import_react9.useMemo)(() => {
     if (!registry || !parsed.isSlash || dismissed) return [];
     if (isSubcommandMode) {
       const subs = registry.getSubcommands(parsed.parentCommand);
@@ -1065,7 +1523,7 @@ function useAutocomplete(value, registry) {
   };
 }
 function InputArea({ onSubmit, isDisabled, registry }) {
-  const [value, setValue] = (0, import_react8.useState)("");
+  const [value, setValue] = (0, import_react9.useState)("");
   const {
     showPopup,
     filteredCommands,
@@ -1074,7 +1532,7 @@ function InputArea({ onSubmit, isDisabled, registry }) {
     isSubcommandMode,
     setShowPopup
   } = useAutocomplete(value, registry);
-  const handleSubmit = (0, import_react8.useCallback)(
+  const handleSubmit = (0, import_react9.useCallback)(
     (text) => {
       const trimmed = text.trim();
       if (trimmed.length === 0) return;
@@ -1087,7 +1545,7 @@ function InputArea({ onSubmit, isDisabled, registry }) {
     },
     [showPopup, filteredCommands, selectedIndex, onSubmit]
   );
-  const selectCommand = (0, import_react8.useCallback)(
+  const selectCommand = (0, import_react9.useCallback)(
     (cmd) => {
       const parsed = parseSlashInput(value);
       if (parsed.parentCommand) {
@@ -1148,7 +1606,7 @@ function InputArea({ onSubmit, isDisabled, registry }) {
 }
 
 // src/ui/ConfirmPrompt.tsx
-var import_react9 = require("react");
+var import_react10 = require("react");
 var import_ink7 = require("ink");
 var import_jsx_runtime7 = require("react/jsx-runtime");
 function ConfirmPrompt({
@@ -1156,9 +1614,9 @@ function ConfirmPrompt({
   options = ["Yes", "No"],
   onSelect
 }) {
-  const [selected, setSelected] = (0, import_react9.useState)(0);
-  const resolvedRef = (0, import_react9.useRef)(false);
-  const doSelect = (0, import_react9.useCallback)(
+  const [selected, setSelected] = (0, import_react10.useState)(0);
+  const resolvedRef = (0, import_react10.useRef)(false);
+  const doSelect = (0, import_react10.useCallback)(
     (index) => {
       if (resolvedRef.current) return;
       resolvedRef.current = true;
@@ -1191,7 +1649,7 @@ function ConfirmPrompt({
 }
 
 // src/ui/PermissionPrompt.tsx
-var import_react10 = __toESM(require("react"), 1);
+var import_react11 = __toESM(require("react"), 1);
 var import_ink8 = require("ink");
 var import_jsx_runtime8 = require("react/jsx-runtime");
 var OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
@@ -1201,15 +1659,15 @@ function formatArgs(args) {
   return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
 }
 function PermissionPrompt({ request }) {
-  const [selected, setSelected] = import_react10.default.useState(0);
-  const resolvedRef = import_react10.default.useRef(false);
-  const prevRequestRef = import_react10.default.useRef(request);
+  const [selected, setSelected] = import_react11.default.useState(0);
+  const resolvedRef = import_react11.default.useRef(false);
+  const prevRequestRef = import_react11.default.useRef(request);
   if (prevRequestRef.current !== request) {
     prevRequestRef.current = request;
     resolvedRef.current = false;
     setSelected(0);
   }
-  const doResolve = import_react10.default.useCallback(
+  const doResolve = import_react11.default.useCallback(
     (index) => {
       if (resolvedRef.current) return;
       resolvedRef.current = true;
@@ -1288,20 +1746,46 @@ function StreamingIndicator({ text, activeTools }) {
 // src/ui/App.tsx
 var import_jsx_runtime10 = require("react/jsx-runtime");
 var EXIT_DELAY_MS2 = 500;
+function mergeHooksIntoConfig(configHooks, pluginHooks) {
+  const pluginKeys = Object.keys(pluginHooks);
+  if (pluginKeys.length === 0) return configHooks;
+  const merged = {};
+  for (const [event, groups] of Object.entries(pluginHooks)) {
+    merged[event] = [...groups];
+  }
+  if (configHooks) {
+    for (const [event, groups] of Object.entries(configHooks)) {
+      if (!Array.isArray(groups)) continue;
+      if (!merged[event]) merged[event] = [];
+      merged[event].push(...groups);
+    }
+  }
+  return merged;
+}
 function App(props) {
   const { exit } = (0, import_ink10.useApp)();
-  const { session, permissionRequest, streamingText, clearStreamingText, activeTools } = useSession(props);
+  const { registry, pluginHooks } = useCommandRegistry(props.cwd ?? process.cwd());
+  const configWithPluginHooks = {
+    ...props.config,
+    hooks: mergeHooksIntoConfig(
+      props.config.hooks,
+      pluginHooks
+    )
+  };
+  const { session, permissionRequest, streamingText, clearStreamingText, activeTools } = useSession(
+    { ...props, config: configWithPluginHooks }
+  );
   const { messages, setMessages, addMessage } = useMessages();
-  const [isThinking, setIsThinking] = (0, import_react11.useState)(false);
+  const [isThinking, setIsThinking] = (0, import_react12.useState)(false);
   const initialCtx = session.getContextState();
-  const [contextState, setContextState] = (0, import_react11.useState)({
+  const [contextState, setContextState] = (0, import_react12.useState)({
     percentage: initialCtx.usedPercentage,
     usedTokens: initialCtx.usedTokens,
     maxTokens: initialCtx.maxTokens
   });
-  const registry = useCommandRegistry(props.cwd ?? process.cwd());
-  const pendingModelChangeRef = (0, import_react11.useRef)(null);
-  const [pendingModelId, setPendingModelId] = (0, import_react11.useState)(null);
+  const pendingModelChangeRef = (0, import_react12.useRef)(null);
+  const [pendingModelId, setPendingModelId] = (0, import_react12.useState)(null);
+  const pluginCallbacks = usePluginCallbacks(props.cwd ?? process.cwd());
   const handleSlashCommand = useSlashCommands(
     session,
     addMessage,
@@ -1309,7 +1793,8 @@ function App(props) {
     exit,
     registry,
     pendingModelChangeRef,
-    setPendingModelId
+    setPendingModelId,
+    pluginCallbacks
   );
   const handleSubmit = useSubmitHandler(
     session,
@@ -1425,23 +1910,24 @@ function renderApp(options) {
 
 // src/cli.ts
 var import_meta = {};
-function hasValidSettingsFile(filePath) {
-  if (!(0, import_node_fs3.existsSync)(filePath)) return false;
+function checkSettingsFile(filePath) {
+  if (!(0, import_node_fs3.existsSync)(filePath)) return "missing";
   try {
     const raw = (0, import_node_fs3.readFileSync)(filePath, "utf8").trim();
-    if (raw.length === 0) return false;
+    if (raw.length === 0) return "incomplete";
     const parsed = JSON.parse(raw);
     const provider = parsed.provider;
-    return !!provider?.apiKey;
+    if (!provider?.apiKey) return "incomplete";
+    return "valid";
   } catch {
-    return false;
+    return "corrupt";
   }
 }
 function readVersion() {
   try {
     const thisFile = (0, import_node_url.fileURLToPath)(import_meta.url);
-    const dir = (0, import_node_path3.dirname)(thisFile);
-    const candidates = [(0, import_node_path3.join)(dir, "..", "..", "package.json"), (0, import_node_path3.join)(dir, "..", "package.json")];
+    const dir = (0, import_node_path5.dirname)(thisFile);
+    const candidates = [(0, import_node_path5.join)(dir, "..", "..", "package.json"), (0, import_node_path5.join)(dir, "..", "package.json")];
     for (const pkgPath of candidates) {
       try {
         const raw = (0, import_node_fs3.readFileSync)(pkgPath, "utf-8");
@@ -1494,14 +1980,36 @@ function promptInput(label, masked = false) {
 }
 async function ensureConfig(cwd) {
   const userPath = getUserSettingsPath();
-  const projectPath = (0, import_node_path3.join)(cwd, ".robota", "settings.json");
-  const localPath = (0, import_node_path3.join)(cwd, ".robota", "settings.local.json");
-  if (hasValidSettingsFile(userPath) || hasValidSettingsFile(projectPath) || hasValidSettingsFile(localPath)) {
+  const projectPath = (0, import_node_path5.join)(cwd, ".robota", "settings.json");
+  const localPath = (0, import_node_path5.join)(cwd, ".robota", "settings.local.json");
+  const paths = [userPath, projectPath, localPath];
+  const checks = paths.map((p) => ({ path: p, status: checkSettingsFile(p) }));
+  if (checks.some((c) => c.status === "valid")) {
     return;
   }
+  const corrupt = checks.filter((c) => c.status === "corrupt");
+  const incomplete = checks.filter((c) => c.status === "incomplete");
   process.stdout.write("\n");
-  process.stdout.write("  Welcome to Robota CLI!\n");
-  process.stdout.write("  No configuration found. Let's set up.\n");
+  if (corrupt.length > 0) {
+    for (const c of corrupt) {
+      process.stderr.write(`  ERROR: Settings file is corrupt (invalid JSON): ${c.path}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  if (incomplete.length > 0) {
+    for (const c of incomplete) {
+      process.stderr.write(`  WARNING: Settings file is missing provider.apiKey: ${c.path}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  if (corrupt.length === 0 && incomplete.length === 0) {
+    process.stdout.write("  Welcome to Robota CLI!\n");
+    process.stdout.write("  No configuration found. Let's set up.\n");
+  } else {
+    process.stdout.write("  Reconfiguring...\n");
+  }
   process.stdout.write("\n");
   const apiKey = await promptInput("  Anthropic API key: ", true);
   if (!apiKey) {
@@ -1509,7 +2017,7 @@ async function ensureConfig(cwd) {
     process.exit(1);
   }
   const language = await promptInput("  Response language (ko/en/ja/zh, default: en): ");
-  const settingsDir = (0, import_node_path3.dirname)(userPath);
+  const settingsDir = (0, import_node_path5.dirname)(userPath);
   (0, import_node_fs3.mkdirSync)(settingsDir, { recursive: true });
   const settings = {
     provider: {
@@ -1550,9 +2058,9 @@ async function startCli() {
   const cwd = process.cwd();
   await ensureConfig(cwd);
   const [config, context, projectInfo] = await Promise.all([
-    (0, import_agent_sdk2.loadConfig)(cwd),
-    (0, import_agent_sdk2.loadContext)(cwd),
-    (0, import_agent_sdk2.detectProject)(cwd)
+    (0, import_agent_sdk4.loadConfig)(cwd),
+    (0, import_agent_sdk4.loadContext)(cwd),
+    (0, import_agent_sdk4.detectProject)(cwd)
   ]);
   if (args.model !== void 0) {
     config.provider.model = args.model;
@@ -1560,7 +2068,7 @@ async function startCli() {
   if (args.language !== void 0) {
     config.language = args.language;
   }
-  const sessionStore = new import_agent_sdk2.SessionStore();
+  const sessionStore = new import_agent_sdk4.SessionStore();
   if (args.printMode) {
     const prompt = args.positional.join(" ").trim();
     if (prompt.length === 0) {
@@ -1568,15 +2076,15 @@ async function startCli() {
       process.exit(1);
     }
     const terminal = new PrintTerminal();
-    const paths = (0, import_agent_sdk2.projectPaths)(cwd);
-    const session = (0, import_agent_sdk2.createSession)({
+    const paths = (0, import_agent_sdk4.projectPaths)(cwd);
+    const session = (0, import_agent_sdk4.createSession)({
       config,
       context,
       terminal,
-      sessionLogger: new import_agent_sdk2.FileSessionLogger(paths.logs),
+      sessionLogger: new import_agent_sdk4.FileSessionLogger(paths.logs),
       projectInfo,
       permissionMode: args.permissionMode,
-      promptForApproval: import_agent_sdk3.promptForApproval
+      promptForApproval: import_agent_sdk5.promptForApproval
     });
     const response = await session.run(prompt);
     process.stdout.write(response + "\n");