@robota-sdk/agent-sdk 3.0.0-beta.23 → 3.0.0-beta.25

package/dist/node/index.cjs

@@ -30,8 +30,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AgentExecutor: () => AgentExecutor,
+  BundlePluginInstaller: () => BundlePluginInstaller,
+  BundlePluginLoader: () => BundlePluginLoader,
   DEFAULT_TOOL_DESCRIPTIONS: () => DEFAULT_TOOL_DESCRIPTIONS,
   FileSessionLogger: () => import_agent_sessions3.FileSessionLogger,
+  MarketplaceClient: () => MarketplaceClient,
+  PluginSettingsStore: () => PluginSettingsStore,
+  PromptExecutor: () => PromptExecutor,
   Session: () => import_agent_sessions2.Session,
   SessionStore: () => import_agent_sessions4.SessionStore,
   SilentSessionLogger: () => import_agent_sessions3.SilentSessionLogger,
@@ -63,6 +69,113 @@ module.exports = __toCommonJS(index_exports);
 // src/types.ts
 var import_agent_core = require("@robota-sdk/agent-core");
 
+// src/hooks/prompt-executor.ts
+function extractJson(raw) {
+  const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1].trim();
+  }
+  return raw.trim();
+}
+var PromptExecutor = class {
+  type = "prompt";
+  providerFactory;
+  defaultModel;
+  constructor(options) {
+    this.providerFactory = options.providerFactory;
+    this.defaultModel = options.defaultModel;
+  }
+  async execute(definition, input) {
+    const promptDef = definition;
+    const model = promptDef.model ?? this.defaultModel;
+    try {
+      const provider = this.providerFactory(model);
+      const prompt = `${promptDef.prompt}
+
+Context:
+${JSON.stringify(input)}
+
+Respond with JSON: { "ok": boolean, "reason"?: string }`;
+      const rawResponse = await provider.complete(prompt);
+      const jsonStr = extractJson(rawResponse);
+      let parsed;
+      try {
+        parsed = JSON.parse(jsonStr);
+      } catch {
+        return {
+          exitCode: 1,
+          stdout: "",
+          stderr: `Failed to parse AI response as JSON: ${rawResponse}`
+        };
+      }
+      if (parsed.ok) {
+        return { exitCode: 0, stdout: JSON.stringify(parsed), stderr: "" };
+      }
+      return {
+        exitCode: 2,
+        stdout: "",
+        stderr: parsed.reason ?? "Blocked by prompt hook"
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { exitCode: 1, stdout: "", stderr: message };
+    }
+  }
+};
+
+// src/hooks/agent-executor.ts
+var DEFAULT_MAX_TURNS = 50;
+var DEFAULT_TIMEOUT_SECONDS = 60;
+function extractJson2(raw) {
+  const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1].trim();
+  }
+  return raw.trim();
+}
+var AgentExecutor = class {
+  type = "agent";
+  sessionFactory;
+  constructor(options) {
+    this.sessionFactory = options.sessionFactory;
+  }
+  async execute(definition, input) {
+    const agentDef = definition;
+    const maxTurns = agentDef.maxTurns ?? DEFAULT_MAX_TURNS;
+    const timeout = agentDef.timeout ?? DEFAULT_TIMEOUT_SECONDS;
+    try {
+      const session = this.sessionFactory({ maxTurns, timeout });
+      const prompt = `Hook input:
+${JSON.stringify(input)}
+
+Respond with JSON: { "ok": boolean, "reason"?: string }`;
+      const rawResponse = await session.run(prompt);
+      const jsonStr = extractJson2(rawResponse);
+      let parsed;
+      try {
+        parsed = JSON.parse(jsonStr);
+      } catch {
+        return {
+          exitCode: 1,
+          stdout: "",
+          stderr: `Failed to parse agent response as JSON: ${rawResponse}`
+        };
+      }
+      if (parsed.ok) {
+        return { exitCode: 0, stdout: JSON.stringify(parsed), stderr: "" };
+      }
+      return {
+        exitCode: 2,
+        stdout: "",
+        stderr: parsed.reason ?? "Blocked by agent hook"
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { exitCode: 1, stdout: "", stderr: message };
+    }
+  }
+};
+
 // src/assembly/create-session.ts
 var import_agent_sessions = require("@robota-sdk/agent-sessions");
 
@@ -95,6 +208,19 @@ function buildToolsSection(descriptions) {
   const lines = ["## Available Tools", ...descriptions.map((d) => `- ${d}`)];
   return lines.join("\n");
 }
+function buildSkillsSection(skills) {
+  const invocable = skills.filter((s) => s.disableModelInvocation !== true);
+  if (invocable.length === 0) {
+    return "";
+  }
+  const lines = [
+    "## Skills",
+    "The following skills are available:",
+    "",
+    ...invocable.map((s) => `- ${s.name}: ${s.description}`)
+  ];
+  return lines.join("\n");
+}
 function buildSystemPrompt(params) {
   const { agentsMd, claudeMd, toolDescriptions, trustLevel, projectInfo, cwd, language } = params;
   const sections = [];
@@ -105,7 +231,9 @@ function buildSystemPrompt(params) {
     "Always be precise, follow existing code conventions, and prefer minimal changes."
   ];
   if (language) {
-    roleLines.push(`Always respond in ${language}. Use ${language} for all explanations and communications.`);
+    roleLines.push(
+      `Always respond in ${language}. Use ${language} for all explanations and communications.`
+    );
   }
   sections.push(roleLines.join("\n"));
   if (cwd) {
@@ -137,6 +265,12 @@ function buildSystemPrompt(params) {
   if (toolsSection.length > 0) {
     sections.push(toolsSection);
   }
+  if (params.skills !== void 0 && params.skills.length > 0) {
+    const skillsSection = buildSkillsSection(params.skills);
+    if (skillsSection.length > 0) {
+      sections.push(skillsSection);
+    }
+  }
   return sections.join("\n\n");
 }
 
@@ -203,6 +337,25 @@ function createSession(options) {
     allow: [...defaultAllow, ...options.config.permissions.allow ?? []],
     deny: options.config.permissions.deny ?? []
   };
+  const hookTypeExecutors = [];
+  if (options.providerFactory) {
+    hookTypeExecutors.push(
+      new PromptExecutor({
+        providerFactory: options.providerFactory,
+        defaultModel: options.config.provider.model
+      })
+    );
+  }
+  if (options.sessionFactory) {
+    hookTypeExecutors.push(
+      new AgentExecutor({
+        sessionFactory: options.sessionFactory
+      })
+    );
+  }
+  if (options.additionalHookExecutors) {
+    hookTypeExecutors.push(...options.additionalHookExecutors);
+  }
   return new import_agent_sessions.Session({
     tools,
     provider,
@@ -221,7 +374,8 @@ function createSession(options) {
     promptForApproval: options.promptForApproval,
     onCompact: options.onCompact,
     compactInstructions: options.compactInstructions ?? options.context.compactInstructions,
-    sessionLogger: options.sessionLogger
+    sessionLogger: options.sessionLogger,
+    hookTypeExecutors: hookTypeExecutors.length > 0 ? hookTypeExecutors : void 0
   });
 }
 
@@ -248,10 +402,34 @@ var PermissionsSchema = import_zod.z.object({
   deny: import_zod.z.array(import_zod.z.string()).optional()
 });
 var EnvSchema = import_zod.z.record(import_zod.z.string()).optional();
-var HookDefinitionSchema = import_zod.z.object({
+var CommandHookDefinitionSchema = import_zod.z.object({
   type: import_zod.z.literal("command"),
-  command: import_zod.z.string()
+  command: import_zod.z.string(),
+  timeout: import_zod.z.number().optional()
+});
+var HttpHookDefinitionSchema = import_zod.z.object({
+  type: import_zod.z.literal("http"),
+  url: import_zod.z.string(),
+  headers: import_zod.z.record(import_zod.z.string()).optional(),
+  timeout: import_zod.z.number().optional()
+});
+var PromptHookDefinitionSchema = import_zod.z.object({
+  type: import_zod.z.literal("prompt"),
+  prompt: import_zod.z.string(),
+  model: import_zod.z.string().optional()
 });
+var AgentHookDefinitionSchema = import_zod.z.object({
+  type: import_zod.z.literal("agent"),
+  agent: import_zod.z.string(),
+  maxTurns: import_zod.z.number().optional(),
+  timeout: import_zod.z.number().optional()
+});
+var HookDefinitionSchema = import_zod.z.discriminatedUnion("type", [
+  CommandHookDefinitionSchema,
+  HttpHookDefinitionSchema,
+  PromptHookDefinitionSchema,
+  AgentHookDefinitionSchema
+]);
 var HookGroupSchema = import_zod.z.object({
   matcher: import_zod.z.string(),
   hooks: import_zod.z.array(HookDefinitionSchema)
@@ -260,8 +438,23 @@ var HooksSchema = import_zod.z.object({
   PreToolUse: import_zod.z.array(HookGroupSchema).optional(),
   PostToolUse: import_zod.z.array(HookGroupSchema).optional(),
   SessionStart: import_zod.z.array(HookGroupSchema).optional(),
-  Stop: import_zod.z.array(HookGroupSchema).optional()
+  Stop: import_zod.z.array(HookGroupSchema).optional(),
+  PreCompact: import_zod.z.array(HookGroupSchema).optional(),
+  PostCompact: import_zod.z.array(HookGroupSchema).optional(),
+  UserPromptSubmit: import_zod.z.array(HookGroupSchema).optional(),
+  Notification: import_zod.z.array(HookGroupSchema).optional()
 }).optional();
+var EnabledPluginsSchema = import_zod.z.record(import_zod.z.boolean()).optional();
+var MarketplaceSourceSchema = import_zod.z.object({
+  source: import_zod.z.object({
+    type: import_zod.z.enum(["github", "git", "local", "url"]),
+    repo: import_zod.z.string().optional(),
+    url: import_zod.z.string().optional(),
+    path: import_zod.z.string().optional(),
+    ref: import_zod.z.string().optional()
+  })
+});
+var ExtraKnownMarketplacesSchema = import_zod.z.record(MarketplaceSourceSchema).optional();
 var SettingsSchema = import_zod.z.object({
   /** Trust level used when no --permission-mode flag is given */
   defaultTrustLevel: import_zod.z.enum(["safe", "moderate", "full"]).optional(),
@@ -270,7 +463,11 @@ var SettingsSchema = import_zod.z.object({
   provider: ProviderSchema.optional(),
   permissions: PermissionsSchema.optional(),
   env: EnvSchema,
-  hooks: HooksSchema
+  hooks: HooksSchema,
+  /** Plugin enablement map: plugin name -> enabled/disabled */
+  enabledPlugins: EnabledPluginsSchema,
+  /** Extra marketplace URLs for BundlePlugin discovery */
+  extraKnownMarketplaces: ExtraKnownMarketplacesSchema
 });
 
 // src/config/config-loader.ts
@@ -337,7 +534,9 @@ function mergeSettings(layers) {
       env: {
         ...merged.env ?? {},
         ...layer.env ?? {}
-      }
+      },
+      enabledPlugins: merged.enabledPlugins !== void 0 || layer.enabledPlugins !== void 0 ? { ...merged.enabledPlugins ?? {}, ...layer.enabledPlugins ?? {} } : void 0,
+      extraKnownMarketplaces: layer.extraKnownMarketplaces ?? merged.extraKnownMarketplaces
     };
   }, {});
 }
@@ -355,25 +554,39 @@ function toResolvedConfig(merged) {
       deny: merged.permissions?.deny ?? DEFAULTS.permissions.deny
     },
     env: merged.env ?? DEFAULTS.env,
-    hooks: merged.hooks ?? void 0
+    hooks: merged.hooks ?? void 0,
+    enabledPlugins: merged.enabledPlugins ?? void 0,
+    extraKnownMarketplaces: merged.extraKnownMarketplaces ?? void 0
   };
 }
+function getSettingsPaths(cwd) {
+  const home = getHomeDir();
+  return [
+    (0, import_path.join)(home, ".robota", "settings.json"),
+    // 1. user (lowest)
+    (0, import_path.join)(cwd, ".robota", "settings.json"),
+    // 2. project
+    (0, import_path.join)(cwd, ".robota", "settings.local.json"),
+    // 3. project-local
+    (0, import_path.join)(cwd, ".claude", "settings.json"),
+    // 4. project, Claude Code compat
+    (0, import_path.join)(cwd, ".claude", "settings.local.json")
+    // 5. project-local (highest)
+  ];
+}
 async function loadConfig(cwd) {
-  const userSettingsPath = (0, import_path.join)(getHomeDir(), ".robota", "settings.json");
-  const projectSettingsPath = (0, import_path.join)(cwd, ".robota", "settings.json");
-  const localSettingsPath = (0, import_path.join)(cwd, ".robota", "settings.local.json");
-  const rawLayers = [
-    readJsonFile(userSettingsPath),
-    readJsonFile(projectSettingsPath),
-    readJsonFile(localSettingsPath)
-  ].filter((v) => v !== void 0);
-  const parsedLayers = rawLayers.map((raw, index) => {
+  const allPaths = getSettingsPaths(cwd);
+  const rawEntries = [];
+  for (const filePath of allPaths) {
+    const raw = readJsonFile(filePath);
+    if (raw !== void 0) {
+      rawEntries.push({ raw, path: filePath });
+    }
+  }
+  const parsedLayers = rawEntries.map(({ raw, path }) => {
     const result = SettingsSchema.safeParse(raw);
     if (!result.success) {
-      const paths = [userSettingsPath, projectSettingsPath, localSettingsPath].filter(
-        (_, i) => rawLayers[i] !== void 0
-      );
-      throw new Error(`Invalid settings in ${paths[index] ?? "unknown"}: ${result.error.message}`);
+      throw new Error(`Invalid settings in ${path}: ${result.error.message}`);
     }
     return resolveEnvRefs(result.data);
   });
@@ -587,6 +800,779 @@ function userPaths() {
   };
 }
 
+// src/plugins/plugin-settings-store.ts
+var import_node_fs = require("fs");
+var import_node_path2 = require("path");
+var PluginSettingsStore = class {
+  settingsPath;
+  constructor(settingsPath) {
+    this.settingsPath = settingsPath;
+  }
+  /** Read the full settings file from disk. */
+  readAll() {
+    if (!(0, import_node_fs.existsSync)(this.settingsPath)) {
+      return {};
+    }
+    try {
+      const raw = (0, import_node_fs.readFileSync)(this.settingsPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Write the full settings file to disk. */
+  writeAll(settings) {
+    const dir = (0, import_node_path2.dirname)(this.settingsPath);
+    if (!(0, import_node_fs.existsSync)(dir)) {
+      (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+    }
+    (0, import_node_fs.writeFileSync)(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  }
+  // --- enabledPlugins ---
+  /** Get the enabledPlugins map. */
+  getEnabledPlugins() {
+    const settings = this.readAll();
+    const ep = settings.enabledPlugins;
+    if (typeof ep === "object" && ep !== null) {
+      return ep;
+    }
+    return {};
+  }
+  /** Set a single plugin's enabled state. */
+  setPluginEnabled(pluginId, enabled) {
+    const settings = this.readAll();
+    const ep = this.getEnabledPluginsFrom(settings);
+    ep[pluginId] = enabled;
+    settings.enabledPlugins = ep;
+    this.writeAll(settings);
+  }
+  /** Remove a plugin from enabledPlugins. */
+  removePluginEntry(pluginId) {
+    const settings = this.readAll();
+    const ep = this.getEnabledPluginsFrom(settings);
+    delete ep[pluginId];
+    settings.enabledPlugins = ep;
+    this.writeAll(settings);
+  }
+  // --- extraKnownMarketplaces ---
+  /** Get all persisted marketplace sources. */
+  getMarketplaceSources() {
+    const settings = this.readAll();
+    const extra = settings.extraKnownMarketplaces;
+    if (typeof extra === "object" && extra !== null) {
+      return extra;
+    }
+    return {};
+  }
+  /** Add or update a marketplace source. */
+  setMarketplaceSource(name, source) {
+    const settings = this.readAll();
+    const extra = this.getMarketplaceSourcesFrom(settings);
+    extra[name] = { source };
+    settings.extraKnownMarketplaces = extra;
+    this.writeAll(settings);
+  }
+  /** Remove a marketplace source. */
+  removeMarketplaceSource(name) {
+    const settings = this.readAll();
+    const extra = this.getMarketplaceSourcesFrom(settings);
+    delete extra[name];
+    settings.extraKnownMarketplaces = extra;
+    this.writeAll(settings);
+  }
+  // --- helpers ---
+  getEnabledPluginsFrom(settings) {
+    const ep = settings.enabledPlugins;
+    if (typeof ep === "object" && ep !== null) {
+      return ep;
+    }
+    return {};
+  }
+  getMarketplaceSourcesFrom(settings) {
+    const extra = settings.extraKnownMarketplaces;
+    if (typeof extra === "object" && extra !== null) {
+      return extra;
+    }
+    return {};
+  }
+};
+
+// src/plugins/bundle-plugin-loader.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+function parseSkillFrontmatter(raw) {
+  const trimmed = raw.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { metadata: {}, content: raw };
+  }
+  const endIndex = trimmed.indexOf("---", 3);
+  if (endIndex === -1) {
+    return { metadata: {}, content: raw };
+  }
+  const frontmatterBlock = trimmed.slice(3, endIndex).trim();
+  const content = trimmed.slice(endIndex + 3).trimStart();
+  const metadata = {};
+  for (const line of frontmatterBlock.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) {
+      const inner = value.slice(1, -1);
+      value = inner.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    }
+    if (key) {
+      metadata[key] = value;
+    }
+  }
+  return { metadata, content };
+}
+function validateManifest(data) {
+  if (typeof data !== "object" || data === null) return null;
+  const obj = data;
+  if (typeof obj.name !== "string") return null;
+  if (typeof obj.version !== "string") return null;
+  if (typeof obj.description !== "string") return null;
+  const features = typeof obj.features === "object" && obj.features !== null ? obj.features : {};
+  return {
+    name: obj.name,
+    version: obj.version,
+    description: obj.description,
+    features: {
+      commands: features.commands === true ? true : void 0,
+      agents: features.agents === true ? true : void 0,
+      skills: features.skills === true ? true : void 0,
+      hooks: features.hooks === true ? true : void 0,
+      mcp: features.mcp === true ? true : void 0
+    }
+  };
+}
+function getSortedSubdirs(dirPath) {
+  if (!(0, import_node_fs2.existsSync)(dirPath)) return [];
+  try {
+    const entries = (0, import_node_fs2.readdirSync)(dirPath, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+var BundlePluginLoader = class {
+  pluginsDir;
+  enabledPlugins;
+  constructor(pluginsDir, enabledPlugins) {
+    this.pluginsDir = pluginsDir;
+    this.enabledPlugins = enabledPlugins ?? {};
+  }
+  /** Load all discovered and enabled bundle plugins (sync). */
+  loadPluginsSync() {
+    return this.discoverAndLoad();
+  }
+  /** Load all discovered and enabled bundle plugins (async wrapper). */
+  async loadAll() {
+    return this.discoverAndLoad();
+  }
+  /**
+   * Discover and load plugins from the cache directory.
+   *
+   * Directory structure: `<pluginsDir>/cache/<marketplace>/<plugin>/<version>/`
+   * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
+   */
+  discoverAndLoad() {
+    const cacheDir = (0, import_node_path3.join)(this.pluginsDir, "cache");
+    if (!(0, import_node_fs2.existsSync)(cacheDir)) {
+      return [];
+    }
+    const results = [];
+    const marketplaces = getSortedSubdirs(cacheDir);
+    for (const marketplace of marketplaces) {
+      const marketplaceDir = (0, import_node_path3.join)(cacheDir, marketplace);
+      const plugins = getSortedSubdirs(marketplaceDir);
+      for (const pluginName of plugins) {
+        const pluginDir = (0, import_node_path3.join)(marketplaceDir, pluginName);
+        const versions = getSortedSubdirs(pluginDir);
+        if (versions.length === 0) continue;
+        const latestVersion = versions[versions.length - 1];
+        const versionDir = (0, import_node_path3.join)(pluginDir, latestVersion);
+        const manifestPath = (0, import_node_path3.join)(versionDir, ".claude-plugin", "plugin.json");
+        if (!(0, import_node_fs2.existsSync)(manifestPath)) continue;
+        const manifest = this.readManifest(manifestPath);
+        if (!manifest) continue;
+        const pluginId = `${manifest.name}@${marketplace}`;
+        if (this.isDisabled(pluginId, manifest.name)) continue;
+        const loaded = this.loadPlugin(versionDir, manifest);
+        results.push(loaded);
+      }
+    }
+    return results;
+  }
+  /** Read and validate a plugin.json manifest. Returns null on failure. */
+  readManifest(path) {
+    try {
+      const raw = (0, import_node_fs2.readFileSync)(path, "utf-8");
+      const data = JSON.parse(raw);
+      return validateManifest(data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if a plugin is explicitly disabled.
+   * Checks both `name@marketplace` and `name` keys.
+   * Plugins not listed in enabledPlugins are enabled by default.
+   */
+  isDisabled(pluginId, pluginName) {
+    if (pluginId in this.enabledPlugins) {
+      return this.enabledPlugins[pluginId] === false;
+    }
+    if (pluginName in this.enabledPlugins) {
+      return this.enabledPlugins[pluginName] === false;
+    }
+    return false;
+  }
+  /** Load a single plugin's skills, hooks, agents, and MCP config. */
+  loadPlugin(pluginDir, manifest) {
+    return {
+      manifest,
+      skills: this.loadSkills(pluginDir, manifest.name),
+      commands: this.loadCommands(pluginDir, manifest.name),
+      hooks: this.loadHooks(pluginDir),
+      mcpConfig: this.loadMcpConfig(pluginDir),
+      agents: this.loadAgents(pluginDir),
+      pluginDir
+    };
+  }
+  /** Load skills from the plugin's skills/ directory. */
+  loadSkills(pluginDir, pluginName) {
+    const skillsDir = (0, import_node_path3.join)(pluginDir, "skills");
+    if (!(0, import_node_fs2.existsSync)(skillsDir)) return [];
+    const entries = (0, import_node_fs2.readdirSync)(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = (0, import_node_path3.join)(skillsDir, entry.name, "SKILL.md");
+      if (!(0, import_node_fs2.existsSync)(skillFile)) continue;
+      const raw = (0, import_node_fs2.readFileSync)(skillFile, "utf-8");
+      const { metadata, content } = parseSkillFrontmatter(raw);
+      const description = typeof metadata.description === "string" ? metadata.description : "";
+      const skill = {
+        name: entry.name,
+        description,
+        skillContent: content,
+        ...metadata
+      };
+      skills.push(skill);
+    }
+    return skills;
+  }
+  /** Load commands from the plugin's commands/ directory (flat .md files). */
+  loadCommands(pluginDir, pluginName) {
+    const commandsDir = (0, import_node_path3.join)(pluginDir, "commands");
+    if (!(0, import_node_fs2.existsSync)(commandsDir)) return [];
+    const entries = (0, import_node_fs2.readdirSync)(commandsDir, { withFileTypes: true });
+    const commands = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const raw = (0, import_node_fs2.readFileSync)((0, import_node_path3.join)(commandsDir, entry.name), "utf-8");
+      const { metadata, content } = parseSkillFrontmatter(raw);
+      const name = typeof metadata.name === "string" ? metadata.name : entry.name.replace(/\.md$/, "");
+      const description = typeof metadata.description === "string" ? metadata.description : "";
+      commands.push({
+        ...metadata,
+        name: `${pluginName}:${name}`,
+        description,
+        skillContent: content
+      });
+    }
+    return commands;
+  }
+  /** Load hooks from hooks/hooks.json if present. */
+  loadHooks(pluginDir) {
+    const hooksPath = (0, import_node_path3.join)(pluginDir, "hooks", "hooks.json");
+    if (!(0, import_node_fs2.existsSync)(hooksPath)) return {};
+    try {
+      const raw = (0, import_node_fs2.readFileSync)(hooksPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
+  loadMcpConfig(pluginDir) {
+    const primaryPath = (0, import_node_path3.join)(pluginDir, ".mcp.json");
+    const fallbackPath = (0, import_node_path3.join)(pluginDir, ".claude-plugin", "mcp.json");
+    const mcpPath = (0, import_node_fs2.existsSync)(primaryPath) ? primaryPath : fallbackPath;
+    if (!(0, import_node_fs2.existsSync)(mcpPath)) return void 0;
+    try {
+      const raw = (0, import_node_fs2.readFileSync)(mcpPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Load agent definitions from agents/ directory if present. */
+  loadAgents(pluginDir) {
+    const agentsDir = (0, import_node_path3.join)(pluginDir, "agents");
+    if (!(0, import_node_fs2.existsSync)(agentsDir)) return [];
+    try {
+      const entries = (0, import_node_fs2.readdirSync)(agentsDir, { withFileTypes: true });
+      return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/plugins/bundle-plugin-installer.ts
+var import_node_child_process = require("child_process");
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
+var GIT_CLONE_TIMEOUT_MS = 6e4;
+var BundlePluginInstaller = class {
+  pluginsDir;
+  cacheDir;
+  registryPath;
+  settingsStore;
+  marketplaceClient;
+  exec;
+  constructor(options) {
+    this.pluginsDir = options.pluginsDir;
+    this.cacheDir = (0, import_node_path4.join)(this.pluginsDir, "cache");
+    this.registryPath = (0, import_node_path4.join)(this.pluginsDir, "installed_plugins.json");
+    this.settingsStore = options.settingsStore;
+    this.marketplaceClient = options.marketplaceClient;
+    this.exec = options.exec ?? this.defaultExec;
+  }
+  /**
+   * Install a plugin from a marketplace.
+   *
+   * 1. Read marketplace manifest to find the plugin entry.
+   * 2. Resolve source (relative path, github, or url).
+   * 3. Copy/clone to `cache/<marketplace>/<plugin>/<version>/`.
+   * 4. Record in `installed_plugins.json`.
+   */
+  async install(pluginName, marketplaceName) {
+    const manifest = this.marketplaceClient.fetchManifest(marketplaceName);
+    const entry = manifest.plugins.find((p) => p.name === pluginName);
+    if (!entry) {
+      throw new Error(`Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
+    }
+    const version = this.resolveVersion(entry, marketplaceName);
+    const targetDir = (0, import_node_path4.join)(this.cacheDir, marketplaceName, pluginName, version);
+    if ((0, import_node_fs3.existsSync)(targetDir)) {
+      throw new Error(
+        `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
+      );
+    }
+    this.resolveAndInstall(entry.source, marketplaceName, pluginName, targetDir);
+    const pluginId = `${pluginName}@${marketplaceName}`;
+    const registry = this.readRegistry();
+    registry[pluginId] = {
+      pluginName,
+      marketplace: marketplaceName,
+      version,
+      installPath: targetDir,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.writeRegistry(registry);
+  }
+  /**
+   * Uninstall a plugin.
+   * Removes from cache and from installed_plugins.json.
+   */
+  async uninstall(pluginId) {
+    const registry = this.readRegistry();
+    const record = registry[pluginId];
+    if (!record) {
+      throw new Error(`Plugin "${pluginId}" is not installed`);
+    }
+    if ((0, import_node_fs3.existsSync)(record.installPath)) {
+      (0, import_node_fs3.rmSync)(record.installPath, { recursive: true, force: true });
+    }
+    delete registry[pluginId];
+    this.writeRegistry(registry);
+    this.settingsStore.removePluginEntry(pluginId);
+  }
+  /** Enable a plugin by setting its enabledPlugins entry to true. */
+  async enable(pluginId) {
+    this.settingsStore.setPluginEnabled(pluginId, true);
+  }
+  /** Disable a plugin by setting its enabledPlugins entry to false. */
+  async disable(pluginId) {
+    this.settingsStore.setPluginEnabled(pluginId, false);
+  }
+  /** Get all installed plugins. */
+  getInstalledPlugins() {
+    return this.readRegistry();
+  }
+  /** Get plugins installed from a specific marketplace. */
+  getPluginsByMarketplace(marketplaceName) {
+    const registry = this.readRegistry();
+    return Object.values(registry).filter((r) => r.marketplace === marketplaceName);
+  }
+  // --- Private helpers ---
+  /** Resolve the version for a plugin entry. */
+  resolveVersion(entry, marketplaceName) {
+    const entryWithVersion = entry;
+    if (typeof entryWithVersion.version === "string" && entryWithVersion.version) {
+      return entryWithVersion.version;
+    }
+    return this.marketplaceClient.getMarketplaceSha(marketplaceName);
+  }
+  /** Resolve the source and install the plugin. */
+  resolveAndInstall(source, marketplaceName, pluginName, targetDir) {
+    (0, import_node_fs3.mkdirSync)(targetDir, { recursive: true });
+    if (typeof source === "string") {
+      const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
+      const sourcePath = (0, import_node_path4.join)(marketplaceDir, source);
+      if (!(0, import_node_fs3.existsSync)(sourcePath)) {
+        (0, import_node_fs3.rmSync)(targetDir, { recursive: true, force: true });
+        throw new Error(
+          `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
+        );
+      }
+      (0, import_node_fs3.cpSync)(sourcePath, targetDir, { recursive: true });
+    } else if (source.type === "github") {
+      const repoUrl = `https://github.com/${source.repo}.git`;
+      this.cloneToDir(repoUrl, targetDir, pluginName);
+    } else if (source.type === "url") {
+      (0, import_node_fs3.rmSync)(targetDir, { recursive: true, force: true });
+      throw new Error("URL source installation is not yet supported");
+    }
+  }
+  /** Clone a git repository to the target directory. */
+  cloneToDir(repoUrl, targetDir, pluginName) {
+    (0, import_node_fs3.rmSync)(targetDir, { recursive: true, force: true });
+    const command = `git clone --depth 1 ${repoUrl} ${targetDir}`;
+    try {
+      this.exec(command, { timeout: GIT_CLONE_TIMEOUT_MS, stdio: "pipe" });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to clone plugin "${pluginName}": ${message}`);
+    }
+  }
+  /** Read the installed_plugins.json registry. */
+  readRegistry() {
+    if (!(0, import_node_fs3.existsSync)(this.registryPath)) {
+      return {};
+    }
+    try {
+      const raw = (0, import_node_fs3.readFileSync)(this.registryPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Write the installed_plugins.json registry. */
+  writeRegistry(registry) {
+    const dir = (0, import_node_path4.dirname)(this.registryPath);
+    if (!(0, import_node_fs3.existsSync)(dir)) {
+      (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+    }
+    (0, import_node_fs3.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  }
+  /** Default exec implementation using child_process. */
+  defaultExec(command, options) {
+    return (0, import_node_child_process.execSync)(command, { timeout: options.timeout, stdio: "pipe" });
+  }
+};
+
+// src/plugins/marketplace-client.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs4 = require("fs");
+var import_node_path5 = require("path");
+var GIT_TIMEOUT_MS = 6e4;
+var MarketplaceClient = class {
+  pluginsDir;
+  exec;
+  marketplacesDir;
+  registryPath;
+  constructor(options) {
+    this.pluginsDir = options.pluginsDir;
+    this.exec = options.exec ?? this.defaultExec;
+    this.marketplacesDir = (0, import_node_path5.join)(this.pluginsDir, "marketplaces");
+    this.registryPath = (0, import_node_path5.join)(this.pluginsDir, "known_marketplaces.json");
+  }
+  /**
+   * Add a marketplace by cloning its repository.
+   *
+   * 1. Parse source: `owner/repo` string becomes a GitHub source.
+   * 2. Shallow git clone (`--depth 1`) to `marketplaces/<name>/`.
+   * 3. Read `.claude-plugin/marketplace.json` for the `name` field.
+   * 4. Register in `known_marketplaces.json`.
+   *
+   * Returns the registered marketplace name from the manifest.
+   */
+  addMarketplace(source) {
+    const tempName = "temp-" + Date.now().toString(36);
+    const tempDir = (0, import_node_path5.join)(this.marketplacesDir, tempName);
+    (0, import_node_fs4.mkdirSync)(this.marketplacesDir, { recursive: true });
+    if (source.type === "local") {
+      if (!(0, import_node_fs4.existsSync)(source.path)) {
+        throw new Error(`Local marketplace path does not exist: ${source.path}`);
+      }
+      (0, import_node_fs4.cpSync)(source.path, tempDir, { recursive: true });
+    } else {
+      const cloneUrl = this.resolveCloneUrl(source);
+      const command = `git clone --depth 1 ${cloneUrl} ${tempDir}`;
+      try {
+        this.exec(command, { timeout: GIT_TIMEOUT_MS, stdio: "pipe" });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to clone marketplace: ${message}`);
+      }
+    }
+    const manifestPath = (0, import_node_path5.join)(tempDir, ".claude-plugin", "marketplace.json");
+    if (!(0, import_node_fs4.existsSync)(manifestPath)) {
+      (0, import_node_fs4.rmSync)(tempDir, { recursive: true, force: true });
+      throw new Error(
+        source.type === "local" ? "Local directory does not contain .claude-plugin/marketplace.json" : "Cloned repository does not contain .claude-plugin/marketplace.json"
+      );
+    }
+    const manifest = this.readManifestFromPath(manifestPath);
+    const name = manifest.name;
+    if (!name) {
+      (0, import_node_fs4.rmSync)(tempDir, { recursive: true, force: true });
+      throw new Error('Marketplace manifest does not contain a "name" field');
+    }
+    const registry = this.readRegistry();
+    if (registry[name]) {
+      (0, import_node_fs4.rmSync)(tempDir, { recursive: true, force: true });
+      throw new Error(`Marketplace "${name}" already exists`);
+    }
+    const finalDir = (0, import_node_path5.join)(this.marketplacesDir, name);
+    (0, import_node_fs4.renameSync)(tempDir, finalDir);
+    registry[name] = {
+      source,
+      installLocation: finalDir,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.writeRegistry(registry);
+    return name;
+  }
+  /**
+   * Remove a marketplace.
+   * Uninstalls all plugins from that marketplace, then deletes the clone directory
+   * and removes from the registry.
+   */
+  removeMarketplace(name) {
+    const registry = this.readRegistry();
+    const entry = registry[name];
+    if (!entry) {
+      throw new Error(`Marketplace "${name}" not found`);
+    }
+    this.removeInstalledPluginsForMarketplace(name);
+    if ((0, import_node_fs4.existsSync)(entry.installLocation)) {
+      (0, import_node_fs4.rmSync)(entry.installLocation, { recursive: true, force: true });
+    }
+    delete registry[name];
+    this.writeRegistry(registry);
+  }
+  /**
+   * Update a marketplace by running git pull on its clone.
+   * The manifest is re-read from disk on demand (via fetchManifest), so the
+   * updated manifest is automatically available after pull.
+   *
+   * TODO: After pull, detect version changes in installed plugins and offer
+   * to update them (re-install at new version).
+   */
+  updateMarketplace(name) {
+    const registry = this.readRegistry();
+    const entry = registry[name];
+    if (!entry) {
+      throw new Error(`Marketplace "${name}" not found`);
+    }
+    if (!(0, import_node_fs4.existsSync)(entry.installLocation)) {
+      throw new Error(`Marketplace directory for "${name}" does not exist`);
+    }
+    if (entry.source.type === "local") {
+      const localSource = entry.source;
+      if (!(0, import_node_fs4.existsSync)(localSource.path)) {
+        throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
+      }
+      (0, import_node_fs4.rmSync)(entry.installLocation, { recursive: true, force: true });
+      (0, import_node_fs4.cpSync)(localSource.path, entry.installLocation, { recursive: true });
+    } else {
+      const command = `git -C ${entry.installLocation} pull`;
+      try {
+        this.exec(command, { timeout: GIT_TIMEOUT_MS, stdio: "pipe" });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to update marketplace "${name}": ${message}`);
+      }
+    }
+    entry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    this.writeRegistry(registry);
+  }
+  /** List all registered marketplaces. */
+  listMarketplaces() {
+    const registry = this.readRegistry();
+    return Object.entries(registry).map(([name, entry]) => ({
+      name,
+      source: entry.source,
+      lastUpdated: entry.lastUpdated
+    }));
+  }
+  /**
+   * Read the marketplace manifest from a registered marketplace's clone.
+   */
+  fetchManifest(marketplaceName) {
+    const registry = this.readRegistry();
+    const entry = registry[marketplaceName];
+    if (!entry) {
+      throw new Error(`Marketplace "${marketplaceName}" not found`);
+    }
+    const manifestPath = (0, import_node_path5.join)(entry.installLocation, ".claude-plugin", "marketplace.json");
+    if (!(0, import_node_fs4.existsSync)(manifestPath)) {
+      throw new Error(
+        `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
+      );
+    }
+    return this.readManifestFromPath(manifestPath);
+  }
+  /** Get the clone directory path for a registered marketplace. */
+  getMarketplaceDir(name) {
+    const registry = this.readRegistry();
+    const entry = registry[name];
+    if (!entry) {
+      throw new Error(`Marketplace "${name}" not found`);
+    }
+    return entry.installLocation;
+  }
+  /**
+   * Get the current git SHA (first 12 chars) for a marketplace clone.
+   * Used as a version identifier when plugins lack explicit versions.
+   */
+  getMarketplaceSha(name) {
+    const dir = this.getMarketplaceDir(name);
+    try {
+      const result = this.exec(`git -C ${dir} rev-parse HEAD`, {
+        timeout: GIT_TIMEOUT_MS,
+        stdio: "pipe"
+      });
+      return result.toString().trim().slice(0, 12);
+    } catch {
+      return "unknown";
+    }
+  }
+  /** List all available plugins across all marketplaces. */
+  listAvailablePlugins() {
+    const results = [];
+    const marketplaces = this.listMarketplaces();
+    for (const { name } of marketplaces) {
+      try {
+        const manifest = this.fetchManifest(name);
+        for (const plugin of manifest.plugins) {
+          results.push({ ...plugin, marketplace: name });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  // --- Private helpers ---
+  /** Resolve a marketplace source to a git clone URL. */
+  resolveCloneUrl(source) {
+    switch (source.type) {
+      case "github":
+        return `https://github.com/${source.repo}.git`;
+      case "git":
+        return source.url;
+      case "local":
+        throw new Error("Local source type does not use git cloning");
+      case "url":
+        throw new Error("URL marketplace source is not yet supported");
+    }
+  }
+  /**
+   * Remove all installed plugins that belong to a given marketplace.
+   * Reads installed_plugins.json, deletes cache directories for matching plugins,
+   * and updates the registry.
+   */
+  removeInstalledPluginsForMarketplace(marketplaceName) {
+    const installedPath = (0, import_node_path5.join)(this.pluginsDir, "installed_plugins.json");
+    if (!(0, import_node_fs4.existsSync)(installedPath)) return;
+    let registry;
+    try {
+      const raw = (0, import_node_fs4.readFileSync)(installedPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data !== "object" || data === null) return;
+      registry = data;
+    } catch {
+      return;
+    }
+    let changed = false;
+    for (const [pluginId, record] of Object.entries(registry)) {
+      if (record.marketplace === marketplaceName) {
+        if (record.installPath && (0, import_node_fs4.existsSync)(record.installPath)) {
+          (0, import_node_fs4.rmSync)(record.installPath, { recursive: true, force: true });
+        }
+        delete registry[pluginId];
+        changed = true;
+      }
+    }
+    if (changed) {
+      const dir = (0, import_node_path5.dirname)(installedPath);
+      if (!(0, import_node_fs4.existsSync)(dir)) {
+        (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+      }
+      (0, import_node_fs4.writeFileSync)(installedPath, JSON.stringify(registry, null, 2), "utf-8");
+    }
+  }
+  /** Read and parse a marketplace.json from a file path. */
+  readManifestFromPath(path) {
+    const raw = (0, import_node_fs4.readFileSync)(path, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data !== "object" || data === null) {
+      throw new Error("Invalid marketplace manifest: not an object");
+    }
+    const obj = data;
+    if (typeof obj.name !== "string") {
+      throw new Error('Invalid marketplace manifest: missing "name" field');
+    }
+    return data;
+  }
+  /** Read the known_marketplaces.json registry. */
+  readRegistry() {
+    if (!(0, import_node_fs4.existsSync)(this.registryPath)) {
+      return {};
+    }
+    try {
+      const raw = (0, import_node_fs4.readFileSync)(this.registryPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Write the known_marketplaces.json registry. */
+  writeRegistry(registry) {
+    const dir = (0, import_node_path5.dirname)(this.registryPath);
+    if (!(0, import_node_fs4.existsSync)(dir)) {
+      (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+    }
+    (0, import_node_fs4.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  }
+  /** Default exec implementation using child_process. */
+  defaultExec(command, options) {
+    return (0, import_node_child_process2.execSync)(command, { timeout: options.timeout, stdio: "pipe" });
+  }
+};
+
 // src/tools/agent-tool.ts
 var import_zod2 = require("zod");
 var import_agent_tools2 = require("@robota-sdk/agent-tools");
@@ -668,8 +1654,14 @@ var import_agent_tools7 = require("@robota-sdk/agent-tools");
 var import_agent_tools8 = require("@robota-sdk/agent-tools");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AgentExecutor,
+  BundlePluginInstaller,
+  BundlePluginLoader,
   DEFAULT_TOOL_DESCRIPTIONS,
   FileSessionLogger,
+  MarketplaceClient,
+  PluginSettingsStore,
+  PromptExecutor,
   Session,
   SessionStore,
   SilentSessionLogger,