plugnz 0.0.4 → 0.0.6

package/src/hosts/kimi.ts

@@ -1,140 +0,0 @@
-/**
- * kimi host reader.
- *
- * Reader only — the writer (add/pin/remove) lives in
- * src/hosts/kimi-writer.ts so loading a reader never evaluates writer code
- * (AGENTS.md: doctor is read-only by construction).
- *
- * Real store layout (measured 2026-09-16, evidence in docs/hosts/kimi.md):
- *   ~/.kimi-code/plugins/installed.json — {version:1, plugins:[{id, root, source,
- *                                           enabled, installedAt, updatedAt, originalSource}]}
- *   ~/.kimi-code/plugins/managed/<id>/  — install dirs (`.kimi-plugin/plugin.json`
- *                                           native manifest with inline `mcpServers`,
- *                                           plus spec `.plugin/plugin.json` and
- *                                           `.mcp.json`/`mcp.json` copies)
- *
- * User-level MCP would be `[mcp_servers.<name>]` in ~/.kimi-code/config.toml
- * (kimi is a TOML-config host like codex). None exist on this machine as of
- * 2026-09-16, so that half of the reader is defensive and its shadow
- * semantics are unverified — see docs/hosts/kimi.md.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { parse as parseToml } from 'smol-toml';
-import type { HostReader, InstalledPlugin, McpServerEntry } from '../host';
-import { kimiRoot } from '../paths';
-import { collectPluginServers, readJson, type PluginMcpCandidate, type RawServerDef } from '../mcp';
-
-declare const Bun: any;
-declare const TextDecoder: any;
-
-export function pluginsDir(): string {
-  return join(kimiRoot(), 'plugins');
-}
-
-/**
- * Where a plugin declares MCP servers. The native manifest carries them inline
- * (measured), ahead of the spec copies `npx plugins` also dereferences.
- */
-export function mcpCandidates(): PluginMcpCandidate[] {
-  return [
-    { kind: 'inline', manifest: 'kimi.plugin.json' },
-    { kind: 'inline', manifest: join('.kimi-plugin', 'plugin.json') },
-    { kind: 'spec', file: '.mcp.json' },
-    { kind: 'spec', file: 'mcp.json' },
-  ];
-}
-
-function configFile(): string {
-  return join(kimiRoot(), 'config.toml');
-}
-
-export const kimi: HostReader = {
-  id: 'kimi',
-  gui: false,
-
-  detect(): boolean {
-    return existsSync(kimiRoot()) || explicitCurrentKimiBinary();
-  },
-
-  stores(): string[] {
-    return [join(pluginsDir(), 'managed')];
-  },
-
-  listInstalled(): InstalledPlugin[] {
-    const root = readJson(join(pluginsDir(), 'installed.json'));
-    if (root === null) return [];
-    const plugins = root['plugins'];
-    if (!Array.isArray(plugins)) return [];
-    const out: InstalledPlugin[] = [];
-    for (const raw of plugins) {
-      if (typeof raw !== 'object' || raw === null) continue;
-      const rec = raw as Record<string, unknown>;
-      const id = typeof rec['id'] === 'string' ? rec['id'] : null;
-      if (id === null) continue;
-      const path = typeof rec['root'] === 'string' ? rec['root'] : undefined;
-      const marker = path === undefined ? null : readJson(join(path, '.plgnz-install.json'));
-      const markerId = marker?.['pluginId'];
-      const ownedId = typeof markerId === 'string' && (markerId === id || new RegExp(`^${escapeRegExp(id)}@[a-z0-9][a-z0-9._-]*$`, 'iu').test(markerId)) ? markerId : id;
-      const at = ownedId.indexOf('@');
-      const plugin: InstalledPlugin = { id: ownedId, name: at < 0 ? ownedId : ownedId.slice(0, at) };
-      if (at >= 0) plugin.marketplace = ownedId.slice(at + 1);
-      if (path !== undefined && existsSync(path)) plugin.path = path;
-      if (rec['enabled'] === false) plugin.enabled = false;
-      out.push(plugin);
-    }
-    return out;
-  },
-
-  mcpEntries(): McpServerEntry[] {
-    const entries: McpServerEntry[] = [];
-    if (existsSync(configFile())) {
-      try {
-        const parsed: unknown = parseToml(readFileSync(configFile(), 'utf8'));
-        const config = typeof parsed === 'object' && parsed !== null ? (parsed as Record<string, unknown>) : null;
-        const servers =
-          config !== null && typeof config['mcp_servers'] === 'object' && config['mcp_servers'] !== null
-            ? (config['mcp_servers'] as Record<string, unknown>)
-            : null;
-        if (servers !== null) {
-          for (const [name, value] of Object.entries(servers)) {
-            if (typeof value !== 'object' || value === null) continue;
-            const def = value as RawServerDef;
-            const transport =
-              typeof def['url'] === 'string' ? 'http' : typeof def['command'] === 'string' ? 'stdio' : null;
-            if (transport === null) continue;
-            const entry: McpServerEntry = { name, transport, origin: 'user', file: configFile(), baseDir: kimiRoot() };
-            const command = def['command'];
-            if (typeof command === 'string') entry.command = command;
-            const rawArgs = def['args'];
-            if (Array.isArray(rawArgs)) entry.args = rawArgs.filter((a): a is string => typeof a === 'string');
-            if (def['enabled'] === false) entry.enabled = false;
-            entries.push(entry);
-          }
-        }
-      } catch {
-        // malformed config.toml — treated as no user-level MCP entries
-      }
-    }
-    for (const plugin of this.listInstalled()) {
-      if (plugin.path === undefined || !existsSync(plugin.path)) continue;
-      entries.push(...collectPluginServers(plugin.id, plugin.path, mcpCandidates()));
-    }
-    return entries;
-  },
-};
-
-/** An explicit current native binary is sufficient presence evidence; its writer initializes the selected root. */
-function explicitCurrentKimiBinary(): boolean {
-  const binary = process.env['OPEN_PLUGIN_KIMI_BIN'];
-  if (!binary || !existsSync(binary)) return false;
-  try {
-    const result = Bun.spawnSync([binary, '--version'], { stdout: 'pipe', stderr: 'pipe', timeout: 10_000 });
-    if (result.exitCode !== 0 || !(result.stdout instanceof Uint8Array)) return false;
-    const version = new TextDecoder().decode(result.stdout).trim();
-    const match = /^(\d+)\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u.exec(version);
-    return match !== null && Number(match[1]) > 0;
-  } catch { return false; }
-}
-
-function escapeRegExp(value: string): string { return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&'); }

package/src/hosts/omp-writer.ts

@@ -1,179 +0,0 @@
-/** Transactional writer for OMP's native npm/link extension-package lane. */
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { tmpdir } from 'node:os';
-import type { AddOptions, HostWriter, InstalledPlugin, PinOptions, PinOutcome } from '../host';
-import type { PluginSource, ResolvedSource } from '../source';
-import { projectPluginForOmp } from '../conversion';
-import { omp, mcpCandidates, pluginsDir } from './omp';
-import { pinPluginMcpFiles } from '../mcp-write';
-
-const MARKER = '.plgnz-install.json';
-const MANAGED = 'plgnz';
-type Ownership = { source: string; pluginId: string; fingerprint: string; packageName: string };
-type Doc = Record<string, unknown>;
-
-declare const TextEncoder: { new (): { encode(input?: string): Uint8Array } };
-
-export const ompWriter: HostWriter = {
-  ...omp,
-  supportsAdoption: true,
-  async add(plugin: PluginSource, resolved: ResolvedSource, opts?: AddOptions): Promise<void | 'unchanged'> {
-    const market = plugin.marketplace ?? 'local'; const id = `${plugin.name}@${market}`;
-    assertIdentity(market, 'marketplace'); assertIdentity(plugin.name, 'plugin');
-    const packageName = nativePackageName(market, plugin.name); const version = plugin.version ?? resolved.sha;
-    const managed = join(pluginsDir(), MANAGED); const target = join(managed, nativeSlug(market, plugin.name));
-    const link = join(pluginsDir(), 'node_modules', '@plgnz', nativeSlug(market, plugin.name));
-    const lockFile = join(pluginsDir(), 'omp-plugins.lock.json'); const registryFile = join(pluginsDir(), 'installed_plugins.json');
-    const lock = readDoc(lockFile, { plugins: {}, settings: {} }, 'lockfile'); const lockPlugins = object(lock.plugins, 'lockfile plugins');
-    const registry = readDoc(registryFile, { version: 2, plugins: {} }, 'registry'); const registryPlugins = object(registry.plugins, 'registry plugins');
-    const rows = userRows(registryPlugins[id]);
-    if (rows.length > 0) validateLegacy(rows, id, plugin.name, version, opts?.adoptExisting === true);
-    const owner = ownership(target);
-    if (owner === null && lstatExists(target)) throw new Error(`OMP managed package slot is unowned; refusing to replace it: ${target}`);
-    if (owner !== null && (owner.source !== resolved.sourceUri || owner.pluginId !== id || owner.packageName !== packageName)) throw new Error(`OMP plugin ${id} belongs to another source; refusing to replace it`);
-    assertOwnedLink(link, target, owner !== null);
-
-    const stage = mkdtempSync(join(tmpdir(), '.plgnz-omp-package-'));
-    try {
-      projectPluginForOmp(plugin.dir, stage, { packageName, version, activeRoot: target, namespace: plugin.name });
-      writeFileSync(join(stage, MARKER), JSON.stringify({ source: resolved.sourceUri, pluginId: id, fingerprint: plugin.contentFingerprint ?? '', packageName } satisfies Ownership));
-      const unchanged = owner !== null && owner.fingerprint === (plugin.contentFingerprint ?? '') && sameTree(stage, target) && linkPointsTo(link, target) && lockEnabled(lockPlugins[packageName]);
-      if (opts?.dryRun) return unchanged ? 'unchanged' : undefined;
-      if (unchanged && rows.length === 0) return 'unchanged';
-
-      mkdirSafe(managed); mkdirSafe(dirname(link));
-      const beforeLock = snapshot(lockFile); const beforeRegistry = snapshot(registryFile);
-      let active: Move | null = null; let previousLink: Move | null = null; let createdLink = false;
-      try {
-        if (!unchanged) active = activate(stage, target);
-        if (!unchanged) previousLink = moveExisting(link);
-        if (!unchanged) { symlinkSync(target, link, 'dir'); createdLink = true; }
-        const nextLockPlugins = { ...lockPlugins, [packageName]: { ...entry(lockPlugins[packageName]), version, enabledFeatures: null, enabled: true } };
-        const retained = nonUserRows(registryPlugins[id]);
-        if (retained.length === 0) delete nextLockPlugins[plugin.name];
-        const nextRegistryPlugins = { ...registryPlugins };
-        if (retained.length > 0) nextRegistryPlugins[id] = retained; else delete nextRegistryPlugins[id];
-        writeDoc(lockFile, { ...lock, plugins: nextLockPlugins });
-        if (rows.length > 0) writeDoc(registryFile, { ...registry, plugins: nextRegistryPlugins });
-      } catch (error) {
-        if (createdLink) rmSync(link, { recursive: true, force: true }); previousLink?.rollback(); active?.rollback();
-        restore(lockFile, beforeLock); restore(registryFile, beforeRegistry); throw error;
-      }
-      previousLink?.commit(); active?.commit();
-      const retainedPaths = registryInstallPaths(nextRegistryPlugins(registryPlugins, id));
-      for (const row of rows) cleanupLegacy(row, plugin.name, retainedPaths);
-      return unchanged ? 'unchanged' : undefined;
-    } finally { rmSync(stage, { recursive: true, force: true }); }
-  },
-  async pin(plugin: InstalledPlugin, opts?: PinOptions): Promise<PinOutcome> {
-    if (plugin.path === undefined || !existsSync(plugin.path)) return { changes: [], refusals: [] };
-    return pinPluginMcpFiles(plugin.path, mcpCandidates(), opts);
-  },
-  async remove(id: string): Promise<void> {
-    const owned = findOwned(id); if (owned === null) throw new Error(`OMP plugin ${id} is not plgnz-owned; refusing to remove it`);
-    const lockFile = join(pluginsDir(), 'omp-plugins.lock.json'); const lock = readDoc(lockFile, { plugins: {}, settings: {} }, 'lockfile');
-    const lockPlugins = object(lock.plugins, 'lockfile plugins'); const link = join(pluginsDir(), 'node_modules', owned.owner.packageName);
-    if (!linkPointsTo(link, owned.path)) throw new Error(`OMP native link for ${id} is missing or redirected; refusing to remove it`);
-    const before = snapshot(lockFile); let movedRoot: Move | null = null; let movedLink: Move | null = null;
-    try { movedRoot = moveExisting(owned.path); movedLink = moveExisting(link); const next = { ...lockPlugins }; delete next[owned.owner.packageName]; writeDoc(lockFile, { ...lock, plugins: next }); }
-    catch (error) { movedLink?.rollback(); movedRoot?.rollback(); restore(lockFile, before); throw error; }
-    movedLink?.commit(); movedRoot?.commit();
-  },
-};
-
-function nativePackageName(market: string, plugin: string): string { return `@plgnz/${nativeSlug(market, plugin)}`; }
-function nativeSlug(market: string, plugin: string): string { return `${hex(market)}-${hex(plugin)}`; }
-function hex(value: string): string { return Array.from(new TextEncoder().encode(value), byte => byte.toString(16).padStart(2, '0')).join(''); }
-function lockEnabled(value: unknown): boolean { return isDoc(value) && value.enabled === true; }
-function entry(value: unknown): Doc { return isDoc(value) ? value : {}; }
-
-function validateLegacy(rows: Array<Doc & { installPath?: unknown }>, id: string, name: string, version: string, adopt: boolean): void {
-  if (!adopt) throw new Error(`OMP marketplace install ${id} exists; pass --adopt-existing to migrate it to the native extension-package lane`);
-  const [marketplace] = id.split('@').slice(1); const cache = join(pluginsDir(), 'cache', 'plugins');
-  for (const row of rows) {
-    if (typeof row.installPath !== 'string' || typeof row.version !== 'string' || row.version !== version || marketplace === undefined) throw new Error(`OMP marketplace install ${id} has no safe native copy`);
-    const expected = join(cache, `${marketplace}___${name}___${version}`);
-    if (resolve(row.installPath) !== resolve(expected)) throw new Error(`OMP marketplace install ${id} is outside its approved cache slot`);
-    assertExistingDirectoryTree(cache, row.installPath, `OMP marketplace install ${id}`);
-    const manifest = readDoc(join(row.installPath, 'plugin.json'), {}, 'legacy plugin manifest');
-    if (manifest.name !== name || (typeof manifest.version === 'string' && manifest.version !== version)) throw new Error(`OMP marketplace install ${id} identity differs from the selected source`);
-  }
-}
-function cleanupLegacy(row: Doc & { installPath?: unknown }, name: string, retainedPaths: Set<string>): void {
-  if (typeof row.installPath !== 'string' || retainedPaths.has(resolve(row.installPath))) return;
-  const legacyLink = join(pluginsDir(), 'node_modules', name);
-  if (linkPointsTo(legacyLink, row.installPath)) rmSync(legacyLink, { force: true });
-  rmSync(row.installPath, { recursive: true, force: true });
-}
-function nextRegistryPlugins(registry: Doc, id: string): Doc { const next = { ...registry }; const retained = nonUserRows(registry[id]); if (retained.length > 0) next[id] = retained; else delete next[id]; return next; }
-function registryInstallPaths(registry: Doc): Set<string> { const paths = new Set<string>(); for (const value of Object.values(registry)) if (Array.isArray(value)) for (const row of value) if (isDoc(row) && typeof row.installPath === 'string') paths.add(resolve(row.installPath)); return paths; }
-function findOwned(id: string): { path: string; owner: Ownership } | null {
-  const root = join(pluginsDir(), MANAGED); if (!existsSync(root)) return null;
-  for (const name of readdirSync(root)) { const path = join(root, name); const owner = ownership(path); if (owner?.pluginId === id) return { path, owner }; }
-  return null;
-}
-function assertOwnedLink(path: string, target: string, owned: boolean): void {
-  if (!lstatExists(path)) return;
-  if (!owned || !linkPointsTo(path, target)) throw new Error(`OMP native package slot is unowned or redirected: ${path}`);
-}
-function lstatExists(path: string): boolean { try { lstatSync(path); return true; } catch { return false; } }
-function linkPointsTo(path: string, target: string): boolean { try { return lstatSync(path).isSymbolicLink() && resolve(dirname(path), readlinkSync(path)) === resolve(target); } catch { return false; } }
-
-type Move = { commit(): void; rollback(): void };
-function moveExisting(path: string): Move | null {
-  if (!lstatExists(path)) return null;
-  const root = mkdtempSync(join(dirname(path), '.plgnz-omp-backup-')); const backup = join(root, 'previous'); renameSync(path, backup);
-  return { commit: () => rmSync(root, { recursive: true, force: true }), rollback: () => { rmSync(path, { recursive: true, force: true }); renameSync(backup, path); rmSync(root, { recursive: true, force: true }); } };
-}
-function activate(stage: string, target: string): Move {
-  const old = moveExisting(target);
-  try {
-    if (process.env['OPEN_PLUGIN_TEST_OMP_ACTIVATION_FAILURE'] === 'after-old-move') throw new Error('forced OMP activation failure');
-    renameSync(stage, target);
-  } catch (error) {
-    old?.rollback();
-    throw error;
-  }
-  return { commit: () => old?.commit(), rollback: () => { rmSync(target, { recursive: true, force: true }); old?.rollback(); } };
-}
-function mkdirSafe(path: string): void {
-  const boundary = resolve(pluginsDir()); const target = resolve(path);
-  if (target !== boundary && !target.startsWith(`${boundary}/`)) throw new Error(`OMP managed path escapes the plugin store: ${target}`);
-  const parentBoundary = dirname(boundary);
-  for (let current = target; ; current = dirname(current)) {
-    if (lstatExists(current)) { const stat = lstatSync(current); if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error(`OMP managed path is unsafe: ${current}`); }
-    if (current === parentBoundary) break;
-  }
-  mkdirSync(path, { recursive: true }); let current = target;
-  while (true) {
-    const stat = lstatSync(current);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error(`OMP managed path is unsafe: ${current}`);
-    if (current === boundary) return;
-    current = dirname(current);
-  }
-}
-function assertExistingDirectoryTree(boundaryPath: string, targetPath: string, label: string): void {
-  const boundary = resolve(boundaryPath); const target = resolve(targetPath);
-  if (target !== boundary && !target.startsWith(`${boundary}/`)) throw new Error(`${label} escapes its approved cache root`);
-  for (let current = target; ; current = dirname(current)) {
-    if (!lstatExists(current)) throw new Error(`${label} has no safe native copy`);
-    const stat = lstatSync(current); if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error(`${label} contains a symlink or non-directory component: ${current}`);
-    if (current === boundary) return;
-  }
-}
-function sameTree(left: string, right: string): boolean {
-  if (!existsSync(right)) return false; const bytes = readFileSync as unknown as (path: string) => Uint8Array;
-  const list = (root: string): string[] => { const out: string[] = []; const walk = (dir: string, prefix: string): void => { for (const name of readdirSync(dir).sort()) { if (name === MARKER) continue; const path = join(dir, name); const rel = prefix ? `${prefix}/${name}` : name; const stat = lstatSync(path); if (stat.isSymbolicLink()) throw new Error(`OMP managed plugin contains symlink: ${path}`); if (stat.isDirectory()) walk(path, rel); else if (stat.isFile()) out.push(`${rel}:${Array.from(bytes(path)).join(',')}`); else throw new Error(`OMP managed plugin contains unsupported file: ${path}`); } }; walk(root, ''); return out; };
-  return JSON.stringify(list(left)) === JSON.stringify(list(right));
-}
-function ownership(path: string): Ownership | null { const marker = join(path, MARKER); if (!existsSync(marker)) return null; const value = readDoc(marker, {}, 'ownership marker'); if (typeof value.source !== 'string' || typeof value.pluginId !== 'string' || typeof value.fingerprint !== 'string' || typeof value.packageName !== 'string') throw new Error(`invalid plgnz ownership marker: ${marker}`); return value as Ownership; }
-function readDoc(path: string, fallback: Doc, label: string): Doc { if (!existsSync(path)) return fallback; try { const value: unknown = JSON.parse(readFileSync(path, 'utf8')); if (!isDoc(value)) throw new Error('expected object'); return value; } catch (error) { throw new Error(`invalid OMP ${label}: ${path} (${(error as Error).message})`); } }
-function object(value: unknown, label: string): Doc { if (!isDoc(value)) throw new Error(`invalid OMP ${label}`); return value; }
-function isDoc(value: unknown): value is Doc { return typeof value === 'object' && value !== null && !Array.isArray(value); }
-function userRows(value: unknown): Array<Doc & { installPath?: unknown }> { return Array.isArray(value) ? value.filter((row): row is Doc & { installPath?: unknown } => isDoc(row) && row.scope === 'user') : []; }
-function nonUserRows(value: unknown): unknown[] { return Array.isArray(value) ? value.filter(row => !isDoc(row) || row.scope !== 'user') : []; }
-function writeDoc(path: string, value: unknown): void { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, JSON.stringify(value, null, 2)); }
-function snapshot(path: string): string | undefined { return existsSync(path) ? readFileSync(path, 'utf8') : undefined; }
-function restore(path: string, value: string | undefined): void { if (value === undefined) rmSync(path, { force: true }); else writeFileSync(path, value); }
-function assertIdentity(value: string, label: string): void { if (!/^[a-z0-9][a-z0-9._-]*$/iu.test(value)) throw new Error(`unsafe OMP ${label}: ${value}`); }

package/src/hosts/omp.ts

@@ -1,153 +0,0 @@
-/**
- * omp host reader.
- *
- * Reader only — the writer (add/pin/remove) lives in
- * src/hosts/omp-writer.ts so loading a reader never evaluates writer code
- * (AGENTS.md: doctor is read-only by construction).
- *
- * Real store layout (measured 2026-09-16, evidence in docs/hosts/omp.md):
- *   ~/.omp/plugins/installed_plugins.json — claude-code-shaped registry:
- *                                           {version:2, plugins:{"<name>@<marketplace>":
- *                                           [{scope, installPath, version, …}]}
- *   ~/.omp/plugins/cache/plugins/<marketplace>___<name>___<version>/ — install dirs
- *                                           (flat triple-underscore keys, unlike
- *                                           claude-code's nested cache layout)
- *   ~/.omp/plugins/omp-plugins.lock.json  — {plugins:{<name>:{version, enabled, …}}}
- *   ~/.omp/plugins/node_modules/<name>    — symlinks into the cache
- *   ~/.omp/marketplaces.json              — {marketplaces:[{name, sourceType, sourceUri, catalogPath}]}
- *
- * omp is a native plugin host with its own store (AGENTS.md hosts list; ground
- * truth "Correction", 2026-09-16) — never routed through a repo-root
- * `.mcp.json`, which is the Claude Code project convention, not omp's plugin
- * surface. omp has no measured user-level MCP config (no ~/.omp/mcp.json on
- * this machine), so doctor's MCP surface is the installed plugins'
- * mcp.json/.mcp.json alone; the shadow check therefore has no user side to
- * trip on until such a config is verified to exist.
- */
-import { existsSync, lstatSync, readdirSync, readlinkSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import type { HostReader, InstalledPlugin, McpServerEntry } from '../host';
-import { ompRoot } from '../paths';
-import { collectPluginServers, readJson, type PluginMcpCandidate } from '../mcp';
-
-export function pluginsDir(): string {
-  return join(ompRoot(), 'plugins');
-}
-
-/** Where a plugin copy declares MCP servers (spec `mcp.json`, plus the `.mcp.json` twin). */
-export function mcpCandidates(): PluginMcpCandidate[] {
-  return [
-    { kind: 'spec', file: '.mcp.json' },
-    { kind: 'spec', file: 'mcp.json' },
-  ];
-}
-
-/** enabled state from omp-plugins.lock.json, keyed by bare plugin name. */
-function lockEnabled(name: string): boolean | undefined {
-  const root = readJson(join(pluginsDir(), 'omp-plugins.lock.json'));
-  if (root === null) return undefined;
-  const plugins = root['plugins'];
-  if (typeof plugins !== 'object' || plugins === null || Array.isArray(plugins)) return undefined;
-  const entry = (plugins as Record<string, unknown>)[name];
-  if (typeof entry !== 'object' || entry === null) return undefined;
-  return (entry as Record<string, unknown>)['enabled'] === false ? false : undefined;
-}
-
-type ManagedMarker = {
-  pluginId: string;
-  packageName: string;
-};
-
-function managedMarker(path: string): ManagedMarker | null {
-  const value = readJson(join(path, '.plgnz-install.json'));
-  if (value === null || typeof value['pluginId'] !== 'string' || typeof value['packageName'] !== 'string') return null;
-  return { pluginId: value['pluginId'], packageName: value['packageName'] };
-}
-
-function managedInstalled(): InstalledPlugin[] {
-  const managed = join(pluginsDir(), 'plgnz');
-  if (!existsSync(managed)) return [];
-  const out: InstalledPlugin[] = [];
-  for (const entry of readdirSync(managed).sort()) {
-    const path = join(managed, entry);
-    if (!lstatSync(path).isDirectory()) continue;
-    const marker = managedMarker(path);
-    const manifest = readJson(join(path, 'package.json'));
-    if (marker === null || manifest === null || manifest['name'] !== marker.packageName) continue;
-    const link = join(pluginsDir(), 'node_modules', marker.packageName);
-    try {
-      if (!lstatSync(link).isSymbolicLink() || resolve(dirname(link), readlinkSync(link)) !== resolve(path)) continue;
-    } catch {
-      continue;
-    }
-    const at = marker.pluginId.indexOf('@');
-    const name = at === -1 ? marker.pluginId : marker.pluginId.slice(0, at);
-    const marketplace = at === -1 ? undefined : marker.pluginId.slice(at + 1);
-    const plugin: InstalledPlugin = { id: marker.pluginId, name, path };
-    if (marketplace !== undefined) plugin.marketplace = marketplace;
-    if (typeof manifest['version'] === 'string') plugin.version = manifest['version'];
-    if (lockEnabled(marker.packageName) === false) plugin.enabled = false;
-    out.push(plugin);
-  }
-  return out;
-}
-
-export const omp: HostReader = {
-  id: 'omp',
-  gui: false,
-
-  /** omp is present iff its native store is — a stray repo .mcp.json must not conjure the host. */
-  detect(): boolean {
-    return existsSync(pluginsDir());
-  },
-
-  stores(): string[] {
-    return [pluginsDir()];
-  },
-
-  listInstalled(): InstalledPlugin[] {
-    const managed = managedInstalled();
-    const managedIds = new Set(managed.map(plugin => plugin.id));
-    const root = readJson(join(pluginsDir(), 'installed_plugins.json'));
-    if (root === null) return managed;
-    const plugins = root['plugins'];
-    if (typeof plugins !== 'object' || plugins === null || Array.isArray(plugins)) return managed;
-    const out: InstalledPlugin[] = [...managed];
-    for (const [id, value] of Object.entries(plugins as Record<string, unknown>)) {
-      if (managedIds.has(id)) continue;
-      const at = id.indexOf('@');
-      const name = at === -1 ? id : id.slice(0, at);
-      const marketplace = at === -1 ? undefined : id.slice(at + 1);
-      if (!Array.isArray(value)) continue;
-      for (const raw of value) {
-        if (typeof raw !== 'object' || raw === null) continue;
-        const rec = raw as Record<string, unknown>;
-        const version = typeof rec['version'] === 'string' ? rec['version'] : undefined;
-        const recordedPath = typeof rec['installPath'] === 'string' ? rec['installPath'] : undefined;
-        // Cache slots are flat: cache/plugins/<marketplace>___<name>___<version>.
-        const fallback =
-          marketplace !== undefined && version !== undefined
-            ? join(pluginsDir(), 'cache', 'plugins', `${marketplace}___${name}___${version}`)
-            : undefined;
-        const path = recordedPath !== undefined && existsSync(recordedPath) ? recordedPath : fallback;
-        const plugin: InstalledPlugin = { id, name };
-        if (marketplace !== undefined) plugin.marketplace = marketplace;
-        if (path !== undefined) plugin.path = path;
-        if (version !== undefined) plugin.version = version;
-        const enabled = lockEnabled(name);
-        if (enabled === false) plugin.enabled = false;
-        out.push(plugin);
-      }
-    }
-    return out;
-  },
-
-  mcpEntries(): McpServerEntry[] {
-    const entries: McpServerEntry[] = [];
-    for (const plugin of this.listInstalled()) {
-      if (plugin.path === undefined || !existsSync(plugin.path)) continue;
-      entries.push(...collectPluginServers(plugin.id, plugin.path, mcpCandidates()));
-    }
-    return entries;
-  },
-};

package/src/hosts/opencode-writer.ts

@@ -1,112 +0,0 @@
-/** Transactional OpenCode standalone delivery: private package + skill + command projections. */
-import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { tmpdir } from 'node:os';
-import type { AddOptions, HostWriter, InstalledPlugin, PinOptions, PinOutcome } from '../host';
-import type { PluginSource, ResolvedSource } from '../source';
-import { opencode, opencodeCommandsDir, opencodePackagesDir, opencodeRoot, opencodeSkillsDir } from './opencode';
-
-const MARKER = '.plgnz-install.json';
-type Owner = { source: string; pluginId: string; fingerprint: string };
-type Move = { target: string; backup?: string };
-type ManualSkill = { relative: string; name: string; description: string; body: string; base: string };
-type SourceCommand = { relative: string; name: string; description: string; body: string; base: string };
-type ProjectedCommand = { relative: string; name: string; description: string; body: string; base: string };
-declare const Bun: { YAML: { parse(input: string): unknown } };
-
-export const opencodeWriter: HostWriter = {
-  ...opencode,
-  async add(plugin: PluginSource, resolved: ResolvedSource, opts?: AddOptions): Promise<void | 'unchanged'> {
-    const market = plugin.marketplace ?? 'local', id = `${plugin.name}@${market}`, name = packageName(market, plugin.name);
-    assertIdentity(market); assertIdentity(plugin.name); assertStore(); assertTree(plugin.dir); assertSupportedRoot(plugin.dir);
-    const parent = opts?.dryRun ? tmpdir() : dirname(opencodeRoot());
-    if (!opts?.dryRun) mkdirSync(parent, { recursive: true });
-    const stage = mkdtempSync(join(parent, '.plgnz-opencode-stage-'));
-    try {
-      const targets = targetsFor(name, plugin.name); checkTargets(targets, id, resolved.sourceUri);
-      const staged = stagePackage(plugin.dir, stage, name, targets.private, { source: resolved.sourceUri, pluginId: id, fingerprint: plugin.contentFingerprint ?? '' });
-      const unchanged = allSame(staged, targets);
-      if (opts?.dryRun) return unchanged ? 'unchanged' : undefined;
-      ensureStore(); if (unchanged) return 'unchanged';
-      const moves: Move[] = [];
-      try {
-        for (const key of keys()) {
-          const target = targets[key];
-          if (!existsSync(target)) { moves.push({ target }); continue; }
-          const backupRoot = mkdtempSync(join(dirname(target), '.plgnz-opencode-backup-'));
-          const backup = join(backupRoot, 'previous'); renameSync(target, backup); moves.push({ target, backup });
-        }
-        for (const key of keys()) renameSync(staged[key], targets[key]);
-      } catch (error) {
-        for (const move of moves.reverse()) { rmSync(move.target, { recursive: true, force: true }); if (move.backup) renameSync(move.backup, move.target); }
-        throw error;
-      }
-      for (const move of moves) if (move.backup) rmSync(dirname(move.backup), { recursive: true, force: true });
-    } finally { rmSync(stage, { recursive: true, force: true }); }
-  },
-  async remove(id: string): Promise<void> {
-    const installed = opencode.listInstalled().find(item => item.id === id);
-    if (!installed?.path) throw new Error(`OpenCode has no plgnz-owned package for ${id}; refusing to remove`);
-    const name = installed.path.slice(opencodePackagesDir().length + 1); if (!validName(name)) throw new Error(`unsafe OpenCode package path: ${installed.path}`);
-    const plugin = installed.id.split('@', 1)[0]; if (!plugin || !validName(plugin)) throw new Error(`unsafe OpenCode plugin identity: ${installed.id}`);
-    const targets = targetsFor(name, plugin); assertStore();
-    for (const key of keys()) if (existsSync(targets[key])) { assertManagedTree(targets[key]); if (!owned(targets[key], id)) throw new Error(`OpenCode target is not owned by ${id}: ${targets[key]}`); }
-    const moves: Move[] = [];
-    try { for (const key of keys()) { const target = targets[key]; if (!existsSync(target)) continue; const root = mkdtempSync(join(dirname(target), '.plgnz-opencode-remove-')); const backup = join(root, 'previous'); renameSync(target, backup); moves.push({ target, backup }); } }
-    catch (error) { for (const move of moves.reverse()) if (move.backup) renameSync(move.backup, move.target); throw error; }
-    for (const move of moves) if (move.backup) rmSync(dirname(move.backup), { recursive: true, force: true });
-  },
-  async pin(_plugin: InstalledPlugin, _opts?: PinOptions): Promise<PinOutcome> { return { changes: [], refusals: [] }; },
-};
-
-function stagePackage(source: string, stage: string, name: string, activePrivateRoot: string, ownerValue: Owner): Targets {
-  const privateRoot = join(stage, 'private', name), skills = join(stage, 'skills', name), commands = join(stage, 'commands', name);
-  mkdirSync(skills, { recursive: true }); mkdirSync(commands, { recursive: true });
-  cpSync(source, privateRoot, { recursive: true });
-  for (const root of [privateRoot, skills, commands]) writeFileSync(join(root, MARKER), JSON.stringify(ownerValue));
-  const manuals = manualSkills(source); const commandsToProject: ProjectedCommand[] = [...sourceCommands(source), ...manuals.map(skill => ({ ...skill, relative: skill.name }))]; const commandNames = new Set<string>();
-  for (const command of commandsToProject) { if (commandNames.has(command.name)) throw new Error(`command collision: ${command.name}`); commandNames.add(command.name); }
-  for (const command of commandsToProject) writeCommand(join(commands, `${command.relative}.md`), command.description, rewriteCommandReferences(command.body, commandNames, ownerValue.pluginId.split('@', 1)[0] ?? ''), join(activePrivateRoot, command.base));
-  cpSync(source, skills, { recursive: true });
-  for (const skill of manuals) rmSync(join(skills, skill.relative), { force: true });
-  for (const root of [privateRoot, skills, commands]) writeFileSync(join(root, MARKER), JSON.stringify(ownerValue));
-  return { private: privateRoot, skills, commands };
-}
-function sourceCommands(source: string): SourceCommand[] {
-  const root = existsSync(join(source, '.claude', 'commands')) ? join(source, '.claude', 'commands') : join(source, 'commands');
-  if (!existsSync(root)) return [];
-  const out: SourceCommand[] = [];
-  const walk = (dir: string) => { for (const entry of readdirSync(dir).sort()) { const path = join(dir, entry), stat = lstatSync(path); if (stat.isDirectory()) { walk(path); continue; } if (!stat.isFile()) throw new Error(`OpenCode command is not a regular file: ${path}`); if (entry.endsWith('.toml')) throw new Error(`OpenCode cannot preserve TOML command semantics: ${path}`); if (!entry.endsWith('.md')) continue; const parsed = commandMarkdown(readFileSync(path, 'utf8'), path); const relative = path.slice(root.length + 1, -3); out.push({ relative, name: relative, description: parsed.description, body: parsed.body, base: dirname(path).slice(source.length + 1) }); } };
-  walk(root);
-  return out;
-}
-function manualSkills(source: string): ManualSkill[] {
-  const root = join(source, 'skills'); if (!existsSync(root)) return [];
-  const out: ManualSkill[] = [];
-  const walk = (dir: string) => { for (const entry of readdirSync(dir).sort()) { const path = join(dir, entry), stat = lstatSync(path); if (stat.isDirectory()) walk(path); else if (stat.isFile() && entry === 'SKILL.md') { const parsed = markdown(readFileSync(path, 'utf8'), path); if (parsed.manual) out.push({ relative: path.slice(source.length + 1), name: parsed.name, description: parsed.description, body: parsed.body, base: dirname(path).slice(source.length + 1) }); } } };
-  walk(root); return out;
-}
-function writeCommand(path: string, description: string, body: string, privateRoot: string): void { const preservedBody = body.endsWith('\n') ? body : `${body}\n`; mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, `---\ndescription: ${JSON.stringify(description)}\n---\n\n${preservedBody}\nBase directory for this command: ${privateRoot}\nRelative paths in this command are relative to this base directory.\n`); }
-function rewriteCommandReferences(body: string, names: Set<string>, namespace: string): string { return body.replace(/(^|[^A-Za-z0-9_/-])\/([A-Za-z0-9][A-Za-z0-9._/-]*)(?=\s|$|[.,:;!?])/gu, (whole, prefix: string, name: string) => names.has(name) ? `${prefix}/${namespace}/${name}` : whole); }
-function markdown(raw: string, path: string): { name: string; description: string; body: string; manual: boolean } { const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/); if (!match) throw new Error(`OpenCode projection needs Markdown frontmatter: ${path}`); let value: unknown; try { value = Bun.YAML.parse(match[1] ?? ''); } catch { throw new Error(`OpenCode projection has invalid YAML: ${path}`); } if (!record(value)) throw new Error(`OpenCode projection frontmatter must be an object: ${path}`); const description = value['description']; if (typeof description !== 'string' || !description.trim()) throw new Error(`OpenCode projection needs description: ${path}`); const name = typeof value['name'] === 'string' ? value['name'] : basenameStem(path); if (!validName(name)) throw new Error(`unsafe OpenCode command or skill name: ${path}`); const userInvocable = policy(value, 'user-invocable', 'user_invocable', path); if (userInvocable === false) throw new Error(`OpenCode cannot preserve user-invocable: false: ${path}`); const disableModelInvocation = policy(value, 'disable-model-invocation', 'disable_model_invocation', path); return { name, description, body: match[2] ?? '', manual: disableModelInvocation === true }; }
-function policy(frontmatter: Record<string, unknown>, hyphen: string, underscore: string, path: string): boolean | undefined { const first = frontmatter[hyphen], second = frontmatter[underscore]; if (first !== undefined && second !== undefined && first !== second) throw new Error(`conflicting OpenCode policy aliases ${hyphen}/${underscore}: ${path}`); const value = first ?? second; if (value !== undefined && typeof value !== 'boolean') throw new Error(`OpenCode policy ${hyphen} must be boolean: ${path}`); return value; }
-function commandMarkdown(raw: string, path: string): { description: string; body: string } { const parsed = markdown(raw, path); const front = Bun.YAML.parse((raw.match(/^---\r?\n([\s\S]*?)\r?\n---/) ?? [])[1] ?? ''); if (!record(front)) throw new Error(`OpenCode command frontmatter must be an object: ${path}`); for (const key of Object.keys(front)) if (key !== 'description') throw new Error(`OpenCode cannot preserve command metadata ${key}: ${path}`); if (/!`[\s\S]*?`/u.test(parsed.body) || /@\{/u.test(parsed.body)) throw new Error(`OpenCode cannot preserve command preprocessing: ${path}`); return parsed; }
-function basenameStem(path: string): string { const value = path.split('/').at(-2); if (!value) throw new Error(`OpenCode skill has no directory name: ${path}`); return value; }
-function packageName(market: string, plugin: string): string { const marketBytes = encode(market), pluginBytes = encode(plugin); return `plgnz-m${marketBytes.length}-${marketBytes}-p${pluginBytes.length}-${pluginBytes}`; }
-function encode(value: string): string { return [...value].map(char => char.codePointAt(0)?.toString(16) ?? '').join('x'); }
-function validName(value: string): boolean { return /^[a-z0-9][a-z0-9._-]*$/iu.test(value); }
-function assertIdentity(value: string): void { if (!validName(value)) throw new Error(`unsafe OpenCode identity: ${value}`); }
-function record(value: unknown): value is Record<string, unknown> { return typeof value === 'object' && value !== null && !Array.isArray(value); }
-type Targets = { private: string; skills: string; commands: string };
-function keys(): Array<keyof Targets> { return ['private', 'skills', 'commands']; }
-function targetsFor(name: string, commandNamespace: string): Targets { return { private: join(opencodePackagesDir(), name), skills: join(opencodeSkillsDir(), name), commands: join(opencodeCommandsDir(), commandNamespace) }; }
-function owner(path: string): Owner | null { const file = join(path, MARKER); if (!existsSync(file)) return null; try { const value: unknown = JSON.parse(readFileSync(file, 'utf8')); if (typeof value !== 'object' || value === null || Array.isArray(value)) throw new Error(); const item = value as Owner; if (typeof item.source !== 'string' || typeof item.pluginId !== 'string' || typeof item.fingerprint !== 'string') throw new Error(); return item; } catch { throw new Error(`invalid OpenCode ownership marker: ${file}`); } }
-function owned(privateTarget: string, id: string, source?: string): boolean { const mark = owner(privateTarget); return mark !== null && mark.pluginId === id && (source === undefined || mark.source === source); }
-function checkTargets(targets: Targets, id: string, source: string): void { for (const key of keys()) if (existsSync(targets[key])) { assertManagedTree(targets[key]); if (!owned(targets[key], id, source)) throw new Error(`OpenCode target is unowned or belongs to another source: ${targets[key]}`); } }
-function allSame(staged: Targets, targets: Targets): boolean { return keys().every(key => sameTree(staged[key], targets[key])); }
-function sameTree(a: string, b: string): boolean { if (!existsSync(a) || !existsSync(b)) return false; const bytes = readFileSync as unknown as (path: string) => Uint8Array; const list = (root: string): string[] => { const out: string[] = []; const walk = (dir: string, prefix: string) => { for (const name of readdirSync(dir).sort()) { if (name === MARKER) continue; const path = join(dir, name), rel = prefix ? `${prefix}/${name}` : name, stat = lstatSync(path); if (stat.isDirectory()) walk(path, rel); else if (stat.isFile()) out.push(`${rel}:${Array.from(bytes(path)).join(',')}`); else throw new Error(`OpenCode package has unsupported entry: ${path}`); } }; walk(root, ''); return out; }; return JSON.stringify(list(a)) === JSON.stringify(list(b)); }
-function assertTree(root: string): void { const stat = lstatSync(root); if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error(`OpenCode plugin root is not a real directory: ${root}`); for (const name of readdirSync(root)) { const path = join(root, name), child = lstatSync(path); if (name === MARKER) throw new Error(`OpenCode plugin reserves ${MARKER}: ${path}`); if (child.isSymbolicLink()) throw new Error(`OpenCode plugin contains symlink: ${path}`); if (child.isDirectory()) assertTree(path); else if (!child.isFile()) throw new Error(`OpenCode plugin contains unsupported entry: ${path}`); } }
-function assertManagedTree(root: string): void { const stat = lstatSync(root); if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error(`OpenCode managed tree is unsafe: ${root}`); for (const name of readdirSync(root)) { const path = join(root, name), child = lstatSync(path); if (child.isSymbolicLink()) throw new Error(`OpenCode managed tree contains symlink: ${path}`); if (child.isDirectory()) assertManagedTree(path); else if (!child.isFile()) throw new Error(`OpenCode managed tree contains unsupported entry: ${path}`); } }
-function assertSupportedRoot(source: string): void { for (const entry of ['agents', 'hooks', '.claude/agents', '.claude/hooks', 'mcp.json', '.mcp.json']) if (existsSync(join(source, entry))) throw new Error(`OpenCode cannot preserve root ${entry} semantics: ${join(source, entry)}`); for (const file of ['plugin.json', '.plugin/plugin.json', '.claude-plugin/plugin.json']) { const path = join(source, file); if (!existsSync(path)) continue; let manifest: unknown; try { manifest = JSON.parse(readFileSync(path, 'utf8')); } catch { throw new Error(`OpenCode plugin manifest is invalid: ${path}`); } if (!record(manifest)) throw new Error(`OpenCode plugin manifest is invalid: ${path}`); for (const field of ['mcpServers', 'hooks', 'agents']) if (manifest[field] !== undefined) throw new Error(`OpenCode cannot preserve plugin manifest ${field}: ${path}`); } }
-function assertStore(): void { for (const path of [opencodeRoot(), join(opencodeRoot(), '.plgnz'), opencodePackagesDir(), opencodeSkillsDir(), opencodeCommandsDir()]) if (existsSync(path) && (!lstatSync(path).isDirectory() || lstatSync(path).isSymbolicLink())) throw new Error(`OpenCode managed path is unsafe: ${path}`); }
-function ensureStore(): void { for (const path of [opencodeRoot(), join(opencodeRoot(), '.plgnz'), opencodePackagesDir(), opencodeSkillsDir(), opencodeCommandsDir()]) { mkdirSync(path, { recursive: true }); assertStore(); } }

package/src/hosts/opencode.ts

@@ -1,38 +0,0 @@
-/** Read-only owned standalone-package catalog for OpenCode. */
-import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import type { HostReader, InstalledPlugin, McpServerEntry } from '../host';
-
-const MARKER = '.plgnz-install.json';
-
-export function opencodeRoot(): string {
-  const explicit = process.env['OPEN_PLUGIN_OPENCODE_ROOT'];
-  if (explicit) return resolve(explicit);
-  return join(process.env['OPEN_PLUGIN_HOME'] || process.env['HOME'] || '.', '.config', 'opencode');
-}
-export function opencodePackagesDir(): string { return join(opencodeRoot(), '.plgnz', 'packages'); }
-export function opencodeSkillsDir(): string { return join(opencodeRoot(), 'skills'); }
-export function opencodeCommandsDir(): string { return join(opencodeRoot(), 'commands'); }
-
-export const opencode: HostReader = {
-  id: 'opencode', gui: false,
-  detect: () => existsSync(opencodeRoot()),
-  stores: () => [opencodePackagesDir(), opencodeSkillsDir(), opencodeCommandsDir()],
-  listInstalled(): InstalledPlugin[] {
-    const root = opencodePackagesDir();
-    if (!existsSync(root)) return [];
-    return readdirSync(root).flatMap(name => {
-      const path = join(root, name);
-      if (!lstatSync(path).isDirectory()) return [];
-      const marker = join(path, MARKER);
-      if (!existsSync(marker)) return [];
-      let value: unknown;
-      try { value = JSON.parse(readFileSync(marker, 'utf8')); } catch { throw new Error(`invalid OpenCode ownership marker: ${marker}`); }
-      if (!isRecord(value) || typeof value.pluginId !== 'string') throw new Error(`invalid OpenCode ownership marker: ${marker}`);
-      const at = value.pluginId.indexOf('@'); const plugin = at < 0 ? value.pluginId : value.pluginId.slice(0, at);
-      return [{ id: value.pluginId, name: plugin, ...(at < 0 ? {} : { marketplace: value.pluginId.slice(at + 1) }), path, contentRoots: { package: path, skills: join(opencodeSkillsDir(), name), commands: join(opencodeCommandsDir(), plugin) }, enabled: true }];
-    });
-  },
-  mcpEntries: (): McpServerEntry[] => [],
-};
-function isRecord(value: unknown): value is Record<string, unknown> { return typeof value === 'object' && value !== null && !Array.isArray(value); }