@wntic/ocm 0.1.0

package/loader/registry.js

@@ -0,0 +1,163 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { LEGACY_REGISTRY_FILE, MARKETPLACES_DIR, OCM_DIR, REGISTRY_FILE } from "./paths.js"
+
+export function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function relativeSource(dir, source) {
+  if (typeof dir === "string" && typeof source === "string" && source.startsWith(dir + "/")) {
+    return source.slice(dir.length + 1)
+  }
+  return source
+}
+
+// read-only mirror of normalizeRegistry in src/registry.ts, so a core that
+// predates a schema change still reads v1 and v2 registries uniformly
+export function normalizeRegistry(raw) {
+  if (!isRecord(raw) || !isRecord(raw.marketplaces)) return { version: 2, marketplaces: {} }
+  if (raw.version === 2) return raw
+  if (raw.version !== 1) return { version: 2, marketplaces: {} }
+  const marketplaces = {}
+  for (const [name, entry] of Object.entries(raw.marketplaces)) {
+    if (!isRecord(entry)) continue
+    const dir = typeof entry.dir === "string" ? entry.dir : ""
+    const addedAt = typeof entry.addedAt === "string" ? entry.addedAt : ""
+    const plugins = {}
+    if (isRecord(entry.plugins)) {
+      for (const [pluginName, plugin] of Object.entries(entry.plugins)) {
+        if (!isRecord(plugin)) continue
+        const source = typeof plugin.source === "string" ? plugin.source : ""
+        plugins[pluginName] = {
+          source: relativeSource(dir, source),
+          components: isRecord(plugin.components) ? plugin.components : {},
+          enabled: true,
+          installedAt: addedAt,
+          version: null,
+          manifest: {},
+        }
+      }
+    }
+    marketplaces[name] = {
+      url: typeof entry.url === "string" ? entry.url : "",
+      dir,
+      local: !dir.startsWith(MARKETPLACES_DIR),
+      addedAt,
+      mode: "auto",
+      ref: null,
+      revision: null,
+      syncIntervalMs: null,
+      trust: { code: "none" },
+      lastSync: null,
+      plugins,
+    }
+  }
+  return { version: 2, marketplaces }
+}
+
+export function readRegistry() {
+  if (existsSync(REGISTRY_FILE)) {
+    try {
+      return normalizeRegistry(JSON.parse(readFileSync(REGISTRY_FILE, "utf8")))
+    } catch {}
+    return { version: 2, marketplaces: {} }
+  }
+  try {
+    return normalizeRegistry(JSON.parse(readFileSync(LEGACY_REGISTRY_FILE, "utf8")))
+  } catch {}
+  return { version: 2, marketplaces: {} }
+}
+
+// Mutating commands report the v1 → v2 upgrade when they save the migrated
+// registry, so this load also says what version was on disk.
+export function loadRegistryForWrite() {
+  // pre-02 layout; read as a fallback, never written
+  const file = existsSync(REGISTRY_FILE) ? REGISTRY_FILE : LEGACY_REGISTRY_FILE
+  try {
+    const raw = JSON.parse(readFileSync(file, "utf8"))
+    return { registry: normalizeRegistry(raw), wasV1: isRecord(raw) && raw.version === 1 }
+  } catch {
+    return { registry: { version: 2, marketplaces: {} }, wasV1: false }
+  }
+}
+
+// Canonical key order: a no-op save must be byte-identical, and unknown
+// fields ride after the known ones so they survive round-trips.
+const MARKETPLACE_KEYS = [
+  "url", "dir", "local", "addedAt", "mode", "ref", "subdir", "revision",
+  "syncIntervalMs", "trust", "lastSync", "plugins",
+]
+const PLUGIN_KEYS = ["source", "components", "enabled", "collision", "installedAt", "version", "manifest"]
+
+function canonicalObject(source, keys) {
+  const out = {}
+  for (const key of keys) if (key in source) out[key] = source[key]
+  for (const key of Object.keys(source)) if (!keys.includes(key)) out[key] = source[key]
+  return out
+}
+
+function serializeRegistry(registry) {
+  const marketplaces = {}
+  for (const [name, entry] of Object.entries(registry.marketplaces ?? {})) {
+    const plugins = {}
+    for (const [pluginName, plugin] of Object.entries(entry.plugins ?? {})) {
+      plugins[pluginName] = canonicalObject(plugin, PLUGIN_KEYS)
+    }
+    marketplaces[name] = canonicalObject({ ...entry, plugins }, MARKETPLACE_KEYS)
+  }
+  return `${JSON.stringify(canonicalObject({ ...registry, version: 2, marketplaces }, ["version", "marketplaces"]), null, 2)}\n`
+}
+
+export function saveRegistry(registry) {
+  mkdirSync(OCM_DIR, { recursive: true })
+  const tmp = `${REGISTRY_FILE}.tmp`
+  try {
+    writeFileSync(tmp, serializeRegistry(registry))
+    renameSync(tmp, REGISTRY_FILE)
+  } catch (err) {
+    throw new Error(`cannot write ${REGISTRY_FILE}: ${err instanceof Error ? err.message : String(err)}`)
+  }
+}
+
+// spec 11: the variables the loader's shell.env hook exports. Every added
+// marketplace root is available under both families — OCM_PLUGIN_ROOT for
+// bodies authored for opencode, CLAUDE_PLUGIN_ROOT as an alias so a Claude
+// Code command file runs unmodified. The flat pair exists only when one
+// marketplace is added: a flat name cannot say which of several roots it
+// means, and an unset variable fails louder than a silently wrong one.
+export function pluginRootEnv() {
+  const entries = Object.entries(readRegistry().marketplaces ?? {}).filter(
+    ([, entry]) => entry && typeof entry.dir === "string" && entry.dir,
+  )
+  const roots = entries.map(([name, entry]) => ({
+    suffix: name.replaceAll("-", "_").toUpperCase(),
+    root: entry.subdir ? join(entry.dir, entry.subdir) : entry.dir,
+  }))
+  const env = {}
+  for (const { suffix, root } of roots) {
+    env[`OCM_PLUGIN_ROOT_${suffix}`] = root
+    env[`CLAUDE_PLUGIN_ROOT_${suffix}`] = root
+  }
+  if (roots.length === 1) {
+    env.OCM_PLUGIN_ROOT = roots[0].root
+    env.CLAUDE_PLUGIN_ROOT = roots[0].root
+  }
+  return env
+}
+
+// the loader's only registry write: flag that a marketplace's executable
+// components changed since its grant. The raw file is preserved verbatim
+// outside the flag — never migrated — and an existing flag is left alone.
+export function markTrustPending(name) {
+  try {
+    const raw = JSON.parse(readFileSync(REGISTRY_FILE, "utf8"))
+    if (!isRecord(raw) || !isRecord(raw.marketplaces) || !isRecord(raw.marketplaces[name])) return
+    const entry = raw.marketplaces[name]
+    if (entry.trustPending === true) return
+    entry.trustPending = true
+    const tmp = `${REGISTRY_FILE}.tmp`
+    writeFileSync(tmp, JSON.stringify(raw, null, 2))
+    renameSync(tmp, REGISTRY_FILE)
+  } catch {}
+}

package/loader/search.js

@@ -0,0 +1,55 @@
+import { readRegistry } from "./registry.js"
+
+// spec 09 ranking, first rule that matches wins; the marketplace name is a
+// match surface ranked below every plugin-level rule
+function rankOf(query, plugin, record, marketplace) {
+  const name = plugin.toLowerCase()
+  if (name === query) return { rank: 0, matched: [] }
+  if (name.startsWith(query)) return { rank: 1, matched: [] }
+  if (name.includes(query)) return { rank: 2, matched: [] }
+  const manifest = record.manifest
+  const words = [...(manifest.tags ?? []), ...(manifest.keywords ?? [])].map((word) => word.toLowerCase())
+  const category = manifest.category?.toLowerCase()
+  if (category === query || words.includes(query)) return { rank: 3, matched: [] }
+  if (
+    (manifest.description?.toLowerCase().includes(query) ?? false) ||
+    category?.includes(query) ||
+    words.some((word) => word.includes(query))
+  ) {
+    return { rank: 4, matched: [] }
+  }
+  const matched = []
+  for (const file of record.components.command ?? []) {
+    const name = file.replace(/\.md$/, "")
+    if (name.toLowerCase().includes(query)) matched.push(`commands/${name}`)
+  }
+  for (const file of record.components.agent ?? []) {
+    const name = file.replace(/\.md$/, "")
+    if (name.toLowerCase().includes(query)) matched.push(`agents/${name}`)
+  }
+  for (const rel of record.components.skill ?? []) {
+    if (rel.toLowerCase().includes(query)) matched.push(`skills/${rel}`)
+  }
+  if (matched.length) return { rank: 5, matched }
+  if (marketplace.toLowerCase().includes(query)) return { rank: 6, matched: [] }
+  return null
+}
+
+// spec 09: every match carries its registry records so the CLI renders
+// without re-reading the registry; ties break alphabetically by
+// plugin@marketplace so output is stable
+export function searchPlugins(queryArg, options = {}) {
+  const query = queryArg.toLowerCase()
+  const registry = readRegistry()
+  const matches = []
+  for (const [marketplace, entry] of Object.entries(registry.marketplaces)) {
+    for (const [plugin, record] of Object.entries(entry.plugins)) {
+      if (options.enabledOnly && !record.enabled) continue
+      const found = rankOf(query, plugin, record, marketplace)
+      if (found) matches.push({ marketplace, plugin, entry, record, rank: found.rank, matched: found.matched })
+    }
+  }
+  const key = (match) => `${match.plugin}@${match.marketplace}`
+  matches.sort((a, b) => a.rank - b.rank || (key(a) < key(b) ? -1 : 1))
+  return matches
+}

package/loader/source.js

@@ -0,0 +1,100 @@
+import { existsSync, mkdirSync, renameSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { readManifest } from "./manifest.js"
+import { HOME, MARKETPLACES_DIR } from "./paths.js"
+import { git } from "./sync.js"
+
+const GITHUB_TREE_RE = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)(\/.*)?$/
+const NAME_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/
+
+export function isGitUrl(source) {
+  return /^https?:|^git@|^file:\/\//.test(source)
+}
+
+function expandPath(source) {
+  return source.startsWith("~") ? join(HOME, source.replace(/^~\/?/, "")) : source
+}
+
+function basename(p) {
+  return p.replace(/\/+$/, "").split("/").pop() ?? p
+}
+
+export function normaliseMarketplaceName(name) {
+  return (
+    name
+      .toLowerCase()
+      .replace(/[^a-z0-9-]+/g, "-")
+      .replace(/-+/g, "-")
+      .replace(/^-|-$/g, "") || "marketplace"
+  )
+}
+
+export function marketplaceNameFromUrl(url) {
+  const cleaned = url
+    .replace(/\.git$/, "")
+    .replace(/\/+$/, "")
+    .replace(/^https?:\/\/[^/]+\//, "")
+    .replace(/^git@[^:]+:/, "")
+  return normaliseMarketplaceName(cleaned.split("/").filter(Boolean).slice(-2).join("--"))
+}
+
+export function marketplaceDir(name) {
+  return join(MARKETPLACES_DIR, name)
+}
+
+// spec 05 add step 1: git urls, github tree urls (repo + ref + subdir) and
+// local paths (absolute, relative or ~/)
+export function parseSource(source) {
+  if (isGitUrl(source)) {
+    const tree = source.match(GITHUB_TREE_RE)
+    if (tree) {
+      const url = `https://github.com/${tree[1]}/${tree[2]}`
+      return {
+        url,
+        name: marketplaceNameFromUrl(url),
+        subdir: tree[4] ? tree[4].replace(/^\/+|\/+$/g, "") : null,
+        isGit: true,
+        ref: tree[3],
+      }
+    }
+    return { url: source, name: marketplaceNameFromUrl(source), subdir: null, isGit: true, ref: null }
+  }
+  const absolute = expandPath(source)
+  if (!existsSync(absolute)) {
+    throw new Error(`path does not exist: ${source}`)
+  }
+  return { url: absolute, name: normaliseMarketplaceName(basename(absolute)), subdir: null, isGit: false, ref: null }
+}
+
+// a marketplace.json name is honoured only when it is already a valid
+// marketplace name (spec 05 add step 2)
+export function manifestName(name) {
+  return name && NAME_RE.test(name) ? name : undefined
+}
+
+async function clone(url, dir, ref) {
+  const args = ["clone", "--depth", "1"]
+  if (ref) args.push("--branch", ref)
+  args.push(url, dir)
+  const result = await git(args)
+  if (!result.ok) {
+    throw new Error(`git clone failed: ${result.stderr || result.stdout}`)
+  }
+}
+
+// clone under the url-derived name; a valid marketplace.json name renames
+// the clone after the fact unless --name already decided it (spec 05 add
+// step 2). The clone progress line is the CLI's — the core never prints.
+export async function placeClone(parsed, name, ref, registry, named) {
+  const dir = marketplaceDir(name)
+  mkdirSync(MARKETPLACES_DIR, { recursive: true })
+  await clone(parsed.url, dir, ref)
+  const declared = named ? undefined : manifestName(readManifest(parsed.subdir ? join(dir, parsed.subdir) : dir).name)
+  if (!declared || declared === name) return { name, dir }
+  if (registry.marketplaces[declared]) {
+    rmSync(dir, { recursive: true, force: true })
+    throw new Error(`marketplace "${declared}" already added (use "ocm update ${declared}")`)
+  }
+  renameSync(dir, marketplaceDir(declared))
+  return { name: declared, dir: marketplaceDir(declared) }
+}

package/loader/sync.js

@@ -0,0 +1,151 @@
+import { spawn } from "node:child_process"
+import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { DEFAULT_SYNC_INTERVAL_MS, REGISTRY_FILE, STAMP_FILE } from "./paths.js"
+import { enabledPlugins, materialize } from "./materialize.js"
+import { isRecord, markTrustPending, readRegistry } from "./registry.js"
+import { executableComponents, trustFingerprint } from "./trust.js"
+
+export function isGitRepo(dir) {
+  return existsSync(join(dir, ".git"))
+}
+
+export function git(args, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] })
+    let stdout = ""
+    let stderr = ""
+    let settled = false
+    const finish = (result) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve(result)
+    }
+    const timer = setTimeout(() => {
+      child.kill()
+      finish({ ok: false, stdout: "", stderr: "git timed out" })
+    }, 120_000)
+    child.stdout.on("data", (chunk) => (stdout += chunk))
+    child.stderr.on("data", (chunk) => (stderr += chunk))
+    child.on("error", (err) => finish({ ok: false, stdout: "", stderr: String(err) }))
+    child.on("close", (code) => finish({ ok: code === 0, stdout: stdout.trim(), stderr: stderr.trim() }))
+  })
+}
+
+// spec 08: fetch the pinned ref when there is one, else the remote's HEAD —
+// a --branch clone is single-branch, so a bare fetch would follow the
+// cloned branch rather than the default. Then hard-reset to FETCH_HEAD,
+// with @{u} as the fallback.
+export async function pullRepo(dir, ref) {
+  const before = (await git(["rev-parse", "HEAD"], dir)).stdout
+  const dirty = (await git(["status", "--porcelain"], dir)).stdout !== ""
+  const fetch = await git(["fetch", "--depth", "1", "origin", ref || "HEAD"], dir)
+  if (!fetch.ok) {
+    const detail = fetch.stderr || fetch.stdout
+    return {
+      ok: false, changed: false, before, after: before, dirty,
+      output: ref ? `cannot fetch ref "${ref}": ${detail}` : detail,
+    }
+  }
+  let reset = await git(["reset", "--hard", "FETCH_HEAD"], dir)
+  if (!reset.ok) reset = await git(["reset", "--hard", "@{u}"], dir)
+  if (!reset.ok) return { ok: false, changed: false, before, after: before, dirty, output: reset.stderr || reset.stdout }
+  const after = (await git(["rev-parse", "HEAD"], dir)).stdout
+  return { ok: true, changed: before !== after, before, after, dirty, output: after }
+}
+
+// the loader never prompts: an unanswered or drifted grant is recorded as
+// pending and left for the CLI to surface (spec 07)
+function markDriftedTrust(name, entry, root) {
+  const trust = entry?.trust
+  if (!isRecord(trust) || trust.code === "denied") return
+  const components = executableComponents(root, entry)
+  if (components.length && (trust.code === "none" || trust.fingerprint !== trustFingerprint(components))) {
+    markTrustPending(name)
+  }
+}
+
+// the loader's only other registry write: lastSync per marketplace, plus the
+// revision after a successful pull (spec 02). The raw file is mutated in
+// place, never migrated, so unknown fields survive.
+function recordSync(name, value, revision) {
+  try {
+    const raw = JSON.parse(readFileSync(REGISTRY_FILE, "utf8"))
+    if (!isRecord(raw) || !isRecord(raw.marketplaces) || !isRecord(raw.marketplaces[name])) return
+    raw.marketplaces[name].lastSync = value
+    if (typeof revision === "string") raw.marketplaces[name].revision = revision
+    const tmp = `${REGISTRY_FILE}.tmp`
+    writeFileSync(tmp, `${JSON.stringify(raw, null, 2)}\n`)
+    renameSync(tmp, REGISTRY_FILE)
+  } catch {}
+}
+
+// spec 08: syncIntervalMs beats OCM_SYNC_INTERVAL_MS beats the 1h default;
+// 0 means due on every start
+function intervalFor(entry) {
+  if (typeof entry?.syncIntervalMs === "number") return entry.syncIntervalMs
+  const raw = process.env.OCM_SYNC_INTERVAL_MS
+  if (raw) {
+    const env = Number(raw)
+    if (Number.isFinite(env) && env >= 0) return env
+  }
+  return DEFAULT_SYNC_INTERVAL_MS
+}
+
+function due(entry, now) {
+  const at = Date.parse(entry?.lastSync?.at ?? "")
+  if (Number.isNaN(at)) return true
+  return now - at >= intervalFor(entry)
+}
+
+export async function syncAll(options = {}) {
+  const result = { ran: false, changed: false, updated: [], unchanged: [], failed: [], errors: {} }
+  if (process.env.OCM_SYNC_DISABLE === "1") return result
+  const registry = readRegistry()
+  const entries = Object.entries(registry.marketplaces ?? {})
+  if (!entries.length) return result
+  const now = Date.now()
+  for (const [name, entry] of entries) {
+    // the throttle is per marketplace: one marketplace's sync never
+    // suppresses another's (spec 08)
+    if (!options.force && !due(entry, now)) continue
+    if (!entry || typeof entry.dir !== "string" || !existsSync(entry.dir)) continue
+    result.ran = true
+    let changed = false
+    let revision
+    // `local === false` rather than `!entry.local`: an entry missing the
+    // field must never be treated as an ocm-managed clone
+    if (entry.local === false && isGitRepo(entry.dir)) {
+      const pull = await pullRepo(entry.dir, typeof entry.ref === "string" ? entry.ref : null)
+      if (!pull.ok) {
+        result.failed.push(name)
+        result.errors[name] = pull.output
+        recordSync(name, { at: new Date().toISOString(), ok: false, error: pull.output })
+        continue
+      }
+      changed = pull.changed
+      revision = pull.after
+      if (changed) result.updated.push(name)
+      else result.unchanged.push(name)
+    } else {
+      // a local directory never pulls; its sync is unchanged by definition
+      result.unchanged.push(name)
+    }
+    // discovery roots at the subdir when the source was a tree url (spec 05);
+    // git operations above ran against the clone root
+    const root = entry.subdir ? join(entry.dir, entry.subdir) : entry.dir
+    const links = materialize(name, root, { enabled: enabledPlugins(entry, root) })
+    if (links.warnings.length) result.warnings = [...(result.warnings ?? []), ...links.warnings.map((w) => `${name}: ${w}`)]
+    if (changed || links.created > 0) result.changed = true
+    markDriftedTrust(name, entry, root)
+    recordSync(name, { at: new Date().toISOString(), ok: true, error: null }, revision)
+  }
+  // the pre-08 global stamp is obsolete: the throttle lives in lastSync.at
+  if (result.ran) {
+    try {
+      rmSync(STAMP_FILE, { force: true })
+    } catch {}
+  }
+  return result
+}

package/loader/trust.js

@@ -0,0 +1,114 @@
+import { createHash } from "node:crypto"
+import { readFileSync } from "node:fs"
+import { join, relative } from "node:path"
+import { discoverPlugins, mcpSourceFile } from "./discovery.js"
+import { isRecord } from "./registry.js"
+
+// canonical JSON: keys sorted at every level, so reordering mcp.json leaves a
+// server entry's hash alone while a command change does not (spec 07)
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`
+  if (isRecord(value)) {
+    const keys = Object.keys(value).sort()
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`
+  }
+  return JSON.stringify(value)
+}
+
+function sha256(data) {
+  return createHash("sha256").update(data).digest("hex")
+}
+
+// `plugin` and `plugins` are both valid source directories (spec 06)
+function pluginFile(pluginDir, file) {
+  for (const dir of ["plugin", "plugins"]) {
+    const path = join(pluginDir, dir, file)
+    try {
+      return { path, content: readFileSync(path) }
+    } catch {}
+  }
+  return null
+}
+
+// every executable component of every discovered plugin, sorted by its
+// marketplace-relative path: plugins/<p>/plugin/*.{js,ts} files and every
+// server entry in a plugin's mcp.json (spec 07)
+export function executableComponents(dir, entry) {
+  const components = []
+  for (const plugin of discoverPlugins(dir)) {
+    for (const file of plugin.components.plugin ?? []) {
+      const source = pluginFile(plugin.dir, file)
+      if (!source) continue
+      components.push({
+        rel: relative(dir, source.path),
+        hash: sha256(source.content),
+        kind: "plugin",
+        plugin: plugin.name,
+        name: file,
+      })
+    }
+    const mcpFile = mcpSourceFile(dir, entry, plugin)
+    let servers = null
+    try {
+      const parsed = JSON.parse(readFileSync(mcpFile, "utf8"))
+      if (isRecord(parsed)) servers = parsed
+    } catch {}
+    for (const [server, value] of Object.entries(servers ?? {})) {
+      components.push({
+        rel: `${relative(dir, mcpFile)}:${server}`,
+        hash: sha256(canonicalJson(value)),
+        kind: "mcp",
+        plugin: plugin.name,
+        name: server,
+        value,
+      })
+    }
+  }
+  return components.sort((a, b) => (a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0))
+}
+
+// sha256 over "<relative path>\n<sha256 of contents>\n" per component, in
+// path order — the fingerprint recorded at grant time (spec 07)
+export function trustFingerprint(components) {
+  const hash = createHash("sha256")
+  for (const component of components) {
+    hash.update(`${component.rel}\n${component.hash}\n`)
+  }
+  return hash.digest("hex")
+}
+
+export function componentKey(kind, plugin, name) {
+  return `${kind}\n${plugin}\n${name}`
+}
+
+// the in-memory halves of a trust decision: applied to a loaded entry and
+// saved by the caller (spec 07)
+export function grantEntry(entry, components) {
+  entry.trust = {
+    code: "granted",
+    grantedAt: new Date().toISOString(),
+    fingerprint: trustFingerprint(components),
+    components: Object.fromEntries(components.map((c) => [c.rel, c.hash])),
+  }
+  delete entry.trustPending
+}
+
+export function denyEntry(entry) {
+  entry.trust = { code: "denied" }
+  delete entry.trustPending
+}
+
+// the materializer's per-component gate: approved iff the marketplace is
+// granted and the component's hash matches the grant record. A grant without
+// a record (written by hand before spec 07) approves everything.
+export function approvedComponents(dir, entry) {
+  const trust = entry?.trust
+  const granted = trust?.code === "granted"
+  const recorded = granted && isRecord(trust.components) ? trust.components : null
+  const approved = new Map()
+  for (const component of executableComponents(dir, entry)) {
+    const ok = granted && (recorded === null || recorded[component.rel] === component.hash)
+    approved.set(componentKey(component.kind, component.plugin, component.name), ok)
+  }
+  return approved
+}

package/loader/ui-dialog.js

@@ -0,0 +1,46 @@
+// Shared view primitives for the /ocm TUI dialog (spec 10b): thin wrappers
+// over api.ui so every flow renders through the same dialogs. Nothing
+// reloads in-session, so every mutation toast ends with the restart notice.
+const NOTICE = "restart opencode to activate"
+
+const message = (err) => (err instanceof Error ? err.message : String(err))
+
+function componentSummary(record) {
+  const parts = []
+  for (const [type, files] of Object.entries(record.components ?? {})) {
+    if (files?.length) parts.push(`${files.length} ${type}${files.length === 1 ? "" : "s"}`)
+  }
+  return parts.join(", ") || "no components"
+}
+
+export function select(api, props) {
+  api.ui.dialog.replace(() => api.ui.DialogSelect(props))
+}
+
+export function alert(api, title, text, onConfirm) {
+  api.ui.dialog.replace(() =>
+    api.ui.DialogAlert({ title, message: text, onConfirm: () => (onConfirm ? onConfirm() : api.ui.dialog.clear()) }),
+  )
+}
+
+export function confirm(api, title, text) {
+  return new Promise((resolve) => {
+    api.ui.dialog.replace(() =>
+      api.ui.DialogConfirm({ title, message: text, onConfirm: () => resolve(true), onCancel: () => resolve(false) }),
+    )
+  })
+}
+
+export function prompt(api, title, text) {
+  return new Promise((resolve) => {
+    api.ui.dialog.replace(() =>
+      api.ui.DialogPrompt({ title, message: text, onConfirm: (value) => resolve(value), onCancel: () => resolve(null) }),
+    )
+  })
+}
+
+export function toast(api, variant, text) {
+  api.ui.toast({ variant, message: text })
+}
+
+export { NOTICE, componentSummary, message }