@wntic/ocm 0.1.0 → 0.2.0

package/README.md

@@ -79,7 +79,8 @@ automatic migration (below) prints the old → new mapping when it relinks.
 
 ```
 my-marketplace/
-├── marketplace.json              # optional
+├── .opencode-plugin/
+│   └── marketplace.json      # optional
 └── plugins/
     ├── demo-kit/
     │   ├── plugin.json           # optional
@@ -123,6 +124,10 @@ marketplace root.
 
 ### `marketplace.json`
 
+The manifest lives at `.opencode-plugin/marketplace.json`. A root
+`marketplace.json` still works — `ocm validate` warns — but new marketplaces
+should use the new location.
+
 ```json
 {
   "name": "my-marketplace",
@@ -144,8 +149,10 @@ marketplace root.
 ```
 
 Only a plugin entry's `name` and `source` are required. `source` is a
-`./`-relative path inside the marketplace — `../` and absolute paths are
-rejected; the marketplace repo is the distribution unit. `defaultEnabled:
+`./`-relative path inside the marketplace — it says where the plugin is.
+`mcpServers` is `./`-relative inside the plugin directory — it says what is
+in the plugin. `../` and absolute paths are rejected; the marketplace repo is
+the distribution unit. `defaultEnabled:
 false` keeps a plugin disabled in an `auto` marketplace.
 
 ### `plugin.json`

package/loader/core.d.ts

@@ -241,6 +241,7 @@ export declare function discoverMarketplace(marketplaceDir: string): CoreDiscove
 export declare function discoveryError(plugins: CoreManifestPlugin[]): string | null
 export declare function nameDisagreement(pluginDir: string, pluginName: string): string | null
 export declare function readManifest(marketplaceDir: string): { name?: string; description?: string }
+export declare function marketplaceManifestFile(marketplaceDir: string): string
 export declare function componentRoot(entry: CoreMarketplaceEntry): string
 export declare function incumbentMarketplace(registry: CoreRegistry, self: string, pluginName: string): string | undefined
 export declare function registerPlugins(registry: CoreRegistry, name: string, plugins: CoreManifestPlugin[]): void

package/loader/core.js

@@ -26,7 +26,7 @@ export { setSkillsPath } from "./config.js"
 export { git, isGitRepo, pullRepo, syncAll } from "./sync.js"
 export { denyEntry, executableComponents, grantEntry, trustFingerprint } from "./trust.js"
 export { isGitUrl, manifestName, marketplaceNameFromUrl, normaliseMarketplaceName, parseSource } from "./source.js"
-export { discoveryError, discoverMarketplace, nameDisagreement, readManifest } from "./manifest.js"
+export { discoveryError, discoverMarketplace, marketplaceManifestFile, nameDisagreement, readManifest } from "./manifest.js"
 export {
   addMarketplace,
   componentRoot,

package/loader/discovery.js

@@ -66,20 +66,62 @@ function listJsFiles(pluginDir, dirs) {
   return [...names].sort()
 }
 
-// mcp.json holds opencode's mcp entry shape; the server names are its keys
-function listMcpServers(pluginDir) {
+// An Agent Plugins server entry, translated to opencode's mcp shape. Only the
+// fields opencode has a home for survive: it has no equivalent of `cwd`.
+function toOpencodeServer(entry) {
+  if (entry.type === "stdio") {
+    // AP requires "command"; without it the file is malformed and the entry
+    // is skipped rather than materialized as a broken server (spec 14 §9)
+    if (typeof entry.command !== "string") return null
+    const args = Array.isArray(entry.args) ? entry.args : []
+    const server = { type: "local", command: [entry.command, ...args], enabled: true }
+    if (isRecord(entry.env)) server.environment = entry.env
+    return server
+  }
+  if (entry.type === "streamable-http" || entry.type === "sse") {
+    const server = { type: "remote", url: entry.url, enabled: true }
+    if (isRecord(entry.headers)) server.headers = entry.headers
+    return server
+  }
+  return entry
+}
+
+// A plugin's mcp.json is either opencode's own shape — a bare map of server
+// name to entry — or the Agent Plugins shape, `{ $schema, mcpServers }`, which
+// Codex and Cursor read. Accepting both means one file per plugin serves every
+// client and the two cannot drift apart.
+export function readMcpServers(file) {
+  let parsed
   try {
-    const parsed = JSON.parse(readFileSync(join(pluginDir, "mcp.json"), "utf8"))
-    if (isRecord(parsed)) return Object.keys(parsed).sort()
-  } catch {}
-  return []
+    parsed = JSON.parse(readFileSync(file, "utf8"))
+  } catch {
+    return null
+  }
+  if (!isRecord(parsed)) return null
+  if (!isRecord(parsed.mcpServers)) return parsed
+  const servers = {}
+  for (const [name, entry] of Object.entries(parsed.mcpServers)) {
+    if (!isRecord(entry)) continue
+    const server = toOpencodeServer(entry)
+    if (server !== null) servers[name] = server
+  }
+  return servers
+}
+
+function listMcpServers(pluginDir) {
+  const servers = readMcpServers(join(pluginDir, "mcp.json"))
+  return servers ? Object.keys(servers).sort() : []
 }
 
 // the mcp source file: the marketplace entry's mcpServers path when it
-// declares one, else the plugin directory's own mcp.json (spec 06)
+// declares one, else the plugin directory's own mcp.json (spec 06). The
+// declared path is plugin-relative; the marketplace root is a deprecated
+// fallback discovery has already warned about (spec 15 §3)
 export function mcpSourceFile(dir, entry, plugin) {
   const declared = entry?.plugins?.[plugin.name]?.manifest?.mcpServers
-  return typeof declared === "string" ? join(dir, declared) : join(plugin.dir, "mcp.json")
+  if (typeof declared !== "string") return join(plugin.dir, "mcp.json")
+  const pluginFile = join(plugin.dir, declared.slice(2))
+  return existsSync(pluginFile) ? pluginFile : join(dir, declared.slice(2))
 }
 
 // a name defined in both the singular and plural form of a component

package/loader/manifest.js

@@ -32,6 +32,13 @@ function metadataFrom(raw) {
   if (Array.isArray(raw.keywords) && raw.keywords.every((keyword) => typeof keyword === "string")) {
     manifest.keywords = raw.keywords
   }
+  // spec 14: category/tags under extensions["dev.wntic.ocm"] win over the
+  // top-level form, which stays readable for marketplaces that predate it
+  const ext = isRecord(raw.extensions) ? raw.extensions["dev.wntic.ocm"] : undefined
+  if (isRecord(ext)) {
+    if (typeof ext.category === "string") manifest.category = ext.category
+    if (Array.isArray(ext.tags) && ext.tags.every((tag) => typeof tag === "string")) manifest.tags = ext.tags
+  }
   return manifest
 }
 
@@ -47,10 +54,29 @@ export function nameDisagreement(pluginDir, pluginName) {
   )
 }
 
-function readEntries(marketplaceDir) {
+// spec 15: .opencode-plugin/marketplace.json wins; the root path stays legal
+export function marketplaceManifestFile(marketplaceDir) {
+  const preferred = join(marketplaceDir, ".opencode-plugin", "marketplace.json")
+  if (existsSync(preferred)) return preferred
+  return join(marketplaceDir, "marketplace.json")
+}
+
+function readEntries(marketplaceDir, warnings) {
   const entries = new Map()
-  const raw = readJsonRecord(join(marketplaceDir, "marketplace.json"))
-  if (!Array.isArray(raw?.plugins)) return entries
+  const file = marketplaceManifestFile(marketplaceDir)
+  if (!existsSync(file)) return entries
+  let raw
+  try {
+    raw = JSON.parse(readFileSync(file, "utf8"))
+  } catch {
+    raw = undefined
+  }
+  if (!isRecord(raw)) {
+    // a broken manifest is reported, never routed around (spec 15 §4)
+    warnings.push(`${file}: not a valid JSON object — the manifest is ignored`)
+    return entries
+  }
+  if (!Array.isArray(raw.plugins)) return entries
   for (const entry of raw.plugins) {
     if (isRecord(entry) && typeof entry.name === "string") entries.set(entry.name, entry)
   }
@@ -59,7 +85,7 @@ function readEntries(marketplaceDir) {
 
 export function discoverMarketplace(marketplaceDir) {
   const warnings = []
-  const entries = readEntries(marketplaceDir)
+  const entries = readEntries(marketplaceDir, warnings)
   const plugins = new Map()
   for (const plugin of discoverPlugins(marketplaceDir)) {
     const entry = entries.get(plugin.name)
@@ -77,11 +103,27 @@ export function discoverMarketplace(marketplaceDir) {
     const components = { ...plugin.components }
     if (typeof entry?.defaultEnabled === "boolean") manifest.defaultEnabled = entry.defaultEnabled
     if (typeof entry?.mcpServers === "string") {
+      // spec 15 §3: plugin-relative first, the marketplace root is deprecated
       const rel = relativePath(entry.mcpServers)
-      const servers = rel === null ? undefined : readJsonRecord(join(marketplaceDir, rel))
+      const pluginFile = rel === null ? null : join(plugin.dir, rel)
+      const marketplaceFile = rel === null ? null : join(marketplaceDir, rel)
+      const inPlugin = pluginFile !== null && existsSync(pluginFile)
+      const inMarketplace = marketplaceFile !== null && existsSync(marketplaceFile)
+      const servers = inPlugin ? readJsonRecord(pluginFile) : inMarketplace ? readJsonRecord(marketplaceFile) : undefined
       if (servers) {
         manifest.mcpServers = entry.mcpServers
         components.mcp = Object.keys(servers).sort()
+        if (inPlugin && inMarketplace && pluginFile !== marketplaceFile) {
+          warnings.push(
+            `plugin "${plugin.name}": mcpServers "${entry.mcpServers}" resolves to both ${pluginFile} and ${marketplaceFile}` +
+              "; the plugin-relative file wins",
+          )
+        } else if (!inPlugin && inMarketplace) {
+          warnings.push(
+            `plugin "${plugin.name}": mcpServers "${entry.mcpServers}" resolves only against the marketplace root — deprecated;` +
+              ` expected ${pluginFile}, found ${marketplaceFile}`,
+          )
+        }
       } else {
         warnings.push(`plugin "${plugin.name}": mcpServers path "${entry.mcpServers}" is not a JSON object in ${marketplaceDir}`)
       }
@@ -144,7 +186,7 @@ function tuiModule(plugin) {
 }
 
 export function readManifest(marketplaceDir) {
-  const file = join(marketplaceDir, "marketplace.json")
+  const file = marketplaceManifestFile(marketplaceDir)
   if (!existsSync(file)) return {}
   try {
     const parsed = JSON.parse(readFileSync(file, "utf8"))

package/loader/mcp.js

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
-import { mcpSourceFile, PLUGIN_NAME_RE } from "./discovery.js"
+import { mcpSourceFile, PLUGIN_NAME_RE, readMcpServers } from "./discovery.js"
 import { OPENCODE_CONFIG_FILE, OPENCODE_DIR } from "./paths.js"
 import { isRecord } from "./registry.js"
 import { componentKey } from "./trust.js"
@@ -64,11 +64,7 @@ export function syncMcp(plugins, dir, entry, enabled, approved, warnings) {
     if (enabled !== null && !enabled.has(plugin.name)) continue
     const file = mcpSourceFile(dir, entry, plugin)
     if (!(plugin.components.mcp ?? []).length && !existsSync(file)) continue
-    let servers = null
-    try {
-      const parsed = JSON.parse(readFileSync(file, "utf8"))
-      if (isRecord(parsed)) servers = parsed
-    } catch {}
+    const servers = readMcpServers(file)
     if (servers === null) {
       warnings.push(`skipped ${file}: not a JSON object`)
       continue

package/loader/trust.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto"
 import { readFileSync } from "node:fs"
 import { join, relative } from "node:path"
-import { discoverPlugins, mcpSourceFile } from "./discovery.js"
+import { discoverPlugins, mcpSourceFile, readMcpServers } from "./discovery.js"
 import { isRecord } from "./registry.js"
 
 // canonical JSON: keys sorted at every level, so reordering mcp.json leaves a
@@ -48,11 +48,9 @@ export function executableComponents(dir, entry) {
       })
     }
     const mcpFile = mcpSourceFile(dir, entry, plugin)
-    let servers = null
-    try {
-      const parsed = JSON.parse(readFileSync(mcpFile, "utf8"))
-      if (isRecord(parsed)) servers = parsed
-    } catch {}
+    // both mcp.json shapes, so the fingerprint covers the servers that will
+    // actually run rather than an Agent Plugins wrapper key
+    const servers = readMcpServers(mcpFile)
     for (const [server, value] of Object.entries(servers ?? {})) {
       components.push({
         rel: `${relative(dir, mcpFile)}:${server}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wntic/ocm",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "File-based plugin marketplace for opencode: skills, agents, commands distributed via git repos",
   "type": "module",
   "bin": {

package/src/commands/validate.ts

@@ -6,11 +6,15 @@ import { join, relative } from "node:path"
 import { dirClashes, discoverPlugins, lintCrossTool } from "../../loader/core.js"
 import type { CoreDiscoveredPlugin } from "../../loader/core.js"
 import { error, reportFindings, warning, type Finding } from "../findings"
-import { NAME_RE, lintMarketplaceJson, lintMcpJson, lintPluginJson, type MarketplaceManifest } from "../manifest-lint"
+import { NAME_RE, lintMarketplaceJson, lintMcpJson, lintPluginJson, lintSkillDepth, type MarketplaceManifest } from "../manifest-lint"
 import { lintMarkdown, lintPluginJs, lintSkill } from "./validate-files"
 
 const TYPO_FILES = new Set(["plugin.ts", "SKILLS.md", "Skill.md"])
 
+// spec 14 §3: the Agent Plugins name charset — a-z 0-9 - ., alphanumeric at
+// both ends, 1–64 chars
+const AP_NAME_RE = /^[a-z0-9]([a-z0-9.-]*[a-z0-9])?$/
+
 export function validate(path?: string): void {
   const root = path ?? process.cwd()
   if (!existsSync(root)) throw new Error(`marketplace directory "${root}" does not exist`)
@@ -33,7 +37,20 @@ function lintPlugin(
   findings: Finding[],
 ): void {
   const rel = relative(root, plugin.dir) || "."
-  if (!NAME_RE.test(plugin.name)) findings.push(error(`${rel}: directory name must match ${NAME_RE}`))
+  if (!NAME_RE.test(plugin.name)) {
+    // spec 14 §3: an AP-valid name gets the namespacing explanation, not a
+    // bare regex failure — ocm's stricter rule stays
+    if (AP_NAME_RE.test(plugin.name) && plugin.name.length <= 64) {
+      findings.push(
+        error(
+          `${rel}: name "${plugin.name}" is valid Agent Plugins but not ocm — plugin names become command and agent` +
+            " namespaces on disk (<plugin>:<item>.md), and a dot there is a new failure surface; rename to kebab-case",
+        ),
+      )
+    } else {
+      findings.push(error(`${rel}: directory name must match ${NAME_RE}`))
+    }
+  }
   if (plugin.name.length > 64) findings.push(error(`${rel}: directory name is longer than 64 characters`))
   for (const clash of dirClashes(plugin.dir)) {
     findings.push(error(`${rel}: ${clash} — both produce the same materialized name`))
@@ -42,6 +59,7 @@ function lintPlugin(
   const record = lintPluginJson(root, plugin.dir, plugin.name, findings)
   lintMcpJson(root, plugin.dir, findings)
   const entry = manifest.entries.get(plugin.name)
+  lintMcpServersBase(root, plugin, entry, findings)
   const fromMarketplace = typeof entry?.version === "string" ? entry.version : undefined
   const fromPlugin = typeof record?.version === "string" ? record.version : undefined
   if (fromMarketplace && fromPlugin && fromMarketplace !== fromPlugin) {
@@ -56,11 +74,33 @@ function lintPlugin(
   for (const dir of plugin.components.skill ?? []) {
     lintSkill(root, plugin, dir, skills, findings)
   }
+  lintSkillDepth(root, plugin.dir, plugin.components.skill ?? [], findings)
   for (const file of plugin.components.plugin ?? []) {
     lintPluginJs(root, plugin, file, findings)
   }
 }
 
+// spec 15 §3: mcpServers resolves against the plugin directory; a value
+// that resolves only against the marketplace root is deprecated
+function lintMcpServersBase(
+  root: string,
+  plugin: CoreDiscoveredPlugin,
+  entry: Record<string, unknown> | undefined,
+  findings: Finding[],
+): void {
+  const mcpServers = entry?.mcpServers
+  if (typeof mcpServers !== "string" || !mcpServers.startsWith("./") || mcpServers.split("/").includes("..")) return
+  const pluginFile = join(plugin.dir, mcpServers.slice(2))
+  const marketplaceFile = join(root, mcpServers.slice(2))
+  if (existsSync(pluginFile) || !existsSync(marketplaceFile)) return
+  findings.push(
+    warning(
+      `${relative(root, plugin.dir)}: mcpServers "${mcpServers}" resolves only against the marketplace root — deprecated; ` +
+        `expected ${relative(root, pluginFile)}, found ${relative(root, marketplaceFile)}`,
+    ),
+  )
+}
+
 function lintTypos(rel: string, pluginDir: string, findings: Finding[]): void {
   if (existsSync(join(pluginDir, "skills")) && existsSync(join(pluginDir, "skill"))) {
     findings.push(warning(`${rel}: both "skill" and "skills" exist — one is probably a typo`))

package/src/discovery.ts

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs"
 import { join } from "node:path"
+import { marketplaceManifestFile } from "../loader/core.js"
 import type { DiscoveredPlugin } from "./types"
 
 export { discoverMarketplace, discoveryError, nameDisagreement, readManifest } from "../loader/core.js"
@@ -31,6 +32,6 @@ function collectRenames(raw: Record<string, unknown> | undefined, into: Record<s
 export function readRenames(marketplaceDir: string, plugins: DiscoveredPlugin[]): Record<string, string | null> {
   const renames: Record<string, string | null> = {}
   for (const plugin of plugins) collectRenames(readJsonRecord(join(plugin.dir, "plugin.json")), renames)
-  collectRenames(readJsonRecord(join(marketplaceDir, "marketplace.json")), renames)
+  collectRenames(readJsonRecord(marketplaceManifestFile(marketplaceDir)), renames)
   return renames
 }

package/src/manifest-lint.ts

@@ -3,11 +3,15 @@
 // dependency; the schema files exist for editors).
 import { existsSync, readFileSync } from "node:fs"
 import { join, relative } from "node:path"
-import { readRegistry } from "../loader/core.js"
+import { marketplaceManifestFile, readRegistry } from "../loader/core.js"
 import { error, warning, type Finding } from "./findings"
 
 export const NAME_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/
 
+// spec 14 §2: pinned to 1.0.0, the published version — 1.1.0 is a Working
+// Draft and a floating identifier is forbidden by §5.2 of the standard
+const AP_PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json"
+
 const STRING_FIELDS = ["description", "version", "category", "homepage", "repository", "license"]
 const ARRAY_FIELDS = ["tags", "keywords"]
 
@@ -126,7 +130,29 @@ export interface MarketplaceManifest {
 
 export function lintMarketplaceJson(root: string, findings: Finding[]): MarketplaceManifest {
   const manifest: MarketplaceManifest = { entries: new Map() }
-  const file = join(root, "marketplace.json")
+  // spec 14 §5: Codex's plugin manifest directory is not a catalog location,
+  // so this file is dead weight no client reads
+  const codexCatalog = join(root, ".codex-plugin", "marketplace.json")
+  if (existsSync(codexCatalog)) {
+    findings.push(
+      warning(`${relative(root, codexCatalog)}: not a catalog location — Codex reads .agents/plugins/marketplace.json; remove this file`),
+    )
+  }
+  // spec 15 §2: both manifest locations present — the new path wins
+  const rootFile = join(root, "marketplace.json")
+  const file = marketplaceManifestFile(root)
+  if (file !== rootFile && existsSync(rootFile)) {
+    findings.push(
+      warning(`${relative(root, rootFile)}: ignored — ${relative(root, file)} wins; remove one of the two manifests`),
+    )
+  }
+  // spec 15 §4: not ocm's business to police, but opencode reads .opencode/
+  // as project config when the repo is opened in it
+  if (existsSync(join(root, ".opencode"))) {
+    findings.push(
+      warning(".opencode/: opencode reads this directory as project config — opening this repo in opencode injects its contents"),
+    )
+  }
   if (!existsSync(file)) return manifest
   const rel = relative(root, file)
   const parsed = parseJson(file, rel, findings)
@@ -165,6 +191,22 @@ export function lintPluginJson(
   const parsed = parseJson(file, rel, findings)
   if (!parsed) return undefined
   lintFields(rel, parsed, findings)
+  // spec 14 §7: only an unrecognised $schema is an error — a non-conformant
+  // plugin still works perfectly well in opencode
+  if (parsed.$schema === undefined) {
+    findings.push(warning(`${rel}: no "$schema" — not installable by Codex; pin to ${AP_PLUGIN_SCHEMA}`))
+  } else if (parsed.$schema !== AP_PLUGIN_SCHEMA) {
+    findings.push(error(`${rel}: "$schema" ${JSON.stringify(parsed.$schema)} is not recognised — pin to ${AP_PLUGIN_SCHEMA}`))
+  }
+  const legacy = ["category", "tags"].filter((key) => parsed[key] !== undefined)
+  if (legacy.length) {
+    findings.push(
+      warning(`${rel}: top-level ${legacy.map((key) => `"${key}"`).join(", ")} — move under extensions["dev.wntic.ocm"]`),
+    )
+  }
+  if (parsed.extensions !== undefined && !isRecord(parsed.extensions)) {
+    findings.push(warning(`${rel}: "extensions" is not an object — reported and ignored`))
+  }
   if (parsed.author !== undefined && !isRecord(parsed.author)) {
     findings.push(error(`${rel}: "author" must be an object`))
   }
@@ -175,15 +217,39 @@ export function lintPluginJson(
   return parsed
 }
 
+// spec 14 §7: Agent Plugins discovers only immediate children of skills/, so
+// a deeper skill is invisible to Codex and Cursor even though ocm installs it
+export function lintSkillDepth(root: string, pluginDir: string, skills: string[], findings: Finding[]): void {
+  for (const dir of skills) {
+    if (!dir.includes("/")) continue
+    findings.push(
+      warning(
+        `${relative(root, pluginDir)}/skills/${dir}: skill nested deeper than an immediate child of skills/` +
+          " — ocm materializes it, but Codex and Cursor will not see it",
+      ),
+    )
+  }
+}
+
 export function lintMcpJson(root: string, pluginDir: string, findings: Finding[]): void {
   const file = join(pluginDir, "mcp.json")
   if (!existsSync(file)) return
   const rel = relative(root, file)
   const parsed = parseJson(file, rel, findings)
   if (!parsed) return
-  for (const [server, value] of Object.entries(parsed)) {
+  // Either opencode's own shape — a bare map of server name to entry — or the
+  // Agent Plugins shape, `{ $schema, mcpServers }`. Both are accepted, so one
+  // file per plugin serves opencode, Codex and Cursor alike.
+  const mcpServers = isRecord(parsed.mcpServers) ? parsed.mcpServers : undefined
+  const servers = mcpServers ?? parsed
+  for (const [server, value] of Object.entries(servers)) {
+    if (server === "$schema") continue
     if (!isRecord(value) || value.type === undefined) {
       findings.push(error(`${rel}: entry "${server}" is missing "type"`))
+    } else if (mcpServers !== undefined && value.type === "stdio" && typeof value.command !== "string") {
+      // AP requires "command", so the file is malformed; the entry is skipped
+      // at install time too (spec 14 §9)
+      findings.push(warning(`${rel}: entry "${server}" is missing "command" — skipped; Agent Plugins requires it`))
     }
   }
 }

package/template/.claude-plugin/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "demo-marketplace",
+  "owner": { "name": "ocm" },
+  "description": "Example marketplace shared by ocm and Claude Code",
+  "plugins": [
+    {
+      "name": "release-kit",
+      "source": "./plugins/release-kit",
+      "description": "Release helpers, authored for both opencode and Claude Code"
+    }
+  ]
+}

package/template/plugins/demo-kit/mcp.json

@@ -1,3 +1,7 @@
 {
-  "time": { "type": "local", "command": ["date"], "enabled": true }
+  "everything": {
+    "type": "local",
+    "command": ["npx", "-y", "@modelcontextprotocol/server-everything"],
+    "enabled": true
+  }
 }

package/template/plugins/demo-kit/plugin.json

@@ -1,6 +1,9 @@
 {
-  "description": "One command, agent, skill, plugin and mcp server — the demo kit",
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "demo-kit",
   "version": "0.1.0",
-  "category": "example",
-  "tags": ["demo"]
+  "description": "One command, agent, skill, plugin and mcp server — the demo kit",
+  "extensions": {
+    "dev.wntic.ocm": { "category": "example", "tags": ["demo"] }
+  }
 }

package/template/plugins/release-kit/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "release-kit",
+  "description": "Ship a release and write its notes — the cross-tool demo kit",
+  "version": "0.1.0",
+  "author": { "name": "ocm" },
+  "commands": "./commands.claude"
+}

package/template/plugins/release-kit/plugin.json

@@ -1,6 +1,9 @@
 {
-  "description": "Ship a release and write its notes — the cross-tool demo kit",
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "release-kit",
   "version": "0.1.0",
-  "category": "example",
-  "tags": ["release"]
+  "description": "Ship a release and write its notes — the cross-tool demo kit",
+  "extensions": {
+    "dev.wntic.ocm": { "category": "example", "tags": ["release"] }
+  }
 }