@ken-jo/agent-connector 0.1.0

package/dist/package-DLOVE2E4.js

@@ -0,0 +1,1132 @@
+#!/usr/bin/env node
+import {
+  fail,
+  print
+} from "./chunk-54EMKTTX.js";
+import {
+  findConnectorConfig,
+  loadConnectorFromPath
+} from "./chunk-LTT56GI3.js";
+import {
+  MCPB_MANIFEST_VERSION,
+  MCP_SERVER_SCHEMA_URL,
+  NPM_REGISTRY_BASE_URL,
+  REGISTRY_NAME_RE,
+  isConcreteSemver,
+  isPlaceholderVersion,
+  registryTransportType
+} from "./chunk-XNAM7F35.js";
+import {
+  writeTomlString
+} from "./chunk-OPXAP3AC.js";
+import {
+  renderCommandMd,
+  renderSkillMd,
+  renderSubagentMd
+} from "./chunk-7L6ITC4T.js";
+import {
+  buildHomeBinHookCommand,
+  buildServeWrapperCommand,
+  shouldWrapForTelemetry
+} from "./chunk-MEH7GC7R.js";
+import {
+  ensureDir,
+  homeBinPath
+} from "./chunk-TRQKHP7D.js";
+
+// src/cli/commands/package.ts
+import { parseArgs } from "util";
+import { join as join7, relative as relative2 } from "path";
+
+// src/core/package.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { resolve as resolve4 } from "path";
+
+// src/core/package-formats/claude-family.ts
+import { join } from "path";
+
+// src/core/package-formats/shared.ts
+import { dirname, relative, resolve, sep } from "path";
+import { writeFileSync } from "fs";
+function createEmitter(dryRun) {
+  const files = [];
+  return {
+    files,
+    emit(path, contents) {
+      if (!dryRun) {
+        ensureDir(dirname(path));
+        writeFileSync(path, contents, "utf8");
+      }
+      files.push(path);
+    }
+  };
+}
+function json(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function resolveWithin(baseDir, rel) {
+  const base = resolve(baseDir);
+  const target = resolve(base, rel);
+  if (target === base) return null;
+  const rind = relative(base, target);
+  if (rind === "" || rind.startsWith("..") || resolve(base, rind) !== target) {
+    return null;
+  }
+  if (rind === ".." || rind.startsWith(`..${sep}`)) return null;
+  return target;
+}
+function renderEnv(env) {
+  if (!env || Object.keys(env).length === 0) return void 0;
+  return { ...env };
+}
+var CLAUDE_MAPPED_EVENTS = /* @__PURE__ */ new Set([
+  "PreToolUse",
+  "PostToolUse",
+  "PreCompact",
+  "SessionStart",
+  "SessionEnd",
+  "UserPromptSubmit",
+  "Stop",
+  "Notification"
+]);
+function buildClaudeHooksJson(connector, homeBin, platformId) {
+  const events = connector.hookEvents.filter((e) => CLAUDE_MAPPED_EVENTS.has(e));
+  if (events.length === 0) return null;
+  const hooks = {};
+  for (const event of events) {
+    const matcher = connector.hooks[event]?.matcher ?? "";
+    const command = {
+      type: "command",
+      command: buildHomeBinHookCommand(homeBin, platformId, event, connector.id)
+    };
+    hooks[event] = [matcher ? { matcher, hooks: [command] } : { hooks: [command] }];
+  }
+  return { hooks };
+}
+function buildMcpEntry(connector, homeBin, platformId) {
+  const server = connector.server;
+  if (!server) return null;
+  if (server.transport !== "stdio") return null;
+  const realCommand = server.command ?? "";
+  if (realCommand === "") return null;
+  const realArgs = [...server.args ?? []];
+  let entry;
+  if (shouldWrapForTelemetry(server, connector.telemetry)) {
+    const wrapped = buildServeWrapperCommand(
+      homeBin,
+      connector.id,
+      realCommand,
+      realArgs,
+      void 0,
+      platformId
+    );
+    entry = { command: wrapped.command, args: wrapped.args };
+  } else {
+    entry = { command: realCommand, args: realArgs };
+  }
+  const env = renderEnv(server.env);
+  if (env) entry.env = env;
+  if (server.cwd) entry.cwd = server.cwd;
+  return { serverName: connector.id, entry };
+}
+
+// src/core/package-formats/claude-family.ts
+var SPECS = {
+  "claude-plugin": {
+    platformId: "claude-code",
+    manifestDir: ".claude-plugin",
+    subagentDir: "agents",
+    mcpFile: ".mcp.json",
+    schemaUrl: "https://json.schemastore.org/claude-code-plugin-manifest.json",
+    marketplace: { dir: ".claude-plugin", file: "marketplace.json", shape: "claude" }
+  },
+  "codex-plugin": {
+    platformId: "codex",
+    manifestDir: ".codex-plugin",
+    subagentDir: "agents",
+    mcpFile: ".mcp.json",
+    marketplace: { dir: ".codex-plugin", file: "marketplace.json", shape: "claude" }
+  },
+  "factory-plugin": {
+    platformId: "droid",
+    manifestDir: ".factory-plugin",
+    subagentDir: "droids",
+    mcpFile: "mcp.json",
+    requireVersion: true,
+    alwaysAuthor: true,
+    // droid marketplaces are Git-repo catalogs; the catalog sits at the repo root.
+    marketplace: { dir: null, file: "marketplace.json", shape: "factory" }
+  }
+};
+function buildManifest(connector, spec) {
+  const manifest = {};
+  if (spec.schemaUrl) manifest.$schema = spec.schemaUrl;
+  manifest.name = connector.id;
+  manifest.description = `${connector.displayName} \u2014 connector emitted by agent-connector`;
+  const hasRealVersion = connector.version && connector.version !== "0.0.0";
+  if (hasRealVersion) {
+    manifest.version = connector.version;
+  } else if (spec.requireVersion) {
+    manifest.version = "0.0.1";
+  }
+  if (spec.alwaysAuthor) {
+    manifest.author = { name: connector.publish?.author?.name ?? "agent-connector" };
+  }
+  return manifest;
+}
+function buildMarketplace(connector) {
+  return {
+    name: "agent-connector",
+    owner: { name: connector.publish?.author?.name ?? "agent-connector" },
+    plugins: [
+      {
+        name: connector.id,
+        source: `./${connector.id}`,
+        description: `${connector.displayName} \u2014 connector emitted by agent-connector`
+      }
+    ]
+  };
+}
+function emitClaudeFamily(connector, ctx, format) {
+  const spec = SPECS[format];
+  if (!spec) throw new Error(`unknown claude-family format: ${format}`);
+  const { emit, files } = createEmitter(ctx.dryRun);
+  const pluginDir = join(ctx.outDir, connector.id);
+  emit(
+    join(pluginDir, spec.manifestDir, "plugin.json"),
+    json(buildManifest(connector, spec))
+  );
+  for (const cmd of connector.commands) {
+    emit(join(pluginDir, "commands", `${cmd.name}.md`), renderCommandMd(cmd));
+  }
+  for (const agent of connector.subagents) {
+    emit(
+      join(pluginDir, spec.subagentDir, `${agent.name}.md`),
+      renderSubagentMd(agent)
+    );
+  }
+  for (const skill of connector.skills) {
+    const skillDir = join(pluginDir, "skills", skill.name);
+    emit(join(skillDir, "SKILL.md"), renderSkillMd(skill));
+    for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+      const target = resolveWithin(skillDir, rel);
+      if (target === null) continue;
+      emit(target, contents);
+    }
+  }
+  const hooksJson = buildClaudeHooksJson(connector, ctx.homeBinPath, spec.platformId);
+  if (hooksJson) emit(join(pluginDir, "hooks", "hooks.json"), json(hooksJson));
+  const mcp = buildMcpEntry(connector, ctx.homeBinPath, spec.platformId);
+  if (mcp) {
+    emit(
+      join(pluginDir, spec.mcpFile),
+      json({ mcpServers: { [mcp.serverName]: mcp.entry } })
+    );
+  }
+  const marketplacePath = spec.marketplace.dir ? join(ctx.outDir, spec.marketplace.dir, spec.marketplace.file) : join(ctx.outDir, spec.marketplace.file);
+  emit(marketplacePath, json(buildMarketplace(connector)));
+  return { files, pluginDir, marketplacePath };
+}
+var emitClaudePlugin = (connector, ctx) => emitClaudeFamily(connector, ctx, "claude-plugin");
+var emitCodexPlugin = (connector, ctx) => emitClaudeFamily(connector, ctx, "codex-plugin");
+var emitFactoryPlugin = (connector, ctx) => emitClaudeFamily(connector, ctx, "factory-plugin");
+
+// src/core/package-formats/cursor.ts
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+var PLATFORM = "cursor";
+function buildManifest2(connector, has) {
+  const manifest = {
+    name: connector.id,
+    description: `${connector.displayName} \u2014 connector emitted by agent-connector`
+  };
+  if (connector.version && connector.version !== "0.0.0") {
+    manifest.version = connector.version;
+  }
+  if (has.commands) manifest.commands = "./commands/";
+  if (has.agents) manifest.agents = "./agents/";
+  if (has.skills) manifest.skills = "./skills/";
+  if (has.hooks) manifest.hooks = "./hooks/hooks.json";
+  if (has.mcp) manifest.mcpServers = "./mcp.json";
+  return manifest;
+}
+function buildMarketplace2(connector) {
+  return {
+    name: "agent-connector",
+    owner: { name: connector.publish?.author?.name ?? "agent-connector" },
+    plugins: [
+      {
+        name: connector.id,
+        source: `./${connector.id}`,
+        description: `${connector.displayName} \u2014 connector emitted by agent-connector`
+      }
+    ]
+  };
+}
+var emitCursorPlugin = (connector, ctx) => {
+  const { emit, files } = createEmitter(ctx.dryRun);
+  const pluginDir = join2(ctx.outDir, connector.id);
+  const hooksJson = buildClaudeHooksJson(connector, ctx.homeBinPath, PLATFORM);
+  const mcp = buildMcpEntry(connector, ctx.homeBinPath, PLATFORM);
+  const has = {
+    commands: connector.commands.length > 0,
+    agents: connector.subagents.length > 0,
+    skills: connector.skills.length > 0,
+    hooks: hooksJson !== null,
+    mcp: mcp !== null
+  };
+  emit(
+    join2(pluginDir, ".cursor-plugin", "plugin.json"),
+    json(buildManifest2(connector, has))
+  );
+  for (const cmd of connector.commands) {
+    emit(join2(pluginDir, "commands", `${cmd.name}.md`), renderCommandMd(cmd));
+  }
+  for (const agent of connector.subagents) {
+    emit(join2(pluginDir, "agents", `${agent.name}.md`), renderSubagentMd(agent));
+  }
+  for (const skill of connector.skills) {
+    const skillDir = join2(pluginDir, "skills", skill.name);
+    emit(join2(skillDir, "SKILL.md"), renderSkillMd(skill));
+    for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+      const target = resolveWithin(skillDir, rel);
+      if (target === null) continue;
+      emit(target, contents);
+    }
+  }
+  if (hooksJson) emit(join2(pluginDir, "hooks", "hooks.json"), json(hooksJson));
+  if (mcp) {
+    emit(
+      join2(pluginDir, "mcp.json"),
+      json({ mcpServers: { [mcp.serverName]: mcp.entry } })
+    );
+  }
+  const marketplacePath = join2(ctx.outDir, ".cursor-plugin", "marketplace.json");
+  emit(marketplacePath, json(buildMarketplace2(connector)));
+  return { files, pluginDir, marketplacePath };
+};
+
+// src/core/package-formats/gemini.ts
+import { join as join3 } from "path";
+var SPECS2 = {
+  "gemini-extension": {
+    platformId: "gemini-cli",
+    manifestFile: "gemini-extension.json",
+    contextFile: "GEMINI.md",
+    commandFormat: "toml"
+  },
+  "qwen-extension": {
+    platformId: "qwen-code",
+    manifestFile: "qwen-extension.json",
+    contextFile: "QWEN.md",
+    commandFormat: "md"
+  }
+};
+function renderCommandToml(cmd) {
+  const obj = {};
+  if (cmd.description !== void 0) obj.description = cmd.description;
+  obj.prompt = cmd.prompt;
+  return writeTomlString(obj);
+}
+function buildManifest3(connector, spec, homeBin) {
+  const manifest = {
+    name: connector.id,
+    // gemini requires a version; default a placeholder to a real semver.
+    version: connector.version && connector.version !== "0.0.0" ? connector.version : "0.0.1",
+    description: `${connector.displayName} \u2014 connector emitted by agent-connector`
+  };
+  const mcp = buildMcpEntry(connector, homeBin, spec.platformId);
+  if (mcp) {
+    manifest.mcpServers = { [mcp.serverName]: mcp.entry };
+  }
+  manifest.contextFileName = spec.contextFile;
+  return manifest;
+}
+function emitGeminiFamily(connector, ctx, format) {
+  const spec = SPECS2[format];
+  if (!spec) throw new Error(`unknown gemini-family format: ${format}`);
+  const { emit, files } = createEmitter(ctx.dryRun);
+  const pluginDir = join3(ctx.outDir, connector.id);
+  emit(
+    join3(pluginDir, spec.manifestFile),
+    json(buildManifest3(connector, spec, ctx.homeBinPath))
+  );
+  emit(
+    join3(pluginDir, spec.contextFile),
+    `# ${connector.displayName}
+
+Connector context emitted by agent-connector.
+`
+  );
+  for (const cmd of connector.commands) {
+    if (spec.commandFormat === "toml") {
+      emit(join3(pluginDir, "commands", `${cmd.name}.toml`), renderCommandToml(cmd));
+    } else {
+      emit(join3(pluginDir, "commands", `${cmd.name}.md`), renderCommandMd(cmd));
+    }
+  }
+  for (const agent of connector.subagents) {
+    emit(join3(pluginDir, "agents", `${agent.name}.md`), renderSubagentMd(agent));
+  }
+  for (const skill of connector.skills) {
+    const skillDir = join3(pluginDir, "skills", skill.name);
+    emit(join3(skillDir, "SKILL.md"), renderSkillMd(skill));
+    for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+      const target = resolveWithin(skillDir, rel);
+      if (target === null) continue;
+      emit(target, contents);
+    }
+  }
+  const hooksJson = buildClaudeHooksJson(connector, ctx.homeBinPath, spec.platformId);
+  if (hooksJson) emit(join3(pluginDir, "hooks", "hooks.json"), json(hooksJson));
+  return { files, pluginDir };
+}
+var emitGeminiExtension = (connector, ctx) => emitGeminiFamily(connector, ctx, "gemini-extension");
+var emitQwenExtension = (connector, ctx) => emitGeminiFamily(connector, ctx, "qwen-extension");
+
+// src/core/package-formats/agy.ts
+import { join as join4 } from "path";
+var PLATFORM2 = "antigravity-cli";
+function buildManifest4(connector) {
+  return {
+    name: connector.id,
+    // agy expects a version on the marker; default a placeholder to a real semver.
+    version: connector.version && connector.version !== "0.0.0" ? connector.version : "0.0.1",
+    description: `${connector.displayName} \u2014 connector emitted by agent-connector`
+  };
+}
+var emitAgyPlugin = (connector, ctx) => {
+  const { emit, files } = createEmitter(ctx.dryRun);
+  const pluginDir = join4(ctx.outDir, connector.id);
+  emit(join4(pluginDir, "plugin.json"), json(buildManifest4(connector)));
+  for (const cmd of connector.commands) {
+    emit(join4(pluginDir, "commands", `${cmd.name}.md`), renderCommandMd(cmd));
+  }
+  for (const agent of connector.subagents) {
+    emit(join4(pluginDir, "agents", `${agent.name}.md`), renderSubagentMd(agent));
+  }
+  for (const skill of connector.skills) {
+    const skillDir = join4(pluginDir, "skills", skill.name);
+    emit(join4(skillDir, "SKILL.md"), renderSkillMd(skill));
+    for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+      const target = resolveWithin(skillDir, rel);
+      if (target === null) continue;
+      emit(target, contents);
+    }
+  }
+  const hooksJson = buildClaudeHooksJson(connector, ctx.homeBinPath, PLATFORM2);
+  if (hooksJson) emit(join4(pluginDir, "hooks", "hooks.json"), json(hooksJson));
+  const mcp = buildMcpEntry(connector, ctx.homeBinPath, PLATFORM2);
+  if (mcp) {
+    emit(
+      join4(pluginDir, "mcp_config.json"),
+      json({ mcpServers: { [mcp.serverName]: mcp.entry } })
+    );
+  }
+  return { files, pluginDir };
+};
+
+// src/core/package-formats/kimi.ts
+import { join as join5 } from "path";
+var PLATFORM3 = "kimi";
+function buildManifest5(connector, hasSkills, homeBin) {
+  const manifest = {
+    name: connector.id,
+    version: connector.version && connector.version !== "0.0.0" ? connector.version : "0.0.1",
+    description: `${connector.displayName} \u2014 connector emitted by agent-connector`
+  };
+  if (hasSkills) manifest.skills = "./skills/";
+  const mcp = buildMcpEntry(connector, homeBin, PLATFORM3);
+  if (mcp) manifest.mcpServers = { [mcp.serverName]: mcp.entry };
+  return manifest;
+}
+var emitKimiPlugin = (connector, ctx) => {
+  const { emit, files } = createEmitter(ctx.dryRun);
+  const pluginDir = join5(ctx.outDir, connector.id);
+  const notes = [];
+  const hasSkills = connector.skills.length > 0;
+  emit(join5(pluginDir, "kimi.plugin.json"), json(buildManifest5(connector, hasSkills, ctx.homeBinPath)));
+  for (const skill of connector.skills) {
+    const skillDir = join5(pluginDir, "skills", skill.name);
+    emit(join5(skillDir, "SKILL.md"), renderSkillMd(skill));
+    for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+      const target = resolveWithin(skillDir, rel);
+      if (target === null) continue;
+      emit(target, contents);
+    }
+  }
+  if (connector.commands.length > 0) {
+    notes.push(
+      `kimi-plugin: dropped ${connector.commands.length} command(s) \u2014 Kimi plugins ignore commands`
+    );
+  }
+  if (connector.subagents.length > 0) {
+    notes.push(
+      `kimi-plugin: dropped ${connector.subagents.length} subagent(s) \u2014 Kimi plugins ignore subagents`
+    );
+  }
+  if (connector.hookEvents.length > 0) {
+    notes.push(
+      `kimi-plugin: dropped ${connector.hookEvents.length} hook event(s) \u2014 Kimi plugins ignore hooks`
+    );
+  }
+  return { files, pluginDir, ...notes.length > 0 ? { notes } : {} };
+};
+
+// src/core/package-formats/npm.ts
+import { join as join6 } from "path";
+var EVENT_TO_OPENCODE = {
+  PreToolUse: "tool.execute.before",
+  PostToolUse: "tool.execute.after",
+  SessionStart: "experimental.chat.system.transform"
+};
+function buildPackageJson(connector) {
+  const pkgName = connector.id.startsWith("opencode-") ? connector.id : `opencode-${connector.id}`;
+  const version = connector.version && connector.version !== "0.0.0" ? connector.version : "0.0.1";
+  const pkg = {
+    name: pkgName,
+    version,
+    description: `${connector.displayName} \u2014 connector emitted by agent-connector`,
+    type: "module",
+    main: "index.js",
+    exports: { ".": "./index.js" },
+    keywords: ["opencode", "opencode-plugin", "pi-package", "agent-connector"],
+    // pi reads skills/prompts/themes/extensions from the package.json "pi" key.
+    pi: { extensions: ["./index.js"], skills: ["./skills"] },
+    engines: { node: ">=18.17", opencode: ">=1.0.0" }
+    // NOTE: no hardcoded license — this is the DEVELOPER'S publishable package
+    // and agent-connector has no authority to license it. The emitter returns a
+    // note telling the dev to set license (and author) before `npm publish`.
+  };
+  if (connector.publish?.author?.name) {
+    pkg.author = connector.publish.author.name;
+  }
+  return pkg;
+}
+function buildIndexJs(connector) {
+  const homeBin = JSON.stringify("agent-connector");
+  const connectorId = JSON.stringify(connector.id);
+  const events = connector.hookEvents.filter(
+    (e) => EVENT_TO_OPENCODE[e] !== void 0
+  );
+  const has = (e) => events.includes(e);
+  const header = `/**
+ * AUTO-GENERATED by agent-connector \u2014 DO NOT EDIT.
+ *
+ * Publishable OpenCode/Kilo/Pi plugin for connector ${connector.id}. It imports
+ * nothing from agent-connector: every hook invocation shells out to the stable
+ * home binary's universal entrypoint and JSON-parses the normalized response.
+ * Fail-open: any bridge error degrades to "allow".
+ */
+import { execFileSync, execSync } from "node:child_process";
+
+const HOME_BIN = ${homeBin};
+const CONNECTOR_ID = ${connectorId};
+
+function bridge(event, payload) {
+  try {
+    // The published bridge resolves HOME_BIN by bare name via the consumer's
+    // PATH, where on Windows it is agent-connector.cmd. Node cannot execFile a
+    // .cmd, and shell+args is deprecated (DEP0190), so on Windows run one quoted
+    // command line via a shell (cmd.exe applies PATHEXT). POSIX keeps execFile.
+    const args = ["hook", "opencode", event, "--connector", CONNECTOR_ID];
+    const opts = { input: JSON.stringify(payload), encoding: "utf8" };
+    const stdout =
+      process.platform === "win32"
+        ? execSync([HOME_BIN, ...args].map((a) => '"' + a + '"').join(" "), opts)
+        : execFileSync(HOME_BIN, args, opts);
+    const text = (stdout || "").trim();
+    if (text === "") return { decision: "allow" };
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+`;
+  const handlers = [];
+  if (has("PreToolUse")) {
+    handlers.push(`    "tool.execute.before": async (input, output) => {
+      const res = bridge("PreToolUse", {
+        toolName: input.tool ?? "",
+        toolInput: (output && output.args) ?? {},
+        sessionId: input.sessionID ?? "",
+        projectDir: PROJECT_DIR,
+      });
+      if (!res) return;
+      if (res.decision === "deny" || res.decision === "ask") {
+        throw new Error(res.reason || "Blocked by ${connector.id}");
+      }
+      if (res.updatedInput && output && output.args) Object.assign(output.args, res.updatedInput);
+    },`);
+  }
+  if (has("PostToolUse")) {
+    handlers.push(`    "tool.execute.after": async (input, output) => {
+      const res = bridge("PostToolUse", {
+        toolName: input.tool ?? "",
+        toolInput: input.args ?? {},
+        toolOutput: output ? output.output : undefined,
+        sessionId: input.sessionID ?? "",
+        projectDir: PROJECT_DIR,
+      });
+      if (!res) return;
+      if (typeof res.updatedOutput === "string" && output) output.output = res.updatedOutput;
+    },`);
+  }
+  if (has("SessionStart")) {
+    handlers.push(`    "experimental.chat.system.transform": async (input, output) => {
+      const res = bridge("SessionStart", {
+        sessionId: (input && input.sessionID) ?? "",
+        projectDir: PROJECT_DIR,
+      });
+      if (!res) return;
+      if (res.additionalContext && output && Array.isArray(output.system)) {
+        output.system.splice(1, 0, res.additionalContext);
+      }
+    },`);
+  }
+  const factory = `
+export default async function (ctx) {
+  const PROJECT_DIR =
+    (ctx && (ctx.directory || (ctx.worktree && ctx.worktree.path))) || process.cwd();
+  return {
+${handlers.join("\n")}
+  };
+}
+`;
+  return header + factory;
+}
+var emitNpmPlugin = (connector, ctx) => {
+  const { emit, files } = createEmitter(ctx.dryRun);
+  const pluginDir = join6(ctx.outDir, connector.id);
+  const notes = [];
+  emit(join6(pluginDir, "package.json"), json(buildPackageJson(connector)));
+  emit(join6(pluginDir, "index.js"), buildIndexJs(connector));
+  for (const skill of connector.skills) {
+    const skillDir = join6(pluginDir, "skills", skill.name);
+    emit(join6(skillDir, "SKILL.md"), renderSkillMd(skill));
+    for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+      const target = resolveWithin(skillDir, rel);
+      if (target === null) continue;
+      emit(target, contents);
+    }
+  }
+  emit(
+    join6(pluginDir, "README.md"),
+    `# ${connector.displayName}
+
+OpenCode / Kilo / Pi plugin package emitted by agent-connector.
+
+Install with \`opencode plugin install <pkg>\` / \`kilo plugin <pkg>\` / \`pi install <pkg>\`.
+
+## Prerequisite
+
+Hooks shell out to the \`agent-connector\` CLI resolved from the consumer's PATH \u2014
+the consumer machine needs \`npm i -g @ken-jo/agent-connector\` (hooks silently no-op,
+fail-open, without it).
+
+## Before you publish
+
+The emitted package.json carries **no \`license\` and no \`author\`** unless your
+connector declared \`publish.author\` \u2014 set them to YOUR terms before \`npm publish\`.
+`
+  );
+  notes.push(
+    "npm-plugin: hooks require `npm i -g @ken-jo/agent-connector` on the consumer machine (bridge resolves the CLI by name on PATH; silently fail-open without it)"
+  );
+  notes.push(
+    "npm-plugin: set license/author in the emitted package.json before `npm publish` \u2014 agent-connector does not license your plugin for you"
+  );
+  if (connector.commands.length > 0) {
+    notes.push(
+      `npm-plugin: ${connector.commands.length} command(s) NOT bundled \u2014 opencode/kilo commands are native host dirs`
+    );
+  }
+  if (connector.subagents.length > 0) {
+    notes.push(
+      `npm-plugin: ${connector.subagents.length} subagent(s) NOT bundled \u2014 opencode/kilo subagents are native host dirs`
+    );
+  }
+  if (connector.server) {
+    notes.push(
+      `npm-plugin: MCP server NOT bundled inside the package \u2014 register it via the opencode.json "mcp" key`
+    );
+  }
+  return { files, pluginDir, ...notes.length > 0 ? { notes } : {} };
+};
+
+// src/core/package-formats/mcp-server.ts
+import { resolve as resolve2 } from "path";
+function buildEnvVars(server) {
+  const vars = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(server.env ?? {})) {
+    const v = { name: key };
+    vars.push(v);
+    byName.set(key, v);
+  }
+  if (server.auth?.type === "bearerEnv" && server.auth.bearerEnvVar) {
+    const name = server.auth.bearerEnvVar;
+    const existing = byName.get(name);
+    if (existing) {
+      existing.isSecret = true;
+      existing.isRequired = true;
+    } else {
+      vars.push({ name, isSecret: true, isRequired: true });
+    }
+  }
+  return vars;
+}
+function buildServerJson(connector, notes) {
+  const publish = connector.publish ?? {};
+  if (!publish.registryNamespace) {
+    throw new Error(
+      'package --format mcp-server-json needs publish.registryNamespace \u2014 a reverse-DNS namespace you OWN (e.g. "io.github.<your-handle>" or "com.<your-domain>"). agent-connector never publishes under a namespace it owns; set it in your connector config.'
+    );
+  }
+  const name = `${publish.registryNamespace}/${connector.id}`;
+  if (!REGISTRY_NAME_RE.test(name)) {
+    throw new Error(
+      `server.json name "${name}" must match ${REGISTRY_NAME_RE} (exactly one "/").`
+    );
+  }
+  if (!isConcreteSemver(connector.version)) {
+    throw new Error(
+      `server.json version must be a concrete SemVer (the registry rejects ranges); got "${connector.version}".`
+    );
+  }
+  if (isPlaceholderVersion(connector.version)) {
+    notes.push(
+      'version is the unset placeholder "0.0.0" \u2014 set a real version before publishing to the registry.'
+    );
+  }
+  const out = {
+    $schema: MCP_SERVER_SCHEMA_URL,
+    name,
+    description: connector.displayName,
+    version: connector.version
+  };
+  const server = connector.server;
+  if (!server) {
+    notes.push(
+      "connector declares no server \u2014 emitted server.json carries neither packages nor remotes (a hooks/commands-only connector is not a registry server)."
+    );
+    return out;
+  }
+  const tt = registryTransportType(server.transport);
+  if (tt === null) {
+    notes.push(
+      `transport "${server.transport}" is not an MCP spec transport and cannot be represented in server.json; emitted server metadata without a package/remote entry.`
+    );
+    return out;
+  }
+  if (server.transport === "stdio") {
+    if (!publish.packageName) {
+      throw new Error(
+        `package --format mcp-server-json needs publish.packageName \u2014 your REAL published npm package that runs the MCP server (e.g. "@acme/acme-db-mcp"). The registry runs that package directly, not agent-connector's serve wrapper.`
+      );
+    }
+    const pkg = {
+      registryType: "npm",
+      registryBaseUrl: publish.registryBaseUrl ?? NPM_REGISTRY_BASE_URL,
+      identifier: publish.packageName,
+      version: connector.version,
+      transport: { type: "stdio" }
+    };
+    const envVars = buildEnvVars(server);
+    if (envVars.length > 0) pkg.environmentVariables = envVars;
+    out.packages = [pkg];
+  } else {
+    const remote = { type: tt, url: server.url };
+    const headers = Object.keys(server.headers ?? {}).map((k) => ({ name: k }));
+    if (headers.length > 0) remote.headers = headers;
+    if (server.auth && server.auth.type !== "none") {
+      notes.push(
+        `remote server uses auth "${server.auth.type}" \u2014 add the credential header (isSecret) to the emitted remotes[].headers before publishing.`
+      );
+    }
+    out.remotes = [remote];
+  }
+  return out;
+}
+var emitMcpServerJson = (connector, ctx) => {
+  const emitter = createEmitter(ctx.dryRun);
+  const notes = [];
+  const serverJson = buildServerJson(connector, notes);
+  const path = resolve2(ctx.outDir, "server.json");
+  emitter.emit(path, json(serverJson));
+  return {
+    files: emitter.files,
+    pluginDir: ctx.outDir,
+    ...notes.length > 0 ? { notes } : {}
+  };
+};
+
+// src/core/package-formats/mcpb.ts
+import { resolve as resolve3 } from "path";
+function titleize(s) {
+  return s.toLowerCase().split(/[_-]+/).filter(Boolean).map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
+}
+function secretEnvNames(server) {
+  const names = /* @__PURE__ */ new Set();
+  if (server.auth?.type === "bearerEnv" && server.auth.bearerEnvVar) {
+    names.add(server.auth.bearerEnvVar);
+  }
+  return names;
+}
+function recipeReadme(connector) {
+  return `# ${connector.displayName} \u2014 MCPB bundle
+
+\`agent-connector package --format mcpb\` emitted the conformant **manifest.json**
+(manifest_version ${MCPB_MANIFEST_VERSION}) for this connector. It does NOT build
+the \`.mcpb\` zip \u2014 that step vendors your server and is yours to run, so the
+bundle stays self-contained and signable.
+
+## Finish the bundle
+
+1. Put your built, self-contained MCP server at \`server/index.js\`
+   (the manifest's \`entry_point\` / \`mcp_config\`).
+2. Vendor production dependencies into the bundle:
+
+   \`\`\`bash
+   cd server && npm install --omit=dev && cd ..
+   \`\`\`
+
+3. Pack (and optionally sign) with the official MCPB CLI:
+
+   \`\`\`bash
+   npx @anthropic-ai/mcpb pack .      # \u2192 ${connector.id}.mcpb
+   npx @anthropic-ai/mcpb sign ${connector.id}.mcpb
+   \`\`\`
+
+The resulting \`.mcpb\` installs one-click into Claude Desktop and any MCPB host.
+Secrets are declared under \`user_config\` and collected by the host keychain at
+install time \u2014 never inline them in the manifest.
+`;
+}
+var emitMcpbBundle = (connector, ctx) => {
+  const publish = connector.publish ?? {};
+  if (!publish.author?.name) {
+    throw new Error(
+      "package --format mcpb needs publish.author.name \u2014 the MCPB manifest requires an author."
+    );
+  }
+  if (!isConcreteSemver(connector.version)) {
+    throw new Error(
+      `mcpb manifest version must be a concrete SemVer; got "${connector.version}".`
+    );
+  }
+  const server = connector.server;
+  if (!server) {
+    throw new Error("package --format mcpb needs a server (an MCPB bundle packages an MCP server).");
+  }
+  if (server.transport !== "stdio") {
+    throw new Error(
+      `package --format mcpb supports stdio servers; "${server.transport}" is a remote server \u2014 publish it via the registry (--format mcp-server-json) instead.`
+    );
+  }
+  const notes = [];
+  if (isPlaceholderVersion(connector.version)) {
+    notes.push('version is the unset placeholder "0.0.0" \u2014 set a real version before packing.');
+  }
+  const secrets = secretEnvNames(server);
+  const env = {};
+  const userConfig = {};
+  for (const [k, v] of Object.entries(server.env ?? {})) {
+    if (secrets.has(k)) {
+      const key = k.toLowerCase();
+      userConfig[key] = {
+        type: "string",
+        title: titleize(k),
+        description: `Value for ${k}`,
+        sensitive: true,
+        required: true
+      };
+      env[k] = `\${user_config.${key}}`;
+    } else {
+      env[k] = v;
+    }
+  }
+  for (const name of secrets) {
+    if (!(name in env)) {
+      const key = name.toLowerCase();
+      userConfig[key] = {
+        type: "string",
+        title: titleize(name),
+        description: `Value for ${name}`,
+        sensitive: true,
+        required: true
+      };
+      env[name] = `\${user_config.${key}}`;
+    }
+  }
+  const author = { name: publish.author.name };
+  if (publish.author.email) author.email = publish.author.email;
+  if (publish.author.url) author.url = publish.author.url;
+  const mcpConfig = {
+    command: "node",
+    args: ["${__dirname}/server/index.js"]
+  };
+  if (Object.keys(env).length > 0) mcpConfig.env = env;
+  const manifest = {
+    manifest_version: MCPB_MANIFEST_VERSION,
+    name: connector.id,
+    version: connector.version,
+    description: connector.displayName,
+    author,
+    server: {
+      type: "node",
+      entry_point: "server/index.js",
+      mcp_config: mcpConfig
+    }
+  };
+  if (Object.keys(userConfig).length > 0) manifest.user_config = userConfig;
+  if (server.command && !/\b(node|npx)\b/.test(server.command)) {
+    notes.push(
+      `your server command is "${server.command}" \u2014 the emitted manifest assumes a node server (server.type:node); adjust server.type/entry_point for your runtime (python|binary).`
+    );
+  }
+  notes.push(
+    "emitted manifest.json + README recipe; this format does NOT build the .mcpb zip. Place your self-contained server at server/index.js, vendor deps, then run `mcpb pack` (see README)."
+  );
+  const emitter = createEmitter(ctx.dryRun);
+  emitter.emit(resolve3(ctx.outDir, "manifest.json"), json(manifest));
+  emitter.emit(resolve3(ctx.outDir, "README.md"), recipeReadme(connector));
+  return { files: emitter.files, pluginDir: ctx.outDir, notes };
+};
+
+// src/core/package.ts
+var EMITTERS = {
+  "claude-plugin": emitClaudePlugin,
+  "codex-plugin": emitCodexPlugin,
+  "factory-plugin": emitFactoryPlugin,
+  "gemini-extension": emitGeminiExtension,
+  "qwen-extension": emitQwenExtension,
+  "agy-plugin": emitAgyPlugin,
+  "cursor-plugin": emitCursorPlugin,
+  "kimi-plugin": emitKimiPlugin,
+  "npm-plugin": emitNpmPlugin,
+  "mcp-server-json": emitMcpServerJson,
+  mcpb: emitMcpbBundle
+};
+var ALL_FORMATS = [
+  "claude-plugin",
+  "codex-plugin",
+  "factory-plugin",
+  "gemini-extension",
+  "qwen-extension",
+  "agy-plugin",
+  "cursor-plugin",
+  "kimi-plugin",
+  "npm-plugin",
+  "mcp-server-json",
+  "mcpb"
+];
+var FEASIBLE_FORMATS = [
+  "claude-plugin",
+  "codex-plugin",
+  "factory-plugin",
+  "gemini-extension",
+  "qwen-extension",
+  "agy-plugin",
+  "cursor-plugin",
+  "kimi-plugin",
+  "npm-plugin"
+];
+function isPackageFormat(s) {
+  return Object.prototype.hasOwnProperty.call(EMITTERS, s);
+}
+var HOME_BIN_EMBED_FORMATS = /* @__PURE__ */ new Set([
+  "claude-plugin",
+  "codex-plugin",
+  "factory-plugin",
+  "gemini-extension",
+  "qwen-extension",
+  "agy-plugin",
+  "cursor-plugin",
+  "kimi-plugin"
+]);
+function packageConnector(connector, opts) {
+  const format = opts.format ?? "claude-plugin";
+  const emitter = EMITTERS[format];
+  if (!emitter) {
+    throw new Error(`unsupported package format: ${format}`);
+  }
+  const ctx = {
+    outDir: resolve4(opts.outDir),
+    homeBinPath: opts.homeBinPath ?? homeBinPath(),
+    dryRun: opts.dryRun ?? false
+  };
+  const result = emitter(connector, ctx);
+  if (HOME_BIN_EMBED_FORMATS.has(format)) {
+    const note = `bundle embeds this machine's agent-connector launcher path (${ctx.homeBinPath}) \u2014 valid for LOCAL install; for a shared marketplace, consumers need agent-connector at the same home path (run \`agent-connector upgrade\` there) or re-run \`package\` per machine`;
+    result.notes = [...result.notes ?? [], note];
+  }
+  return result;
+}
+function packageConnectorAll(connector, opts) {
+  const base = resolve4(opts.outDir);
+  const homeBin = opts.homeBinPath ?? homeBinPath();
+  const dryRun = opts.dryRun ?? false;
+  return FEASIBLE_FORMATS.map((format) => ({
+    format,
+    result: packageConnector(connector, {
+      outDir: resolve4(base, format),
+      format,
+      homeBinPath: homeBin,
+      dryRun
+    })
+  }));
+}
+
+// src/cli/commands/package.ts
+var HELP = `agent-connector package \u2014 emit a plugin/extension/marketplace bundle.
+
+usage: agent-connector package [flags]
+
+flags:
+  --connector <path>   Connector config to package (else auto-discovered).
+  --format <fmt>       Output format (default: claude-plugin). One of:
+                         ${ALL_FORMATS.join(", ")}
+                       or "all" to emit every feasible format into <out>/<fmt>/.
+  --out <dir>          Output directory. Default: <cwd>/dist-plugin.
+  --project <dir>      Project root for connector discovery (default: cwd).
+  --dry-run            Compute the file tree without writing anything.
+  --help               Show this help.`;
+function printFormatResult(format, connectorId, outDir, result) {
+  print(`  pluginDir: ${result.pluginDir}`);
+  if (result.marketplacePath) {
+    print(`  marketplace: ${relative2(outDir, result.marketplacePath)}`);
+  }
+  print("  emitted files:");
+  for (const f of result.files) {
+    print(`    + ${relative2(outDir, f)}`);
+  }
+  if (result.notes && result.notes.length > 0) {
+    print("  notes:");
+    for (const n of result.notes) print(`    ! ${n}`);
+  }
+  print("  install:");
+  for (const line of installInstructions(format, connectorId, outDir)) {
+    print(`    ${line}`);
+  }
+  print("");
+}
+function installInstructions(format, id, outDir) {
+  switch (format) {
+    case "claude-plugin":
+      return [
+        `/plugin marketplace add ${outDir}`,
+        `/plugin install ${id}@agent-connector`,
+        `(CLI: claude plugin marketplace add ${outDir} && claude plugin install ${id}@agent-connector)`
+      ];
+    case "codex-plugin":
+      return [
+        `codex plugin marketplace add ${outDir}`,
+        `codex plugin add ${id}@agent-connector`
+      ];
+    case "factory-plugin":
+      return [
+        `droid plugin marketplace add ${outDir}`,
+        `droid plugin install ${id}@agent-connector`
+      ];
+    case "gemini-extension":
+      return [`gemini extensions install ${join7(outDir, id)}`];
+    case "qwen-extension":
+      return [`qwen extensions install ${join7(outDir, id)}`];
+    case "agy-plugin":
+      return [
+        `agy plugin install ${join7(outDir, id)}`,
+        `(validate: agy plugin validate ${join7(outDir, id)})`
+      ];
+    case "cursor-plugin":
+      return [
+        `link ${join7(outDir, id)} into ~/.cursor/plugins/local/${id}/ then Developer: Reload Window`,
+        `(or publish ${outDir} as a Cursor marketplace repo)`
+      ];
+    case "kimi-plugin":
+      return [`kimi plugin install ${join7(outDir, id)}`];
+    case "npm-plugin":
+      return [
+        `npm publish ${join7(outDir, id)}  (then: opencode plugin install <pkg> | kilo plugin <pkg> | pi install npm:<pkg>)`
+      ];
+    case "mcp-server-json":
+      return [
+        `mcp-publisher login <github|dns|http>   (prove ownership of your namespace once)`,
+        `cd ${outDir} && mcp-publisher publish   (uploads server.json to the official MCP Registry)`
+      ];
+    case "mcpb":
+      return [
+        `vendor your built server under ${join7(outDir, "server")}/ (see the emitted README)`,
+        `npx @anthropic-ai/mcpb pack ${outDir}   (then optionally: mcpb sign)`
+      ];
+    default:
+      return [];
+  }
+}
+async function run(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      connector: { type: "string" },
+      format: { type: "string", default: "claude-plugin" },
+      out: { type: "string" },
+      project: { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      help: { type: "boolean", default: false }
+    },
+    allowPositionals: false
+  });
+  if (values.help) {
+    print(HELP);
+    return 0;
+  }
+  const formatArg = values.format ?? "claude-plugin";
+  const isAll = formatArg === "all";
+  if (!isAll && !isPackageFormat(formatArg)) {
+    return fail(
+      `invalid --format "${formatArg}" (expected one of: ${ALL_FORMATS.join(", ")}, or "all")`
+    );
+  }
+  const projectDir = values.project ?? process.cwd();
+  const configPath = values.connector ?? findConnectorConfig(projectDir);
+  if (!configPath) {
+    return fail(
+      "no connector config found. Pass --connector <path> or add an agent-connector.config.{mjs,js,json} to your project."
+    );
+  }
+  const outDir = values.out ?? `${process.cwd()}/dist-plugin`;
+  const dryRun = values["dry-run"];
+  const mode = dryRun ? " (dry-run \u2014 nothing written)" : "";
+  const { connector } = await loadConnectorFromPath(configPath);
+  if (isAll) {
+    print(`package "${connector.id}" \u2192 all formats${mode}`);
+    print(`  outDir: ${outDir}`);
+    print("");
+    const results = packageConnectorAll(connector, { outDir, dryRun });
+    for (const { format: format2, result: result2 } of results) {
+      const formatOut = join7(outDir, format2);
+      print(`\u2500\u2500 ${format2} \u2500\u2500`);
+      printFormatResult(format2, connector.id, formatOut, result2);
+    }
+    print(`emitted ${results.length} formats: ${FEASIBLE_FORMATS.join(", ")}`);
+    return 0;
+  }
+  const format = formatArg;
+  let result;
+  try {
+    result = packageConnector(connector, { outDir, format, dryRun });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return fail(message);
+  }
+  print(`package "${connector.id}" \u2192 ${format}${mode}`);
+  print(`  outDir: ${outDir}`);
+  print("");
+  printFormatResult(format, connector.id, outDir, result);
+  return 0;
+}
+export {
+  run
+};
+//# sourceMappingURL=package-DLOVE2E4.js.map