@wntic/ocm 0.1.0

package/loader/marketplace.js

@@ -0,0 +1,199 @@
+import { rmSync } from "node:fs"
+import { join, relative } from "node:path"
+import { setSkillsPath } from "./config.js"
+import { discoverMarketplace, discoveryError, readManifest } from "./manifest.js"
+import { enabledPlugins, materialize, removeLinksFor } from "./materialize.js"
+import { removeMcpKeys } from "./mcp.js"
+import { LINKS_DIR } from "./paths.js"
+import { loadRegistryForWrite, saveRegistry } from "./registry.js"
+import { manifestName, normaliseMarketplaceName, parseSource, placeClone } from "./source.js"
+import { git } from "./sync.js"
+import { denyEntry, executableComponents, grantEntry } from "./trust.js"
+
+// discovery roots at the subdir when the source was a tree url; git
+// operations keep running against the clone root (spec 05)
+export function componentRoot(entry) {
+  return entry.subdir ? join(entry.dir, entry.subdir) : entry.dir
+}
+
+// plugin names are globally unique across marketplaces (spec 04, axis 4):
+// the first marketplace to provide a name is the incumbent
+export function incumbentMarketplace(registry, self, pluginName) {
+  for (const [name, entry] of Object.entries(registry.marketplaces)) {
+    if (name !== self && entry.plugins[pluginName]) return name
+  }
+}
+
+export function registerPlugins(registry, name, plugins) {
+  // every caller assigns or verifies the entry in the registry right before this
+  const entry = registry.marketplaces[name]
+  const root = componentRoot(entry)
+  const updated = {}
+  for (const plugin of plugins) {
+    const existing = entry.plugins[plugin.name]
+    const incumbent = incumbentMarketplace(registry, name, plugin.name)
+    // a colliding name registers disabled; a collision that has cleared
+    // registers as if fresh — enabled in auto, and in explicit only when
+    // the user installed it while it was colliding. A collision record
+    // was never chosen, so installedAt stays null (spec 02)
+    let enabled = existing?.collision
+      ? entry.mode === "auto" || existing.installedAt !== null
+      : existing?.enabled ?? (entry.mode !== "explicit" && plugin.manifest.defaultEnabled !== false)
+    if (incumbent) enabled = false
+    const record = {
+      source: relative(root, plugin.dir),
+      components: plugin.components,
+      enabled,
+      installedAt: existing?.installedAt ?? (incumbent || entry.mode === "explicit" || !enabled ? null : entry.addedAt),
+      version: plugin.manifest.version ?? null,
+      manifest: plugin.manifest,
+    }
+    if (incumbent) record.collision = incumbent
+    updated[plugin.name] = record
+  }
+  entry.plugins = updated
+}
+
+// spec 04, axis 4: plugin names are globally unique across marketplaces;
+// adding a marketplace that ships a taken name fails with both sources named
+function collisionError(registry, name, plugins) {
+  for (const plugin of plugins) {
+    const incumbent = incumbentMarketplace(registry, name, plugin.name)
+    if (incumbent) {
+      return `plugin "${plugin.name}" is already provided by marketplace "${incumbent}"; not adding "${name}". Remove one, or ask its author to rename.`
+    }
+  }
+  return null
+}
+
+// a failed add leaves no clone behind (a local directory is the user's);
+// the discovery warnings ride the error so a refusal cannot swallow them
+function addRefusal(message, warnings, parsed, dir) {
+  if (parsed.isGit) rmSync(dir, { recursive: true, force: true })
+  const error = new Error(message)
+  error.warnings = warnings
+  throw error
+}
+
+// spec 05 add, minus the dialog: register, decide trust from the flag, save,
+// materialize. With no flag the trust stays "none" and the executable
+// components ship blocked, named in trustComponents for the prompt to render.
+export async function addMarketplace(source, options = {}) {
+  const parsed = parseSource(source)
+  const { registry, wasV1 } = loadRegistryForWrite()
+  const mode = options.explicit ? "explicit" : "auto"
+  const ref = options.ref ?? parsed.ref
+  const fallback = parsed.isGit ? parsed.name : manifestName(readManifest(parsed.url).name) ?? parsed.name
+  const wanted = options.name ? normaliseMarketplaceName(options.name) : fallback
+  if (registry.marketplaces[wanted]) {
+    throw new Error(`marketplace "${wanted}" already added (use "ocm update ${wanted}")`)
+  }
+  const { name, dir } = parsed.isGit
+    ? await placeClone(parsed, wanted, ref, registry, options.name !== undefined)
+    : { name: wanted, dir: parsed.url }
+  const root = parsed.subdir ? join(dir, parsed.subdir) : dir
+  const discovered = discoverMarketplace(root)
+  const plugins = [...discovered.plugins.values()]
+  if (!plugins.length) {
+    addRefusal(
+      `no plugins found in ${parsed.url}\n` +
+        `  expected plugins/<name>/{commands,agents,skills}/ at the repository root\n` +
+        `  run \`ocm scan ${parsed.url}\` to see what was found`,
+      discovered.warnings, parsed, dir,
+    )
+  }
+  const refusal = discoveryError(plugins)
+  if (refusal) addRefusal(refusal, discovered.warnings, parsed, dir)
+  const collision = collisionError(registry, name, plugins)
+  if (collision) addRefusal(collision, discovered.warnings, parsed, dir)
+  const entry = {
+    url: parsed.url,
+    dir,
+    local: !parsed.isGit,
+    addedAt: new Date().toISOString(),
+    mode,
+    ref: parsed.isGit ? ref : null,
+    subdir: parsed.subdir,
+    revision: null,
+    syncIntervalMs: null,
+    trust: { code: "none" },
+    lastSync: null,
+    plugins: {},
+  }
+  registry.marketplaces[name] = entry
+  registerPlugins(registry, name, plugins)
+  const trustComponents = executableComponents(root, entry)
+  if (typeof options.trust === "boolean" && trustComponents.length) {
+    if (options.trust) grantEntry(entry, trustComponents)
+    else denyEntry(entry)
+  }
+  // the materializer reads the registry from disk, so the trust decision
+  // must be saved before links are made (spec 07)
+  saveRegistry(registry)
+  const report = materialize(name, root, { enabled: enabledPlugins(entry, root) })
+  return {
+    name,
+    url: parsed.url,
+    dir,
+    root,
+    mode,
+    plugins: plugins.map((plugin) => ({ name: plugin.name, components: plugin.components })),
+    warnings: discovered.warnings,
+    report,
+    trustComponents,
+    wasV1,
+  }
+}
+
+// spec 05 remove: full teardown — links, skills.paths entry, ocm-- mcp keys,
+// the clone (never a local directory), the registry record
+export function removeMarketplace(name) {
+  const { registry, wasV1 } = loadRegistryForWrite()
+  const entry = registry.marketplaces[name]
+  if (!entry) {
+    throw new Error(`marketplace "${name}" not found (ocm list)`)
+  }
+  const warnings = []
+  removeLinksFor(name, entry.dir)
+  const skillsWarning = setSkillsPath(join(LINKS_DIR, name, "skills"), false)
+  if (skillsWarning) warnings.push(skillsWarning)
+  // collision records never materialized, so their mcp keys are not ours to drop
+  const owned = Object.entries(entry.plugins).filter(([, plugin]) => !plugin.collision)
+  const mcpWarning = removeMcpKeys(owned.map(([pluginName]) => pluginName))
+  if (mcpWarning) warnings.push(mcpWarning)
+  // `local === false` rather than `!local`: an entry missing the field must
+  // never be treated as ocm-managed and deleted
+  if (entry.local === false) {
+    rmSync(entry.dir, { recursive: true, force: true })
+  }
+  delete registry.marketplaces[name]
+  saveRegistry(registry)
+  return {
+    name,
+    owned: owned.map(([pluginName, plugin]) => ({ name: pluginName, components: plugin.components })),
+    warnings,
+    wasV1,
+  }
+}
+
+// spec 08: pinning is branch- and tag-following, never commit-freezing.
+// The ref is validated by fetching it before it is saved, so a typo fails
+// immediately rather than breaking the next unattended sync. A null ref
+// clears the pin.
+export async function pinMarketplace(name, ref) {
+  const { registry, wasV1 } = loadRegistryForWrite()
+  const entry = registry.marketplaces[name]
+  if (!entry) throw new Error(`marketplace "${name}" not found (ocm list)`)
+  if (entry.local) throw new Error(`marketplace "${name}" is local; nothing to pin`)
+  if (ref === null) {
+    entry.ref = null
+    saveRegistry(registry)
+    return { name, ref: null, cleared: true, wasV1 }
+  }
+  if (!ref) throw new Error(`missing ref (ocm pin <name> <ref>)`)
+  const fetch = await git(["fetch", "--depth", "1", "origin", ref], entry.dir)
+  if (!fetch.ok) throw new Error(`cannot pin "${name}" to "${ref}": ${fetch.stderr || fetch.stdout}`)
+  entry.ref = ref
+  saveRegistry(registry)
+  return { name, ref, cleared: false, wasV1 }
+}

package/loader/materialize.js

@@ -0,0 +1,218 @@
+import { spawnSync } from "node:child_process"
+import { existsSync, mkdirSync, readFileSync, rmSync, rmdirSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { setSkillsPath } from "./config.js"
+import { discoverPlugins, PLUGIN_NAME_RE } from "./discovery.js"
+import { gcTargets, isRenderedFile, link, mirror } from "./links.js"
+import { syncMcp } from "./mcp.js"
+import { LINKS_DIR, DISPLACED_DIR, OPENCODE_AGENTS_DIR, OPENCODE_COMMANDS_DIR, OPENCODE_PLUGINS_DIR } from "./paths.js"
+import { readRegistry, isRecord } from "./registry.js"
+import { approvedComponents, componentKey } from "./trust.js"
+
+function managedDirs(dir, registry) {
+  const dirs = [dir]
+  for (const entry of Object.values(registry.marketplaces ?? {})) {
+    if (entry && typeof entry.dir === "string" && entry.dir && entry.dir !== dir) dirs.push(entry.dir)
+  }
+  return dirs.sort((a, b) => b.length - a.length)
+}
+
+function gitRevision(dir) {
+  try {
+    const result = spawnSync("git", ["rev-parse", "HEAD"], { cwd: dir, timeout: 5000, encoding: "utf8" })
+    if (result.status === 0) return result.stdout.trim()
+  } catch {}
+  return "unknown"
+}
+
+// `commands` and `command` are both opencode-valid; a name resolvable in
+// both is a clash we refuse rather than guess
+function resolveSource(pluginDir, dirs, name, ctx, plugin) {
+  const found = dirs.map((d) => join(pluginDir, d, name)).filter((p) => existsSync(p))
+  if (found.length > 1) {
+    ctx.warnings.push(`skipped ${plugin}:${name}: found in both ${dirs[0]} and ${dirs[1]}`)
+    return undefined
+  }
+  return found[0]
+}
+
+// the single transform: `name: <value>` becomes `name: "<plugin>:<value>"`;
+// everything else in the file is preserved byte-for-byte
+function renderSkillMd(content, plugin) {
+  if (!content.startsWith("---\n")) return null
+  const close = content.indexOf("\n---\n", 3)
+  if (close === -1) return null
+  const frontmatter = content.slice(4, close)
+  const match = frontmatter.match(/^name:[^\n]*/m)
+  if (!match) return null
+  const value = match[0].slice(5).trim().replace(/^["']|["']$/g, "")
+  if (!value) return null
+  const renamed = `name: "${plugin}:${value}"`
+  const updated = frontmatter.slice(0, match.index) + renamed + frontmatter.slice(match.index + match[0].length)
+  return content.slice(0, 4) + updated + content.slice(close)
+}
+
+function removeLegacyContainers(name) {
+  rmSync(join(OPENCODE_COMMANDS_DIR, `ocm--${name}`), { recursive: true, force: true })
+  rmSync(join(OPENCODE_AGENTS_DIR, `ocm--${name}`), { recursive: true, force: true })
+}
+
+export function materialize(name, dir, options = {}) {
+  const warnings = []
+  const counts = { command: 0, agent: 0, skill: 0, plugin: 0, mcp: 0 }
+  let created = 0
+  let removed = 0
+  let skipped = 0
+
+  removeLegacyContainers(name)
+
+  if (!existsSync(dir)) {
+    warnings.push(`marketplace "${name}" directory missing (${dir}), links left untouched`)
+    return { counts, created, removed, skipped, warnings }
+  }
+
+  const registry = readRegistry()
+  const entry = (registry.marketplaces ?? {})[name]
+  const approved = approvedComponents(dir, entry)
+  const revision = (entry && typeof entry.revision === "string" && entry.revision) || gitRevision(dir)
+  const ctx = {
+    name,
+    dir,
+    managed: managedDirs(dir, registry),
+    revision,
+    warnings,
+    force: options.force === true,
+    displacedDir: join(DISPLACED_DIR, new Date().toISOString().replace(/[:.]/g, "-")),
+  }
+  const enabled = options.enabled ?? null
+  // a plugin-scoped pass (ocm update <plugin>@<mp>) reconciles only the
+  // named plugin; every other plugin's links and mcp keys stay untouched
+  const only = options.plugin ?? null
+  const skillsDir = join(LINKS_DIR, name, "skills")
+  const desiredCommands = new Set()
+  const desiredAgents = new Set()
+  const desiredMirrors = new Set()
+  const desiredPluginLinks = new Set()
+
+  mkdirSync(OPENCODE_COMMANDS_DIR, { recursive: true })
+  mkdirSync(OPENCODE_AGENTS_DIR, { recursive: true })
+  mkdirSync(OPENCODE_PLUGINS_DIR, { recursive: true })
+
+  const discovered = discoverPlugins(dir)
+  const active = only === null ? discovered : discovered.filter((plugin) => plugin.name === only)
+  for (const plugin of active) {
+    if (enabled !== null && !enabled.has(plugin.name)) continue
+    if (!PLUGIN_NAME_RE.test(plugin.name)) {
+      warnings.push(`skipped plugin "${plugin.name}": name must match ${PLUGIN_NAME_RE}`)
+      continue
+    }
+    for (const file of plugin.components.command ?? []) {
+      const source = resolveSource(plugin.dir, ["commands", "command"], file, ctx, plugin.name)
+      if (!source) continue
+      counts.command += 1
+      const dest = `${plugin.name}:${file}`
+      desiredCommands.add(dest)
+      const status = link(source, join(OPENCODE_COMMANDS_DIR, dest), ctx, plugin.name, file)
+      if (status === "created") created += 1
+      else if (status !== "ok") skipped += 1
+    }
+    for (const file of plugin.components.agent ?? []) {
+      const source = resolveSource(plugin.dir, ["agents", "agent"], file, ctx, plugin.name)
+      if (!source) continue
+      counts.agent += 1
+      const dest = `${plugin.name}:${file}`
+      desiredAgents.add(dest)
+      const status = link(source, join(OPENCODE_AGENTS_DIR, dest), ctx, plugin.name, file)
+      if (status === "created") created += 1
+      else if (status !== "ok") skipped += 1
+    }
+    for (const rel of plugin.components.skill ?? []) {
+      const sourceDir = resolveSource(plugin.dir, ["skills", "skill"], rel, ctx, plugin.name)
+      if (!sourceDir) continue
+      const skillMd = join(sourceDir, "SKILL.md")
+      let transformed = null
+      try {
+        transformed = renderSkillMd(readFileSync(skillMd, "utf8"), plugin.name)
+      } catch {}
+      if (transformed === null) {
+        warnings.push(`skipped ${skillMd}: no name in frontmatter`)
+        continue
+      }
+      counts.skill += 1
+      const mirrorName = `${plugin.name}--${rel.split("/").join("-")}`
+      desiredMirrors.add(mirrorName)
+      removed += mirror(sourceDir, join(skillsDir, mirrorName), { "SKILL.md": () => transformed }, ctx, plugin.name, rel)
+    }
+    for (const file of plugin.components.plugin ?? []) {
+      const source = resolveSource(plugin.dir, ["plugin", "plugins"], file, ctx, plugin.name)
+      if (!source) continue
+      counts.plugin += 1
+      const dest = `ocm--${plugin.name}--${file}`
+      if (!approved.get(componentKey("plugin", plugin.name, file))) {
+        warnings.push(`blocked (untrusted): ${plugin.name}:${file} not linked — run \`ocm trust ${name}\` to approve`)
+        continue
+      }
+      desiredPluginLinks.add(dest)
+      const status = link(source, join(OPENCODE_PLUGINS_DIR, dest), ctx, plugin.name, file)
+      if (status === "created") created += 1
+      else if (status !== "ok") skipped += 1
+    }
+  }
+
+  // plugin names cannot contain ":", "--" or uppercase (PLUGIN_NAME_RE),
+  // so a name prefix never spans another plugin's entries
+  const scope = only === null ? undefined : `${only}:`
+  removed += gcTargets(OPENCODE_COMMANDS_DIR, desiredCommands, ctx, undefined, scope)
+  removed += gcTargets(OPENCODE_AGENTS_DIR, desiredAgents, ctx, undefined, scope)
+  removed += gcTargets(skillsDir, desiredMirrors, ctx, (path) => isRenderedFile(join(path, "SKILL.md")), only === null ? undefined : `${only}--`)
+  removed += gcTargets(OPENCODE_PLUGINS_DIR, desiredPluginLinks, ctx, undefined, only === null ? undefined : `ocm--${only}--`)
+
+  counts.mcp += syncMcp(active, dir, entry, enabled, approved, warnings)
+
+  // a scoped pass never unregisters the skills path: other plugins'
+  // rendered skills may still live there
+  if (only === null || counts.skill > 0) {
+    const warning = setSkillsPath(skillsDir, counts.skill > 0)
+    if (warning) warnings.push(warning)
+  }
+
+  return { counts, created, removed, skipped, warnings }
+}
+
+// the enabled set a caller drives materialize with: registry plugins that
+// are not disabled, plus discovered-but-unregistered ones in auto mode
+export function enabledPlugins(entry, dir) {
+  if (!entry || typeof entry.dir !== "string" || !entry.dir) return null
+  const registered = entry.plugins ?? {}
+  const enabled = new Set()
+  for (const [name, plugin] of Object.entries(registered)) {
+    if (plugin && plugin.enabled !== false) enabled.add(name)
+  }
+  if (entry.mode !== "explicit") {
+    // a name some marketplace already provides is never auto-installed
+    // here: it would displace the incumbent's links (spec 04)
+    const taken = new Set()
+    for (const other of Object.values(readRegistry().marketplaces ?? {})) {
+      if (isRecord(other?.plugins)) for (const name of Object.keys(other.plugins)) taken.add(name)
+    }
+    for (const plugin of discoverPlugins(dir)) {
+      if (!(plugin.name in registered) && !taken.has(plugin.name)) enabled.add(plugin.name)
+    }
+  }
+  return enabled
+}
+
+export function removeLinksFor(name, marketplaceDir) {
+  removeLegacyContainers(name)
+  const ctx = { name, dir: marketplaceDir, managed: [], revision: null, warnings: [] }
+  gcTargets(OPENCODE_COMMANDS_DIR, new Set(), ctx)
+  gcTargets(OPENCODE_AGENTS_DIR, new Set(), ctx)
+  gcTargets(OPENCODE_PLUGINS_DIR, new Set(), ctx)
+  const skillsDir = join(LINKS_DIR, name, "skills")
+  gcTargets(skillsDir, new Set(), ctx, (path) => isRenderedFile(join(path, "SKILL.md")))
+  // prune the cache dirs only when nothing unowned is left in them
+  try {
+    rmdirSync(skillsDir)
+    rmdirSync(dirname(skillsDir))
+  } catch {}
+}

package/loader/mcp.js

@@ -0,0 +1,124 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
+import { mcpSourceFile, PLUGIN_NAME_RE } from "./discovery.js"
+import { OPENCODE_CONFIG_FILE, OPENCODE_DIR } from "./paths.js"
+import { isRecord } from "./registry.js"
+import { componentKey } from "./trust.js"
+
+// desired keys are ocm--<plugin>--<server>; every other key in the mcp object
+// is the user's and survives byte-identically outside the keys ocm owns
+function applyMcpKeys(desired, prefixes) {
+  let raw
+  try {
+    raw = readFileSync(OPENCODE_CONFIG_FILE, "utf8")
+  } catch {}
+  let config = {}
+  if (raw !== undefined) {
+    try {
+      config = JSON.parse(raw)
+    } catch {
+      return `skipped ${OPENCODE_CONFIG_FILE}: not valid JSON, left untouched`
+    }
+  }
+  if (!isRecord(config)) return `skipped ${OPENCODE_CONFIG_FILE}: not a JSON object`
+  if (config.mcp !== undefined && !isRecord(config.mcp)) {
+    return `skipped ${OPENCODE_CONFIG_FILE}: "mcp" is not an object`
+  }
+  const mcp = isRecord(config.mcp) ? config.mcp : {}
+  let changed = false
+  for (const key of Object.keys(mcp)) {
+    if (prefixes.some((prefix) => key.startsWith(prefix)) && !desired.has(key)) {
+      delete mcp[key]
+      changed = true
+    }
+  }
+  for (const [key, value] of desired) {
+    if (JSON.stringify(mcp[key]) !== JSON.stringify(value)) {
+      mcp[key] = value
+      changed = true
+    }
+  }
+  if (!changed) return null
+  if (Object.keys(mcp).length) config.mcp = mcp
+  else delete config.mcp
+  try {
+    mkdirSync(OPENCODE_DIR, { recursive: true })
+    const tmp = `${OPENCODE_CONFIG_FILE}.tmp`
+    writeFileSync(tmp, `${JSON.stringify(config, null, 2)}\n`)
+    renameSync(tmp, OPENCODE_CONFIG_FILE)
+  } catch (err) {
+    return `failed ${OPENCODE_CONFIG_FILE}: ${err instanceof Error ? err.message : String(err)}`
+  }
+  return null
+}
+
+// one pass over every discovered plugin: enabled plugins contribute desired
+// keys for their approved servers, everything else only the prefix that
+// scopes the stale keys removed for it (specs 06, 07)
+export function syncMcp(plugins, dir, entry, enabled, approved, warnings) {
+  const desired = new Map()
+  const prefixes = []
+  let count = 0
+  for (const plugin of plugins) {
+    if (!PLUGIN_NAME_RE.test(plugin.name)) continue
+    prefixes.push(`ocm--${plugin.name}--`)
+    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 {}
+    if (servers === null) {
+      warnings.push(`skipped ${file}: not a JSON object`)
+      continue
+    }
+    for (const [server, value] of Object.entries(servers)) {
+      if (!approved.get(componentKey("mcp", plugin.name, server))) {
+        warnings.push(`blocked (untrusted): ${plugin.name}:mcp/${server} not installed`)
+        continue
+      }
+      count += 1
+      desired.set(`ocm--${plugin.name}--${server}`, value)
+    }
+  }
+  const warning = applyMcpKeys(desired, prefixes)
+  if (warning) warnings.push(warning)
+  return count
+}
+
+// spec 05 ocm remove: every ocm--<plugin> and ocm--<plugin>--* mcp key of
+// these plugins goes, keeping the mcp object when the user has their own
+// servers left in it. Returns a warning instead of printing — the core
+// never prints.
+export function removeMcpKeys(pluginNames) {
+  let raw
+  try {
+    raw = readFileSync(OPENCODE_CONFIG_FILE, "utf8")
+  } catch {
+    return null
+  }
+  let config
+  try {
+    config = JSON.parse(raw)
+  } catch {
+    return `${OPENCODE_CONFIG_FILE} is not valid JSON, left untouched`
+  }
+  if (!isRecord(config) || !isRecord(config.mcp)) return null
+  const mcp = config.mcp
+  const owned = Object.keys(mcp).filter((key) =>
+    pluginNames.some((name) => key === `ocm--${name}` || key.startsWith(`ocm--${name}--`)),
+  )
+  if (!owned.length) return null
+  for (const key of owned) delete mcp[key]
+  if (!Object.keys(mcp).length) delete config.mcp
+  try {
+    mkdirSync(OPENCODE_DIR, { recursive: true })
+    const tmp = `${OPENCODE_CONFIG_FILE}.tmp`
+    writeFileSync(tmp, `${JSON.stringify(config, null, 2)}\n`)
+    renameSync(tmp, OPENCODE_CONFIG_FILE)
+  } catch (err) {
+    return `cannot write ${OPENCODE_CONFIG_FILE}: ${err instanceof Error ? err.message : String(err)}`
+  }
+  return null
+}

package/loader/mutations.js

@@ -0,0 +1,102 @@
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+import { nameDisagreement } from "./manifest.js"
+import { componentRoot } from "./marketplace.js"
+import { enabledPlugins, materialize } from "./materialize.js"
+import { loadRegistryForWrite, saveRegistry } from "./registry.js"
+import { denyEntry, executableComponents, grantEntry } from "./trust.js"
+
+// spec 05 argument resolution, shared by every verb that takes a plugin
+export function resolvePlugin(registry, arg) {
+  const at = arg.indexOf("@")
+  let marketplace
+  let plugin
+  if (at !== -1) {
+    plugin = arg.slice(0, at)
+    marketplace = arg.slice(at + 1)
+    if (!plugin) throw new Error(`missing plugin name in "${arg}" (ocm list --all)`)
+    if (!marketplace) throw new Error(`missing marketplace name in "${arg}" (ocm list)`)
+  } else {
+    plugin = arg
+    const providers = Object.entries(registry.marketplaces).filter(([, entry]) => entry.plugins[plugin])
+    if (!providers.length) {
+      throw new Error(`plugin "${plugin}" not found in any marketplace (ocm add <url|path>, or ocm update)`)
+    }
+    if (providers.length > 1) {
+      const names = providers.map(([name]) => name).join(", ")
+      throw new Error(`plugin "${plugin}" is provided by more than one marketplace: ${names} (use ${plugin}@<marketplace>)`)
+    }
+    marketplace = providers[0][0]
+  }
+  const entry = registry.marketplaces[marketplace]
+  if (!entry) throw new Error(`marketplace "${marketplace}" not found (ocm list)`)
+  const record = entry.plugins[plugin]
+  if (!record) throw new Error(`plugin "${plugin}" not found in marketplace "${marketplace}" (ocm list --all)`)
+  if (!existsSync(join(componentRoot(entry), record.source))) {
+    throw new Error(`plugin "${plugin}" is registered but missing on disk in marketplace "${marketplace}" (run ocm update ${marketplace})`)
+  }
+  return { marketplace, plugin, entry }
+}
+
+// spec 05 install/uninstall: flip the record, save, reconcile links. A
+// no-op flip saves nothing, so a repeat run writes nothing (idempotence).
+export function setEnabled(arg, enabled, options = {}) {
+  const { registry, wasV1 } = loadRegistryForWrite()
+  const resolved = resolvePlugin(registry, arg)
+  const entry = registry.marketplaces[resolved.marketplace]
+  const record = entry.plugins[resolved.plugin]
+  const root = componentRoot(entry)
+  const current = enabled
+    ? record.enabled && record.installedAt
+    : !record.enabled && record.installedAt === null
+  let saved = false
+  if (!current) {
+    record.enabled = enabled
+    record.installedAt = enabled ? new Date().toISOString() : null
+    saveRegistry(registry)
+    saved = true
+  }
+  const report = materialize(resolved.marketplace, root, {
+    enabled: enabledPlugins(entry, root),
+    force: options.force === true,
+  })
+  return {
+    marketplace: resolved.marketplace,
+    plugin: resolved.plugin,
+    components: record.components,
+    disagreement: nameDisagreement(join(root, record.source), resolved.plugin),
+    wasV1: wasV1 && saved,
+    report,
+  }
+}
+
+export function grantTrust(name) {
+  const { registry, wasV1 } = loadRegistryForWrite()
+  const entry = registry.marketplaces[name]
+  if (!entry) throw new Error(`marketplace "${name}" not found (ocm list)`)
+  const root = componentRoot(entry)
+  const components = executableComponents(root, entry)
+  if (!components.length) return { granted: false, report: null, wasV1: false }
+  grantEntry(entry, components)
+  saveRegistry(registry)
+  const report = materialize(name, root, { enabled: enabledPlugins(entry, root) })
+  return { granted: true, report, wasV1 }
+}
+
+// idempotent: a second deny writes nothing (spec 07)
+export function denyTrust(name) {
+  const { registry, wasV1 } = loadRegistryForWrite()
+  const entry = registry.marketplaces[name]
+  if (!entry) throw new Error(`marketplace "${name}" not found (ocm list)`)
+  let saved = false
+  if (entry.trust.code !== "denied" || entry.trustPending) {
+    denyEntry(entry)
+    saveRegistry(registry)
+    saved = true
+  }
+  const root = componentRoot(entry)
+  const report = materialize(name, root, { enabled: enabledPlugins(entry, root) })
+  return { report, wasV1: wasV1 && saved }
+}
+
+export { denyTrust as revokeTrust }

package/loader/ocm-loader.js

@@ -0,0 +1,21 @@
+// namespace import, not named bindings: the loader must link even when
+// core.js exports less than this file uses, so a partially updated core
+// degrades the hook rather than the whole loader
+import * as core from "../ocm/core.js"
+
+export default {
+  id: "ocm-loader",
+  server: async () => {
+    void core.syncAll({ reason: "startup" }).catch(() => {})
+    return {
+      // spec 11: command bodies reference ${OCM_PLUGIN_ROOT}/plugins/<name>/…
+      // and Claude Code's ${CLAUDE_PLUGIN_ROOT}; both point at the
+      // marketplace root
+      "shell.env": async (_input, output) => {
+        if (output && typeof output.env === "object" && output.env !== null) {
+          Object.assign(output.env, core.pluginRootEnv())
+        }
+      },
+    }
+  },
+}

package/loader/paths.js

@@ -0,0 +1,20 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export const HOME = homedir()
+export const OPENCODE_DIR = join(HOME, ".config", "opencode")
+export const OPENCODE_CONFIG_FILE = join(OPENCODE_DIR, "opencode.json")
+export const OPENCODE_COMMANDS_DIR = join(OPENCODE_DIR, "commands")
+export const OPENCODE_AGENTS_DIR = join(OPENCODE_DIR, "agents")
+export const OPENCODE_PLUGINS_DIR = join(OPENCODE_DIR, "plugins")
+export const OCM_DIR = join(OPENCODE_DIR, "ocm")
+export const CACHE_DIR = join(HOME, ".cache", "ocm")
+export const MARKETPLACES_DIR = join(CACHE_DIR, "marketplaces")
+export const LINKS_DIR = join(CACHE_DIR, "links")
+export const DISPLACED_DIR = join(CACHE_DIR, "displaced")
+export const REGISTRY_FILE = join(OCM_DIR, "registry.json")
+// pre-01 layout; read as a fallback for one release
+export const LEGACY_REGISTRY_FILE = join(OPENCODE_PLUGINS_DIR, "ocm-registry.json")
+export const STAMP_FILE = join(CACHE_DIR, "last-sync.json")
+
+export const DEFAULT_SYNC_INTERVAL_MS = 60 * 60 * 1000