@ken-jo/agent-connector 0.4.99 → 0.5.0

package/dist/{chunk-N4STCQGP.js → chunk-U2XJWG7N.js}

@@ -33,7 +33,7 @@ import {
 
 // src/core/package.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join7, resolve as resolve4 } from "path";
+import { join as join8, resolve as resolve4 } from "path";
 
 // src/core/package-formats/claude-family.ts
 import { join } from "path";
@@ -41,6 +41,21 @@ import { join } from "path";
 // src/core/package-formats/shared.ts
 import { dirname, relative, resolve, sep } from "path";
 import { writeFileSync } from "fs";
+import { createRequire } from "module";
+var AGENT_CONNECTOR_PACKAGE_NAME = "@ken-jo/agent-connector";
+function resolveFrameworkDependencyRange() {
+  const req = createRequire(import.meta.url);
+  for (const rel of ["../../../package.json", "../../package.json", "../package.json"]) {
+    try {
+      const pkg = req(rel);
+      if (pkg.name === AGENT_CONNECTOR_PACKAGE_NAME && typeof pkg.version === "string" && /^\d+\.\d+\.\d+/.test(pkg.version)) {
+        return `^${pkg.version}`;
+      }
+    } catch {
+    }
+  }
+  return "*";
+}
 function createEmitter(dryRun) {
   const files = [];
   return {
@@ -143,29 +158,6 @@ var SPECS = {
     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: join(".agents", "plugins"),
-      file: "marketplace.json",
-      shape: "claude"
-    }
-  },
-  "copilot-plugin": {
-    // copilot-cli accepts a Claude-shaped bundle as-is; the ONLY difference from
-    // claude-plugin is the --host stamp so the wrapped MCP + hook commands route
-    // telemetry to the copilot host. Same `.claude-plugin/` manifest dir + schema
-    // + `.claude-plugin/marketplace.json` catalog (live-verified on CLI 1.0.63).
-    platformId: "copilot-cli",
-    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" }
-  },
   "factory-plugin": {
     platformId: "droid",
     manifestDir: ".factory-plugin",
@@ -247,9 +239,7 @@ function emitClaudeFamily(connector, ctx, format) {
   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");
-var emitCopilotPlugin = (connector, ctx) => emitClaudeFamily(connector, ctx, "copilot-plugin");
 
 // src/core/package-formats/cursor.ts
 import { existsSync } from "fs";
@@ -506,27 +496,12 @@ var emitKimiPlugin = (connector, ctx) => {
 };
 
 // src/core/package-formats/npm.ts
-import { createRequire } from "module";
 import { join as join6 } from "path";
-var AGENT_CONNECTOR_PACKAGE_NAME = "@ken-jo/agent-connector";
 var EVENT_TO_OPENCODE = {
   PreToolUse: "tool.execute.before",
   PostToolUse: "tool.execute.after",
   SessionStart: "experimental.chat.system.transform"
 };
-function resolveFrameworkDependencyRange() {
-  const req = createRequire(import.meta.url);
-  for (const rel of ["../../../package.json", "../../package.json", "../package.json"]) {
-    try {
-      const pkg = req(rel);
-      if (pkg.name === AGENT_CONNECTOR_PACKAGE_NAME && typeof pkg.version === "string" && /^\d+\.\d+\.\d+/.test(pkg.version)) {
-        return `^${pkg.version}`;
-      }
-    } catch {
-    }
-  }
-  return "*";
-}
 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";
@@ -719,6 +694,400 @@ connector declared \`publish.author\` \u2014 set them to YOUR terms before \`npm
   return { files, pluginDir, ...notes.length > 0 ? { notes } : {} };
 };
 
+// src/core/package-formats/agent-plugin.ts
+import { join as join7 } from "path";
+var AGENT_PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+var AGENT_PLUGIN_MCP_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+var AGENT_PLUGIN_SPEC_VERSION = "1.0.0";
+var AGENT_PLUGIN_LAUNCHER = "bin/agent-connector.mjs";
+var CATALOG_NAME = "agent-connector";
+var CLIENT_NAMESPACES = [
+  {
+    namespace: "com.github.copilot",
+    label: "GitHub Copilot (CLI, VS Code, JetBrains)",
+    platform: "copilot-cli",
+    readers: ["copilot-cli", "vscode-copilot", "jetbrains-copilot"],
+    hookStyle: "plugin-root-launcher",
+    agentFile: (name) => `${name}.agent.md`,
+    commandFile: (name) => `${name}.md`,
+    manifestExtension: null
+  },
+  {
+    namespace: "com.openai",
+    label: "Codex / ChatGPT",
+    platform: "codex",
+    readers: ["codex"],
+    hookStyle: "home-bin",
+    agentFile: null,
+    commandFile: null,
+    manifestExtension: ({ hooks }) => hooks ? { hooks } : {}
+  }
+];
+var RESERVED_ENV_KEYS = /* @__PURE__ */ new Set(["PLUGIN_ROOT", "PLUGIN_DATA"]);
+function toAgentPluginName(id) {
+  let name = id.trim().toLowerCase().replace(/[^a-z0-9.-]+/g, "-").replace(/-{2,}/g, "-").replace(/\.{2,}/g, ".").replace(/(?:-\.|\.-)+/g, "-").replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, "");
+  if (name.length > 64) {
+    name = name.slice(0, 64).replace(/[^a-z0-9]+$/g, "");
+  }
+  return name.length > 0 ? name : "connector";
+}
+function isConformantCwd(cwd) {
+  return cwd.startsWith("./") || cwd === "${PLUGIN_ROOT}" || cwd.startsWith("${PLUGIN_ROOT}/") || cwd === "${PLUGIN_DATA}" || cwd.startsWith("${PLUGIN_DATA}/");
+}
+function isConformantCommand(command) {
+  if (command.startsWith("./")) return true;
+  return !command.includes("/") && !command.includes("\\");
+}
+var LAUNCHER_AT_ROOT = `\${PLUGIN_ROOT}/${AGENT_PLUGIN_LAUNCHER}`;
+function hookCommand(style, homeBin, platform, event, connectorId) {
+  if (style === "home-bin") {
+    return buildHomeBinHookCommand(homeBin, platform, event, connectorId);
+  }
+  return `node "${LAUNCHER_AT_ROOT}" hook ${platform} ${event} --connector ${connectorId}`;
+}
+function buildServerEntry(connector, hostHint, notes) {
+  const server = connector.server;
+  if (!server) return null;
+  const serverName = connector.id;
+  if (server.transport === "stdio") {
+    const realCommand = server.command ?? "";
+    if (realCommand === "") return null;
+    const realArgs = [...server.args ?? []];
+    let entry2;
+    let wrapped = false;
+    if (shouldWrapForTelemetry(server, connector.telemetry)) {
+      const flags = ["serve", "--connector", connector.id];
+      if (hostHint !== void 0) flags.push("--host", hostHint);
+      entry2 = {
+        type: "stdio",
+        command: "node",
+        args: [LAUNCHER_AT_ROOT, ...flags, "--", realCommand, ...realArgs]
+      };
+      wrapped = true;
+    } else {
+      entry2 = { type: "stdio", command: realCommand };
+      if (realArgs.length > 0) entry2.args = realArgs;
+      if (!isConformantCommand(realCommand)) {
+        notes.push(
+          `agent-plugin: server command "${realCommand}" is neither a bare executable name nor a plugin-relative ./ path \u2014 conforming clients may reject it (spec \xA77.2.1)`
+        );
+      }
+    }
+    const env = renderEnv(server.env);
+    if (env) {
+      const kept = {};
+      for (const [key, value] of Object.entries(env)) {
+        if (RESERVED_ENV_KEYS.has(key)) {
+          notes.push(
+            `agent-plugin: dropped env "${key}" \u2014 PLUGIN_ROOT / PLUGIN_DATA are reserved runtime variables a plugin cannot set`
+          );
+          continue;
+        }
+        kept[key] = value;
+      }
+      if (Object.keys(kept).length > 0) entry2.env = kept;
+    }
+    if (server.cwd) {
+      if (isConformantCwd(server.cwd)) {
+        entry2.cwd = server.cwd;
+      } else {
+        notes.push(
+          `agent-plugin: dropped cwd "${server.cwd}" \u2014 must be ./-relative, \${PLUGIN_ROOT}\u2026 or \${PLUGIN_DATA}\u2026 (the plugin root is used instead)`
+        );
+      }
+    }
+    return { serverName, entry: entry2, wrapped };
+  }
+  const url = server.url ?? "";
+  if (url === "") return null;
+  if (server.transport === "ws") {
+    notes.push(
+      `agent-plugin: dropped the "ws" server \u2014 Agent Plugins 1.0.0 defines only stdio, streamable-http and (legacy) sse transports`
+    );
+    return null;
+  }
+  const entry = {
+    type: server.transport === "sse" ? "sse" : "streamable-http",
+    url
+  };
+  const headers = renderEnv(server.headers);
+  if (headers) entry.headers = headers;
+  if (server.auth) {
+    notes.push(
+      `agent-plugin: the server's \`auth\` block is not portable \u2014 Agent Plugins carries only literal HTTP headers; the client handles authentication`
+    );
+  }
+  if (!/^https:\/\//i.test(url) && !/^http:\/\/(localhost|127\.\d+\.\d+\.\d+|\[::1\])(?:[:/]|$)/i.test(url)) {
+    notes.push(
+      `agent-plugin: remote url "${url}" is not HTTPS \u2014 the spec requires HTTPS for non-loopback endpoints`
+    );
+  }
+  return { serverName, entry, wrapped: false };
+}
+function buildNamespaceHooks(connector, ns, platform, homeBin) {
+  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: hookCommand(ns.hookStyle, homeBin, platform, event, connector.id)
+    };
+    hooks[event] = [matcher ? { matcher, hooks: [command] } : { hooks: [command] }];
+  }
+  return { hooks };
+}
+function buildManifest6(connector, extensions) {
+  const manifest = {
+    $schema: AGENT_PLUGIN_SCHEMA,
+    name: toAgentPluginName(connector.id)
+  };
+  if (connector.version && connector.version !== "0.0.0") {
+    manifest.version = connector.version;
+  }
+  manifest.description = `${connector.displayName} \u2014 connector emitted by agent-connector`;
+  const author = connector.publish?.author;
+  if (author?.name) {
+    const a = { name: author.name };
+    if (author.email) a.email = author.email;
+    if (author.url) a.url = author.url;
+    manifest.author = a;
+  }
+  if (Object.keys(extensions).length > 0) manifest.extensions = extensions;
+  return manifest;
+}
+function renderLauncher() {
+  const range = resolveFrameworkDependencyRange();
+  const spec = range === "*" ? AGENT_CONNECTOR_PACKAGE_NAME : `${AGENT_CONNECTOR_PACKAGE_NAME}@${range}`;
+  return `#!/usr/bin/env node
+/**
+ * AUTO-GENERATED by agent-connector \u2014 DO NOT EDIT.
+ *
+ * Portable launcher for the agent-connector runtime. Agent Plugins packages
+ * must not embed absolute paths, so this file resolves the runtime at run time:
+ *   1. $AGENT_CONNECTOR_HOME_BIN                       (explicit override)
+ *   2. <$AGENT_CONNECTOR_DATA_DIR | ~/.agent-connector>/bin/agent-connector  (the stable home binary)
+ *   3. \`agent-connector\` on PATH                       (a global install)
+ *   4. npx -y ${spec}   (network; last resort)
+ * stdio is inherited so the MCP stdio proxy and hook JSON pass straight through.
+ */
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+
+const win = process.platform === "win32";
+const argv = process.argv.slice(2);
+
+function onPath(name) {
+  const exts = win ? [".cmd", ".exe", ".bat", ""] : [""];
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const candidate = join(dir, name + ext);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+const dataRoot = process.env.AGENT_CONNECTOR_DATA_DIR || join(homedir(), ".agent-connector");
+const homeBin = join(dataRoot, "bin", win ? "agent-connector.cmd" : "agent-connector");
+const explicit = process.env.AGENT_CONNECTOR_HOME_BIN;
+
+let command;
+let args;
+const local = [explicit, homeBin].find((p) => p && existsSync(p)) ?? onPath("agent-connector");
+if (local) {
+  command = local;
+  args = argv;
+} else {
+  command = win ? "npx.cmd" : "npx";
+  args = ["-y", ${JSON.stringify(spec)}, ...argv];
+}
+
+// .cmd/.bat wrappers need the shell on Windows; everything else spawns directly.
+const shell = win && /\\.(cmd|bat)$/i.test(command);
+const child = spawn(command, args, { stdio: "inherit", windowsHide: true, shell });
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+  process.on(signal, () => child.kill(signal));
+}
+child.on("error", (err) => {
+  process.stderr.write(\`agent-connector launcher: cannot start \${command}: \${err.message}\\n\`);
+  process.exit(1);
+});
+child.on("exit", (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  process.exit(code ?? 1);
+});
+`;
+}
+function buildCatalog(connector) {
+  return {
+    name: CATALOG_NAME,
+    owner: { name: connector.publish?.author?.name ?? CATALOG_NAME },
+    plugins: [
+      {
+        name: connector.id,
+        source: `./${connector.id}`,
+        description: `${connector.displayName} \u2014 connector emitted by agent-connector`
+      }
+    ]
+  };
+}
+function buildReadme(connector, has) {
+  const lines = [
+    `# ${connector.displayName} \u2014 Agent Plugin`,
+    "",
+    `An [Agent Plugins ${AGENT_PLUGIN_SPEC_VERSION}](https://agent-plugins.org) package for the`,
+    `\`${connector.id}\` connector, emitted by agent-connector.`,
+    "",
+    "## Contents",
+    "",
+    "- `plugin.json` \u2014 the plugin manifest"
+  ];
+  if (has.mcp) lines.push("- `mcp.json` \u2014 the MCP server entry");
+  if (has.skills) lines.push("- `skills/<name>/SKILL.md` \u2014 Agent Skills");
+  for (const ns of has.namespaces) {
+    lines.push(
+      `- \`${ns.namespace}/\` \u2014 client extension namespace for ${ns.label} (other clients ignore it)`
+    );
+  }
+  if (has.launcher) {
+    lines.push(
+      `- \`${AGENT_PLUGIN_LAUNCHER}\` \u2014 portable launcher that locates the agent-connector runtime (home binary \u2192 PATH \u2192 npx) so per-tool token telemetry carries through without any absolute path in the bundle`
+    );
+  }
+  lines.push(
+    "",
+    "## Install",
+    "",
+    "Locally, the directory ABOVE this one is a marketplace root \u2014 register it and",
+    `install by name: \`copilot plugin marketplace add <root> && copilot plugin install ${connector.id}@${CATALOG_NAME}\``,
+    `or \`codex plugin marketplace add <root> && codex plugin add ${connector.id}@${CATALOG_NAME}\`.`,
+    "",
+    "To share it, push this directory to a git repository and install it from",
+    "source with your client's plugin flow \u2014 in VS Code run **Chat: Install Plugin",
+    "From Source** from the Command Palette and enter the repository URL. Every",
+    "Agent Plugins client has an equivalent: https://agent-plugins.org/compatible-clients",
+    ""
+  );
+  return lines.join("\n");
+}
+function readAgentPluginManifest(manifestJson) {
+  try {
+    const parsed = JSON.parse(manifestJson);
+    if (parsed.$schema !== AGENT_PLUGIN_SCHEMA) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+var emitAgentPlugin = (connector, ctx) => {
+  const { emit, files } = createEmitter(ctx.dryRun);
+  const pluginDir = join7(ctx.outDir, connector.id);
+  const notes = [];
+  const hostHint = ctx.hostHint;
+  const hasHooks = connector.hookEvents.some((e) => CLAUDE_MAPPED_EVENTS.has(e));
+  const populated = [];
+  const extensions = {};
+  const namespaceFiles = [];
+  let launcherHooks = false;
+  let homeBinHooks = false;
+  for (const ns of CLIENT_NAMESPACES) {
+    const extDir = join7(pluginDir, ns.namespace);
+    const platform = hostHint !== void 0 && ns.readers.includes(hostHint) ? hostHint : ns.platform;
+    const hooksRel = `${ns.namespace}/hooks/hooks.json`;
+    let wrote = false;
+    const hooksJson = hasHooks ? buildNamespaceHooks(connector, ns, platform, ctx.homeBinPath) : null;
+    if (hooksJson) {
+      namespaceFiles.push({ path: join7(extDir, "hooks", "hooks.json"), contents: json(hooksJson) });
+      if (ns.hookStyle === "plugin-root-launcher") launcherHooks = true;
+      else homeBinHooks = true;
+      wrote = true;
+    }
+    if (ns.commandFile) {
+      for (const cmd of connector.commands) {
+        namespaceFiles.push({
+          path: join7(extDir, "commands", ns.commandFile(cmd.name)),
+          contents: renderCommandMd(cmd)
+        });
+        wrote = true;
+      }
+    }
+    if (ns.agentFile) {
+      for (const agent of connector.subagents) {
+        namespaceFiles.push({
+          path: join7(extDir, "agents", ns.agentFile(agent.name)),
+          contents: renderSubagentMd(agent)
+        });
+        wrote = true;
+      }
+    }
+    if (!wrote) continue;
+    populated.push(ns);
+    if (ns.manifestExtension) {
+      const ext = ns.manifestExtension({ hooks: hooksJson ? `./${hooksRel}` : void 0 });
+      if (Object.keys(ext).length > 0) extensions[ns.namespace] = ext;
+    }
+  }
+  emit(join7(pluginDir, "plugin.json"), json(buildManifest6(connector, extensions)));
+  const mcp = buildServerEntry(connector, hostHint, notes);
+  if (mcp) {
+    emit(
+      join7(pluginDir, "mcp.json"),
+      json({
+        $schema: AGENT_PLUGIN_MCP_SCHEMA,
+        mcpServers: { [mcp.serverName]: mcp.entry }
+      })
+    );
+  }
+  for (const skill of connector.skills) {
+    const skillDir = join7(pluginDir, "skills", skill.name);
+    emit(join7(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);
+    }
+  }
+  for (const f of namespaceFiles) emit(f.path, f.contents);
+  if (populated.length > 0) {
+    notes.push(
+      `agent-plugin: hooks/commands/subagents are not portable Agent Plugins 1.0 components \u2014 emitted under the ${populated.map((ns) => `${ns.namespace}/`).join(", ")} client extension namespace(s); clients ignore namespaces they do not own`
+    );
+  }
+  const launcher = launcherHooks || mcp !== null && mcp.wrapped;
+  if (launcher) {
+    emit(join7(pluginDir, AGENT_PLUGIN_LAUNCHER), renderLauncher());
+    notes.push(
+      `agent-plugin: the MCP entry${launcherHooks ? " and Copilot hooks" : ""} run through the bundled launcher ${AGENT_PLUGIN_LAUNCHER} (no absolute path \u2014 resolves the home binary, then PATH, then npx ${AGENT_CONNECTOR_PACKAGE_NAME})`
+    );
+  }
+  if (homeBinHooks) {
+    notes.push(
+      `agent-plugin: com.openai/ hooks call this machine's agent-connector launcher (${ctx.homeBinPath}) \u2014 Codex documents no plugin-root token for hook commands; valid for a local install, re-run \`package\` per machine to share`
+    );
+  }
+  emit(
+    join7(pluginDir, "README.md"),
+    buildReadme(connector, {
+      mcp: mcp !== null,
+      skills: connector.skills.length > 0,
+      namespaces: populated,
+      launcher
+    })
+  );
+  const catalog = json(buildCatalog(connector));
+  const marketplacePath = join7(ctx.outDir, ".claude-plugin", "marketplace.json");
+  emit(marketplacePath, catalog);
+  emit(join7(ctx.outDir, ".agents", "plugins", "marketplace.json"), catalog);
+  const result = { files, pluginDir, marketplacePath };
+  if (notes.length > 0) result.notes = notes;
+  return result;
+};
+
 // src/core/package-formats/mcp-server.ts
 import { resolve as resolve2 } from "path";
 function buildEnvVars(server) {
@@ -960,10 +1329,14 @@ var emitMcpbBundle = (connector, ctx) => {
 };
 
 // src/core/package.ts
+var DEFAULT_PACKAGE_FORMAT = "agent-plugin";
+var LEGACY_FORMAT_ALIASES = {
+  "codex-plugin": "agent-plugin",
+  "copilot-plugin": "agent-plugin"
+};
 var EMITTERS = {
+  "agent-plugin": emitAgentPlugin,
   "claude-plugin": emitClaudePlugin,
-  "codex-plugin": emitCodexPlugin,
-  "copilot-plugin": emitCopilotPlugin,
   "factory-plugin": emitFactoryPlugin,
   "gemini-extension": emitGeminiExtension,
   "qwen-extension": emitQwenExtension,
@@ -975,9 +1348,8 @@ var EMITTERS = {
   mcpb: emitMcpbBundle
 };
 var ALL_FORMATS = [
+  "agent-plugin",
   "claude-plugin",
-  "codex-plugin",
-  "copilot-plugin",
   "factory-plugin",
   "gemini-extension",
   "qwen-extension",
@@ -989,9 +1361,8 @@ var ALL_FORMATS = [
   "mcpb"
 ];
 var FEASIBLE_FORMATS = [
+  "agent-plugin",
   "claude-plugin",
-  "codex-plugin",
-  "copilot-plugin",
   "factory-plugin",
   "gemini-extension",
   "qwen-extension",
@@ -1003,10 +1374,17 @@ var FEASIBLE_FORMATS = [
 function isPackageFormat(s) {
   return Object.prototype.hasOwnProperty.call(EMITTERS, s);
 }
+function resolvePackageFormat(s) {
+  if (isPackageFormat(s)) return { format: s };
+  const replacement = Object.prototype.hasOwnProperty.call(LEGACY_FORMAT_ALIASES, s) ? LEGACY_FORMAT_ALIASES[s] : void 0;
+  if (replacement === void 0) return null;
+  return {
+    format: replacement,
+    deprecation: `--format ${s} is retired \u2014 emitting ${replacement} instead (the Agent Plugins 1.0.0 bundle both Codex and GitHub Copilot install natively)`
+  };
+}
 var HOME_BIN_EMBED_FORMATS = /* @__PURE__ */ new Set([
   "claude-plugin",
-  "codex-plugin",
-  "copilot-plugin",
   "factory-plugin",
   "gemini-extension",
   "qwen-extension",
@@ -1015,7 +1393,7 @@ var HOME_BIN_EMBED_FORMATS = /* @__PURE__ */ new Set([
   "kimi-plugin"
 ]);
 function packageConnector(connector, opts) {
-  const format = opts.format ?? "claude-plugin";
+  const format = opts.format ?? DEFAULT_PACKAGE_FORMAT;
   const emitter = EMITTERS[format];
   if (!emitter) {
     throw new Error(`unsupported package format: ${format}`);
@@ -1025,6 +1403,7 @@ function packageConnector(connector, opts) {
     homeBinPath: opts.homeBinPath ?? homeBinPath(),
     dryRun: opts.dryRun ?? false
   };
+  if (opts.hostHint !== void 0) ctx.hostHint = opts.hostHint;
   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`;
@@ -1048,46 +1427,43 @@ function packageConnectorAll(connector, opts) {
 }
 function installInstructions(format, id, outDir) {
   switch (format) {
+    case "agent-plugin":
+      return [
+        `copilot plugin marketplace add ${outDir} && copilot plugin install ${id}@agent-connector`,
+        `codex plugin marketplace add ${outDir} && codex plugin add ${id}@agent-connector`,
+        `(share: push ${join8(outDir, id)} to a git repo, then VS Code \u2192 "Chat: Install Plugin From Source" <repo url>;`,
+        ` Kiro / Hermes / Cursor / other clients: https://agent-plugins.org/compatible-clients)`
+      ];
     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 "copilot-plugin":
-      return [
-        `copilot plugin marketplace add ${outDir}`,
-        `copilot plugin install ${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)}`];
+      return [`gemini extensions install ${join8(outDir, id)}`];
     case "qwen-extension":
-      return [`qwen extensions install ${join7(outDir, id)}`];
+      return [`qwen extensions install ${join8(outDir, id)}`];
     case "agy-plugin":
       return [
-        `agy plugin install ${join7(outDir, id)}`,
-        `(validate: agy plugin validate ${join7(outDir, id)})`
+        `agy plugin install ${join8(outDir, id)}`,
+        `(validate: agy plugin validate ${join8(outDir, id)})`
       ];
     case "cursor-plugin":
       return [
-        `link ${join7(outDir, id)} into ~/.cursor/plugins/local/${id}/ then Developer: Reload Window`,
+        `link ${join8(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)}`];
+      return [`kimi plugin install ${join8(outDir, id)}`];
     case "npm-plugin":
       return [
-        `npm publish ${join7(outDir, id)}  (then: opencode plugin install <pkg> | kilo plugin <pkg> | pi install npm:<pkg>)`
+        `npm publish ${join8(outDir, id)}  (then: opencode plugin install <pkg> | kilo plugin <pkg> | pi install npm:<pkg>)`
       ];
     case "mcp-server-json":
       return [
@@ -1096,7 +1472,7 @@ function installInstructions(format, id, outDir) {
       ];
     case "mcpb":
       return [
-        `vendor your built server under ${join7(outDir, "server")}/ (see the emitted README)`,
+        `vendor your built server under ${join8(outDir, "server")}/ (see the emitted README)`,
         `npx @anthropic-ai/mcpb pack ${outDir}   (then optionally: mcpb sign)`
       ];
     default:
@@ -1105,11 +1481,13 @@ function installInstructions(format, id, outDir) {
 }
 
 export {
+  readAgentPluginManifest,
+  DEFAULT_PACKAGE_FORMAT,
   ALL_FORMATS,
   FEASIBLE_FORMATS,
-  isPackageFormat,
+  resolvePackageFormat,
   packageConnector,
   packageConnectorAll,
   installInstructions
 };
-//# sourceMappingURL=chunk-N4STCQGP.js.map
+//# sourceMappingURL=chunk-U2XJWG7N.js.map