plugnz 0.0.4 → 0.0.5

package/src/hosts/dcode-writer.ts

@@ -1,150 +0,0 @@
-/** Transactional writer for dcode's recorded native plugin state. */
-import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, 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 { dcode, dcodeEnablementFile, dcodeRegistryFile, dcodeRoot, dcodeStateDir } from './dcode';
-import { requireCompatible } from '../compatibility';
-import { findConsumerProfile } from '../consumer-profiles';
-
-declare const Bun: any;
-
-const MARKER = '.plgnz-install.json';
-type Ownership = { source: string; pluginId: string; fingerprint: string };
-type Doc = Record<string, unknown>;
-
-export const dcodeWriter: HostWriter = {
-  ...dcode,
-  supportsAdoption: true,
-  async add(plugin: PluginSource, resolved: ResolvedSource, opts?: AddOptions): Promise<void | 'unchanged'> {
-    const market = plugin.marketplace || 'local'; const id = `${plugin.name}@${market}`;
-    assertIdentity(plugin.name, 'plugin'); assertIdentity(market, 'marketplace'); assertIdentity(resolved.sha, 'version');
-    const cache = join(dcodeRoot(), 'plugins', 'cache', market, plugin.name);
-    const target = join(cache, resolved.sha); assertManagedPath(cache); assertManagedPath(target); assertUnder(cache, target);
-    const registryFile = dcodeRegistryFile(), enablementFile = dcodeEnablementFile();
-    assertManagedPath(dcodeStateDir()); assertManagedPath(registryFile); assertManagedPath(enablementFile);
-    const registry = readRegistry(registryFile);
-    const enablement = readEnablement(enablementFile);
-    const plugins = object(registry.plugins, 'registry plugins'); const enabled = boolObject(enablement.enabledPlugins, 'enabledPlugins');
-    const stage = mkdtempSync(join(tmpdir(), '.plgnz-dcode-stage-'));
-    try {
-      const manifestVersion = stagePlugin(plugin.dir, stage, plugin.name);
-      assertPriorRows(plugins[id], id, cache, resolved.sourceUri, opts?.adoptExisting === true, plugin.name, manifestVersion);
-      writeFileSync(join(stage, MARKER), JSON.stringify({ source: resolved.sourceUri, pluginId: id, fingerprint: plugin.contentFingerprint ?? '' } satisfies Ownership));
-      const marker = ownership(target);
-      if (marker !== null && (marker.source !== resolved.sourceUri || marker.pluginId !== id)) throw new Error(`dcode plugin ${id} belongs to another source; refusing to replace it`);
-      if (existsSync(target) && marker === null) throw new Error(`dcode cache target is unowned; refusing to replace it: ${target}`);
-      const unchanged = marker !== null && marker.fingerprint === (plugin.contentFingerprint ?? '') && sameTree(stage, target);
-      const nextRegistry: Doc = { ...registry, plugins: { ...plugins, [id]: [{ installPath: target, version: resolved.sha }] } };
-      const nextEnablement: Doc = { ...enablement, enabledPlugins: { ...enabled, [id]: true } };
-      if (opts?.dryRun) { console.log(`[dcode] would activate directory: ${target}`); console.log(`[dcode] would update registry: ${registryFile}`); return unchanged ? 'unchanged' : undefined; }
-      mkdirSync(cache, { recursive: true });
-      const beforeRegistry = snapshot(registryFile), beforeEnablement = snapshot(enablementFile);
-      if (unchanged) { try { writeDoc(registryFile, nextRegistry); writeDoc(enablementFile, nextEnablement); } catch (error) { restore(registryFile, beforeRegistry); restore(enablementFile, beforeEnablement); throw error; } return 'unchanged'; }
-      const activation = activate(stage, target, cache);
-      try { writeDoc(registryFile, nextRegistry); writeDoc(enablementFile, nextEnablement); }
-      catch (error) { activation.rollback(); restore(registryFile, beforeRegistry); restore(enablementFile, beforeEnablement); throw error; }
-      activation.commit();
-    } finally { rmSync(stage, { recursive: true, force: true }); }
-  },
-  async pin(_plugin: InstalledPlugin, _opts?: PinOptions): Promise<PinOutcome> { return { changes: [], refusals: [] }; },
-  async remove(id: string): Promise<void> {
-    assertIdentity(id, 'plugin id'); const registryFile = dcodeRegistryFile(), enablementFile = dcodeEnablementFile();
-    assertManagedPath(dcodeStateDir()); assertManagedPath(registryFile); assertManagedPath(enablementFile);
-    const registry = readRegistry(registryFile); const enablement = readEnablement(enablementFile);
-    const plugins = object(registry.plugins, 'registry plugins'); const rows = rowsFor(plugins[id]);
-    if (rows.length === 0) return;
-    const cache = join(dcodeRoot(), 'plugins', 'cache');
-    if (rows.some(row => typeof row.installPath !== 'string' || ownership(row.installPath)?.pluginId !== id)) throw new Error(`dcode record ${id} is not wholly plgnz-owned; refusing to remove it`);
-    for (const row of rows) { assertUnder(cache, row.installPath as string); assertManagedPath(row.installPath as string); }
-    const moved: Array<{ commit(): void; rollback(): void }> = []; const beforeRegistry = snapshot(registryFile), beforeEnablement = snapshot(enablementFile);
-    try {
-      for (const row of rows) moved.push(moveAside(row.installPath as string));
-      const nextPlugins = { ...plugins }; delete nextPlugins[id]; const nextEnabled = { ...boolObject(enablement.enabledPlugins, 'enabledPlugins') }; delete nextEnabled[id];
-      writeDoc(registryFile, { ...registry, plugins: nextPlugins }); writeDoc(enablementFile, { ...enablement, enabledPlugins: nextEnabled });
-    } catch (error) { for (const backup of moved.reverse()) backup.rollback(); restore(registryFile, beforeRegistry); restore(enablementFile, beforeEnablement); throw error; }
-    for (const backup of moved) backup.commit();
-  },
-};
-
-function stagePlugin(source: string, stage: string, name: string): string | undefined {
-  assertNoSymlinks(source); cpSync(source, stage, { recursive: true }); assertNoSymlinks(stage);
-  const manifest = [join(stage, 'plugin.json'), join(stage, '.claude-plugin', 'plugin.json'), join(stage, '.codex-plugin', 'plugin.json')].find(existsSync);
-  if (!manifest) throw new Error('dcode stage has no supported plugin manifest');
-  const parsed = JSON.parse(readFileSync(manifest, 'utf8')) as Doc;
-  if (parsed.name !== name) throw new Error(`dcode manifest identity does not match ${name}`);
-  if (existsSync(join(stage, 'commands')) || existsSync(join(stage, '.claude', 'commands'))) requireDcodeCapability('commandProjection');
-  if (existsSync(join(stage, 'agents')) || existsSync(join(stage, '.claude', 'agents'))) throw new Error('dcode plugin agents are unsupported; refusing to activate');
-  for (const skill of skillFiles(stage)) {
-    const frontmatter = openingFrontmatter(readFileSync(skill, 'utf8'), skill);
-    if (frontmatter !== undefined) {
-      for (const key of ['disable-model-invocation', 'disable_model_invocation', 'user-invocable', 'user_invocable']) {
-        if (!Object.hasOwn(frontmatter, key)) continue;
-        const value = frontmatter[key];
-        if (typeof value !== 'boolean') throw new Error(`dcode skill invocation flag ${key} must be boolean: ${skill}`);
-        if (key.startsWith('disable') ? value : !value) requireDcodeCapability('userOnlySkills');
-      }
-    }
-    const sidecar = join(dirname(skill), 'agents', 'openai.yaml');
-    if (existsSync(sidecar)) {
-      let parsed: unknown;
-      try { parsed = Bun.YAML.parse(readFileSync(sidecar, 'utf8')); }
-      catch { throw new Error(`dcode skill invocation sidecar has invalid YAML: ${sidecar}`); }
-      if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) throw new Error(`dcode skill invocation sidecar must be an object: ${sidecar}`);
-      const policy = (parsed as Doc).policy;
-      if (typeof policy === 'object' && policy !== null && !Array.isArray(policy) && Object.hasOwn(policy, 'allow_implicit_invocation')) {
-        const value = (policy as Doc).allow_implicit_invocation;
-        if (typeof value !== 'boolean') throw new Error(`dcode skill invocation sidecar policy must be boolean: ${sidecar}`);
-        if (!value) requireDcodeCapability('userOnlySkills');
-      }
-    }
-  }
-  return typeof parsed.version === 'string' && parsed.version.length > 0 ? parsed.version : undefined;
-}
-function requireDcodeCapability(capability: 'commandProjection' | 'userOnlySkills'): void {
-  // TODO(2026-09-23): support user-only skills when native non-experimental semantics exist; DEEPAGENTS_CODE_EXPERIMENTAL middleware is intentionally deferred.
-  const profile = findConsumerProfile('dcode');
-  if (profile === undefined) throw new Error('dcode consumer profile is missing');
-  requireCompatible(profile, capability);
-}
-function skillFiles(root: string): string[] { const out: string[] = []; const walk = (dir: string): void => { for (const entry of readdirSync(dir)) { const path = join(dir, entry); const st = lstatSync(path); if (st.isDirectory()) walk(path); else if (entry === 'SKILL.md') out.push(path); } }; walk(root); return out; }
-function openingFrontmatter(raw: string, path: string): Record<string, unknown> | undefined { const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(raw); if (match === null) return undefined; let parsed: unknown; try { parsed = Bun.YAML.parse(match[1] ?? ''); } catch { throw new Error(`dcode skill frontmatter has invalid YAML: ${path}`); } if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) throw new Error(`dcode skill frontmatter must be an object: ${path}`); return parsed as Record<string, unknown>; }
-function readDoc(file: string, fallback: Doc, label: string): Doc { if (!existsSync(file)) return fallback; try { const value: unknown = JSON.parse(readFileSync(file, 'utf8')); if (typeof value !== 'object' || value === null || Array.isArray(value)) throw new Error('not an object'); return value as Doc; } catch (error) { throw new Error(`invalid dcode ${label}: ${file} (${(error as Error).message})`); } }
-function readRegistry(file: string): Doc { const registry = readDoc(file, { version: 2, plugins: {} }, 'registry'); if (registry.version !== 1 && registry.version !== 2) throw new Error(`invalid dcode registry version: ${file}`); const plugins = object(registry.plugins, 'registry plugins'); for (const [id, value] of Object.entries(plugins)) { if (!id || !Array.isArray(value) || value.length === 0) throw new Error(`invalid dcode registry record: ${id}`); for (const row of value) { if (typeof row !== 'object' || row === null || Array.isArray(row) || (typeof (row as Doc).installPath !== 'string' && typeof (row as Doc).install_path !== 'string')) throw new Error(`invalid dcode registry record: ${id}`); } } return registry; }
-function readEnablement(file: string): Doc { const enablement = readDoc(file, { version: 1, enabledPlugins: {} }, 'enablement'); if (enablement.version !== undefined && (!Number.isInteger(enablement.version) || (enablement.version as number) > 1)) throw new Error(`invalid dcode enablement version: ${file}`); boolObject(enablement.enabledPlugins, 'enabledPlugins'); return enablement; }
-function object(value: unknown, label: string): Doc { if (typeof value !== 'object' || value === null || Array.isArray(value)) throw new Error(`invalid dcode ${label}`); return value as Doc; }
-function boolObject(value: unknown, label: string): Record<string, boolean> { const result = object(value, label); if (Object.values(result).some(value => typeof value !== 'boolean')) throw new Error(`invalid dcode ${label}`); return result as Record<string, boolean>; }
-function rowsFor(value: unknown): Doc[] { if (!Array.isArray(value)) return []; return value.filter((value): value is Doc => typeof value === 'object' && value !== null && !Array.isArray(value)); }
-function assertPriorRows(value: unknown, id: string, cache: string, source: string, adopt: boolean, name: string, version: string | undefined): void {
-  const rows = rowsFor(value);
-  for (const row of rows) {
-    const install = typeof row.installPath === 'string' ? row.installPath : row.install_path;
-    if (typeof install !== 'string') throw new Error(`dcode install record ${id} has no installPath`);
-    assertUnder(cache, install); assertManagedPath(install);
-    const marker = ownership(install);
-    if (marker?.pluginId === id && marker.source === source) continue;
-    if (marker !== null || !adopt || rows.length !== 1 || !existsSync(install) || version === undefined || typeof row.version !== 'string' || row.version !== version || resolve(install) !== resolve(join(cache, version))) {
-      throw new Error(`dcode install record ${id} is not plgnz-owned; refusing to replace it`);
-    }
-    assertNoSymlinks(install);
-    const manifest = [join(install, 'plugin.json'), join(install, '.claude-plugin', 'plugin.json'), join(install, '.codex-plugin', 'plugin.json')].find(existsSync);
-    if (!manifest) throw new Error(`dcode legacy install ${id} has no supported manifest; refusing adoption`);
-    let legacy: Doc;
-    try { legacy = object(JSON.parse(readFileSync(manifest, 'utf8')) as unknown, 'legacy manifest'); }
-    catch { throw new Error(`dcode legacy install ${id} has invalid manifest; refusing adoption`); }
-    if (legacy.name !== name || legacy.version !== version) throw new Error(`dcode legacy install ${id} identity differs; refusing adoption`);
-  }
-}
-function ownership(dir: string): Ownership | null { assertManagedPath(dir); const file = join(dir, MARKER); assertManagedPath(file); if (!existsSync(file)) return null; try { const value = JSON.parse(readFileSync(file, 'utf8')) as Doc; if (typeof value.source !== 'string' || typeof value.pluginId !== 'string' || typeof value.fingerprint !== 'string') throw new Error('marker fields are invalid'); return value as Ownership; } catch (error) { throw new Error(`invalid dcode ownership marker: ${file} (${(error as Error).message})`); } }
-function writeDoc(file: string, value: Doc): void { mkdirSync(dirname(file), { recursive: true }); const temporary = `${file}.plgnz-${Date.now()}`; try { writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`); renameSync(temporary, file); } finally { rmSync(temporary, { force: true }); } }
-function snapshot(file: string): Uint8Array | undefined { const read = readFileSync as unknown as (path: string) => Uint8Array; return existsSync(file) ? read(file) : undefined; }
-function restore(file: string, before: Uint8Array | undefined): void { try { if (before === undefined) rmSync(file, { force: true }); else { mkdirSync(dirname(file), { recursive: true }); writeFileSync(file, before as unknown as string); } } catch {} }
-function activate(stage: string, target: string, parent: string): { commit(): void; rollback(): void } { if (!existsSync(target)) { renameSync(stage, target); return { commit: () => {}, rollback: () => rmSync(target, { recursive: true, force: true }) }; } const backup = moveAside(target, parent); try { renameSync(stage, target); } catch (error) { backup.rollback(); throw error; } return { commit: backup.commit, rollback: () => { rmSync(target, { recursive: true, force: true }); backup.rollback(); } }; }
-function moveAside(path: string, parent = dirname(path)): { commit(): void; rollback(): void } { const backupRoot = mkdtempSync(join(parent, '.plgnz-dcode-backup-')); const backup = join(backupRoot, 'previous'); renameSync(path, backup); return { commit: () => rmSync(backupRoot, { recursive: true, force: true }), rollback: () => { if (existsSync(backup)) renameSync(backup, path); rmSync(backupRoot, { recursive: true, force: true }); } }; }
-function sameTree(left: string, right: string): boolean { if (!existsSync(right)) return false; const read = readFileSync as unknown as (path: string) => Uint8Array; const listing = (root: string): string[] => { const out: string[] = []; const walk = (dir: string, prefix: string): void => { for (const entry of readdirSync(dir).sort()) { if (entry === MARKER) continue; const file = join(dir, entry), relative = prefix ? `${prefix}/${entry}` : entry, st = lstatSync(file); if (st.isDirectory()) walk(file, relative); else if (st.isFile()) out.push(`${relative}:${Array.from(read(file)).join(',')}`); else throw new Error(`dcode stage has unsupported entry: ${file}`); } }; walk(root, ''); return out; }; return JSON.stringify(listing(left)) === JSON.stringify(listing(right)); }
-function assertNoSymlinks(dir: string): void { for (const entry of readdirSync(dir)) { const file = join(dir, entry), st = lstatSync(file); if (st.isSymbolicLink()) throw new Error(`dcode plugin contains symlink: ${file}`); if (st.isDirectory()) assertNoSymlinks(file); } }
-function assertIdentity(value: string, label: string): void { if (!/^[A-Za-z0-9._-]+(?:@[A-Za-z0-9._-]+)?$/.test(value)) throw new Error(`invalid dcode ${label}`); }
-function assertUnder(root: string, path: string): void { const absoluteRoot = resolve(root), absolutePath = resolve(path); if (absolutePath === absoluteRoot || !absolutePath.startsWith(`${absoluteRoot}/`)) throw new Error(`dcode path escapes managed cache: ${path}`); }
-/** Reject links in the native root or any component beneath it before a write. */
-function assertManagedPath(path: string): void { const root = resolve(dcodeRoot()), target = resolve(path); if (target !== root && !target.startsWith(`${root}/`)) throw new Error(`dcode path escapes native root: ${path}`); let current = root; if (existsSync(current) && lstatSync(current).isSymbolicLink()) throw new Error(`dcode native path contains symlink: ${current}`); const relative = target.slice(root.length).replace(/^\//, ''); for (const part of relative ? relative.split('/') : []) { current = join(current, part); if (existsSync(current) && lstatSync(current).isSymbolicLink()) throw new Error(`dcode native path contains symlink: ${current}`); } }

package/src/hosts/dcode.ts

@@ -1,74 +0,0 @@
-/**
- * Read-only dcode (deepagents-code) plugin store reader.
- *
- * Evidence: deepagents-code 0.1.71 / upstream store.py at 59408ebe.  The
- * supported native state is `<DEEPAGENTS_HOME>/.state/{installed_plugins,
- * plugin_state}.json`; commands and invocation gating are deliberately not
- * inferred from the loader.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import type { HostReader, InstalledPlugin, McpServerEntry } from '../host';
-
-export function dcodeRoot(): string {
-  const explicit = process.env['OPEN_PLUGIN_DCODE_ROOT'];
-  if (explicit && explicit.length > 0) return resolve(explicit);
-  const home = process.env['OPEN_PLUGIN_HOME'] || process.env['HOME'] || '.';
-  return join(home, '.deepagents');
-}
-
-export function dcodeStateDir(): string { return join(dcodeRoot(), '.state'); }
-export function dcodeRegistryFile(): string { return join(dcodeStateDir(), 'installed_plugins.json'); }
-export function dcodeEnablementFile(): string { return join(dcodeStateDir(), 'plugin_state.json'); }
-
-type Registry = { version: 1 | 2; plugins: Record<string, unknown> };
-type Enablement = { version?: number; enabledPlugins: Record<string, boolean> };
-
-function registry(): Registry | null {
-  const file = dcodeRegistryFile();
-  if (!existsSync(file)) return null;
-  try {
-    const value: unknown = JSON.parse(readFileSync(file, 'utf8'));
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) return null;
-    const doc = value as Record<string, unknown>;
-    if ((doc.version !== 1 && doc.version !== 2) || typeof doc.plugins !== 'object' || doc.plugins === null || Array.isArray(doc.plugins)) return null;
-    return { version: doc.version, plugins: doc.plugins as Record<string, unknown> };
-  } catch { return null; }
-}
-
-function enablement(): Enablement | null {
-  const file = dcodeEnablementFile();
-  if (!existsSync(file)) return { enabledPlugins: {} };
-  try {
-    const value: unknown = JSON.parse(readFileSync(file, 'utf8'));
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) return null;
-    const doc = value as Record<string, unknown>;
-    if ((doc.version !== undefined && (!Number.isInteger(doc.version) || (doc.version as number) > 1)) || typeof doc.enabledPlugins !== 'object' || doc.enabledPlugins === null || Array.isArray(doc.enabledPlugins)) return null;
-    const entries = doc.enabledPlugins as Record<string, unknown>;
-    if (Object.values(entries).some((enabled) => typeof enabled !== 'boolean')) return null;
-    return { ...(typeof doc.version === 'number' ? { version: doc.version } : {}), enabledPlugins: entries as Record<string, boolean> };
-  } catch { return null; }
-}
-
-export const dcode: HostReader = {
-  id: 'dcode', gui: false,
-  detect: () => existsSync(dcodeRoot()),
-  stores: () => [dcodeRoot(), dcodeStateDir()],
-  listInstalled(): InstalledPlugin[] {
-    const installs = registry(); const enabled = enablement();
-    if (installs === null || enabled === null) return [];
-    const result: InstalledPlugin[] = [];
-    for (const [id, entries] of Object.entries(installs.plugins)) {
-      if (!Array.isArray(entries) || entries.length === 0) continue;
-      const entry = entries[0];
-      if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) continue;
-      const row = entry as Record<string, unknown>;
-      const path = typeof row.installPath === 'string' ? row.installPath : typeof row.install_path === 'string' ? row.install_path : undefined;
-      const at = id.indexOf('@'); const name = at < 0 ? id : id.slice(0, at); const marketplace = at < 0 ? undefined : id.slice(at + 1);
-      const plugin: InstalledPlugin = { id, name, ...(marketplace ? { marketplace } : {}), ...(path && existsSync(path) ? { path } : {}), ...(typeof row.version === 'string' ? { version: row.version } : {}), ...(enabled.enabledPlugins[id] === true ? { enabled: true } : { enabled: false }) };
-      result.push(plugin);
-    }
-    return result;
-  },
-  mcpEntries(): McpServerEntry[] { return []; },
-};

package/src/hosts/grok-writer.ts

@@ -1,254 +0,0 @@
-/** Transactional Grok Build marketplace writer. */
-import { spawnSync } from 'node:child_process';
-import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { parse as parseToml } from 'smol-toml';
-import { tmpdir } from 'node:os';
-import type { AddOptions, HostWriter, InstalledPlugin, PinOptions, PinOutcome } from '../host';
-import type { PluginSource, ResolvedSource } from '../source';
-import { fingerprintTree } from '../fingerprint';
-import { pinPluginMcpFiles } from '../mcp-write';
-import { homeRoot, grokRoot } from '../paths';
-import { grok, MARKER, canonical, localSourceOf, marketplacesRoot, namesOf, ownership, provenanceOf, registryIsReadable, repos, type GrokOwnership } from './grok';
-
-declare const Bun: { YAML: { parse(input: string): unknown; stringify(value: unknown): string }; CryptoHasher: new (algorithm: string) => { update(value: string): void; digest(encoding: 'hex'): string } };
-
-type MarketplaceRow = { name?: unknown; kind?: unknown; source?: { path?: unknown } };
-const stableId = (plugin: PluginSource) => plugin.marketplace === undefined ? plugin.name : `${plugin.name}@${plugin.marketplace}`;
-const digest = (value: string) => { const hash = new Bun.CryptoHasher('sha256'); hash.update(value); return hash.digest('hex').slice(0, 16); };
-
-export const grokWriter: HostWriter = {
-  ...grok,
-  supportsAdoption: true,
-  async add(plugin: PluginSource, resolved: ResolvedSource, opts?: AddOptions): Promise<void | 'unchanged'> {
-    const nativeFingerprint = validateGrokSource(plugin.dir);
-    if (!registryIsReadable()) throw new Error('Grok native registry is unreadable or unsupported; refusing mutation');
-    const id = stableId(plugin); const root = join(marketplacesRoot(), `plgnz-${digest(`${resolved.sourceUri}\0${id}`)}`); const parent = dirname(root);
-    const prior = canonical(root); const priorMarker = prior === undefined ? null : ownership(prior);
-    if (prior !== undefined && priorMarker === null) throw new Error(`Grok marketplace ${root} is unowned; refusing to replace it`);
-    if (priorMarker !== null && (priorMarker.source !== resolved.sourceUri || priorMarker.pluginId !== id)) throw new Error(`Grok marketplace ${root} belongs to another source; refusing to replace it`);
-    const legacy = legacyCandidate(plugin, opts?.adoptExisting === true, prior);
-    if (legacy === undefined) assertExistingNativeOwnership(id, plugin.name, root);
-    const unchanged = prior !== undefined && priorMarker?.fingerprint === plugin.contentFingerprint && priorMarker?.nativeFingerprint === nativeFingerprint && existsSync(join(prior, 'plugins', plugin.name)) && fingerprintTree(join(prior, 'plugins', plugin.name)) === nativeFingerprint && current(id, prior, plugin.name, nativeFingerprint);
-    if (opts?.dryRun) return unchanged ? 'unchanged' : undefined;
-    if (unchanged) return 'unchanged';
-    mkdirSync(parent, { recursive: true });
-    const stage = mkdtempSync(join(parent, '.plgnz-grok-stage-'));
-    const stagedRoot = join(stage, basename(root));
-    try {
-      const stagedPlugin = join(stagedRoot, 'plugins', plugin.name);
-      mkdirSync(dirname(stagedPlugin), { recursive: true }); cpSync(plugin.dir, stagedPlugin, { recursive: true });
-      projectGrokSource(stagedPlugin);
-      const catalog = join(stagedRoot, '.grok-plugin', 'marketplace.json');
-      mkdirSync(dirname(catalog), { recursive: true });
-      writeFileSync(catalog, JSON.stringify({ name: basename(root), plugins: [{ name: plugin.name, source: `./plugins/${plugin.name}` }] }));
-      writeFileSync(join(stagedRoot, MARKER), JSON.stringify({ source: resolved.sourceUri, pluginId: id, fingerprint: plugin.contentFingerprint ?? '', nativeFingerprint } satisfies GrokOwnership));
-      run(['plugin', 'validate', stagedPlugin]);
-      const priorFingerprint = priorMarker?.nativeFingerprint;
-      const backup = prior === undefined ? undefined : `${root}.plgnz-backup-${Date.now()}`;
-      let backedUp = false;
-      let legacyRemoved = false;
-      let legacyLinkRemoved = false;
-      try {
-        if (prior !== undefined) { renameSync(prior, backup!); backedUp = true; }
-        renameSync(stagedRoot, root);
-        ensureMarketplace(root);
-        if (legacy !== undefined) {
-          run(['plugin', 'uninstall', plugin.name, '--confirm']);
-          legacyRemoved = true;
-          if (grok.listInstalled().some(candidate => candidate.name === plugin.name)) throw new Error(`Grok ${id}: legacy uninstall left an active record`);
-          if (legacy.link !== undefined) { rmSync(legacy.link); legacyLinkRemoved = true; }
-        }
-        const installed = grok.listInstalled().find(candidate => candidate.id === id);
-        if (installed === undefined) run(['plugin', 'install', `${plugin.name}@local/${basename(root)}`, '--trust']);
-        else run(['plugin', 'update', plugin.name]);
-        run(['plugin', 'enable', plugin.name]);
-        if (!current(id, root, plugin.name, nativeFingerprint)) throw new Error(`Grok ${id}: native readback does not match staged content`);
-      } catch (error) {
-        if (backedUp && backup !== undefined) {
-          rmSync(root, { recursive: true, force: true }); renameSync(backup, root);
-          try {
-            ensureMarketplace(root); run(['plugin', 'update', plugin.name]); run(['plugin', 'enable', plugin.name]);
-            if (!current(id, root, plugin.name, priorFingerprint)) throw new Error(`Grok ${id}: native rollback did not restore the prior bytes`);
-          } catch (rollback) { throw new Error(`Grok ${id}: update failed and native rollback could not be verified: ${(rollback as Error).message}`, { cause: error }); }
-        } else if (backup === undefined) {
-          try {
-            if (marketplaceSources().some(row => typeof row.source?.path === 'string' && canonical(row.source.path) === canonical(root))) run(['plugin', 'marketplace', 'remove', root]);
-            rmSync(root, { recursive: true, force: true });
-            if (legacy !== undefined && legacyRemoved) {
-              run(['plugin', 'install', legacy.source, '--trust']);
-              run(['plugin', 'enable', plugin.name]);
-              const restored = grok.listInstalled().find(candidate => candidate.name === plugin.name);
-              if (restored?.path === undefined || fingerprintTree(restored.path) !== legacy.fingerprint) throw new Error(`Grok ${id}: legacy native content was not restored`);
-              if (legacyLinkRemoved && legacy.link !== undefined) symlinkSync(restored.path, legacy.link);
-            }
-          } catch (rollback) { throw new Error(`Grok ${id}: install failed and cleanup could not be verified: ${(rollback as Error).message}`, { cause: error }); }
-        }
-        throw error;
-      }
-      if (backup !== undefined) rmSync(backup, { recursive: true, force: true });
-    } finally { rmSync(stage, { recursive: true, force: true }); }
-  },
-  async remove(id: string): Promise<void> {
-    if (!registryIsReadable()) throw new Error('Grok native registry is unreadable or unsupported; refusing mutation');
-    const installed = grok.listInstalled().filter(plugin => plugin.id === id);
-    if (installed.length !== 1 || installed[0]?.path === undefined) throw new Error(`Grok ${id} is not a single plgnz-owned install; refusing native removal`);
-    const native = repos().find(([, candidate]) => candidate.path === installed[0]!.path);
-    if (native === undefined) throw new Error(`Grok ${id}: native registry readback is missing`);
-    const repo = native[1];
-    const provenance = provenanceOf(repo); if (provenance === null) throw new Error(`Grok ${id}: native install has no marketplace provenance`);
-    const root = canonical(provenance.root); const marker = root === undefined ? null : ownership(root);
-    if (root === undefined || marker?.pluginId !== id || marker.source === '' || provenance.subdir !== `plugins/${installed[0]!.name}` || canonical(localSourceOf(repo) ?? '') !== canonical(join(root, 'plugins', installed[0]!.name)) || namesOf(repo).length !== 1 || namesOf(repo)[0] !== installed[0]!.name) throw new Error(`Grok ${id}: native ownership proof is incomplete; refusing removal`);
-    assertOwnedRoot(root);
-    const shared = repos().filter(([, candidate]) => canonical(provenanceOf(candidate)?.root ?? '') === root);
-    if (shared.length !== 1) throw new Error(`Grok ${id}: marketplace root is shared by another native install; refusing removal`);
-    const sources = marketplaceSources().filter(source => typeof source.source?.path === 'string' && canonical(source.source.path) === root);
-    if (sources.length !== 1) throw new Error(`Grok ${id}: marketplace source is missing or ambiguous; refusing removal`);
-    run(['plugin', 'marketplace', 'remove', sources[0]!.source!.path as string]);
-    if (grok.listInstalled().some(plugin => plugin.id === id)) throw new Error(`Grok ${id}: native removal did not deactivate the plugin`);
-    rmSync(root, { recursive: true, force: true });
-  },
-  async pin(plugin: InstalledPlugin, opts?: PinOptions): Promise<PinOutcome> {
-    return plugin.path === undefined ? { changes: [], refusals: [] } : pinPluginMcpFiles(plugin.path, [
-      { kind: 'spec', file: '.mcp.json' },
-      { kind: 'inline', manifest: 'plugin.json' },
-    ], opts);
-  },
-};
-
-function basename(path: string): string { return path.slice(path.lastIndexOf('/') + 1); }
-/** Grok Build resolves its native store from GROK_HOME (xai-dirs/src/lib.rs). */
-function env(): Record<string, string | undefined> { const home = homeRoot(); return { ...process.env, HOME: home, GROK_HOME: grokRoot(), XDG_CONFIG_HOME: join(home, '.config'), XDG_DATA_HOME: join(home, '.local', 'share'), XDG_CACHE_HOME: join(home, '.cache'), CLAUDE_CONFIG_DIR: join(home, '.claude') }; }
-function binary(): string { const value = process.env['OPEN_PLUGIN_GROK_BIN'] ?? 'grok'; return value; }
-function run(args: string[]): string { const result = spawnSync(binary(), args, { env: env(), encoding: 'utf8' }); if (result.status !== 0) throw new Error(`grok ${args.join(' ')}: ${(result.stderr || result.stdout).trim()}`); return result.stdout; }
-function marketplaceSources(): MarketplaceRow[] { try { const value: unknown = JSON.parse(run(['plugin', 'marketplace', 'list', '--json'])); return Array.isArray(value) ? value.filter((row): row is MarketplaceRow => row !== null && typeof row === 'object') : []; } catch { return []; } }
-function ensureMarketplace(root: string): void { const rows = marketplaceSources().filter(row => typeof row.source?.path === 'string' && canonical(row.source.path) === canonical(root)); if (rows.length === 0) run(['plugin', 'marketplace', 'add', root]); else if (rows.length !== 1) throw new Error(`Grok marketplace ${root} is ambiguous`); }
-function current(id: string, root: string, name: string, fingerprint?: string): boolean {
-  const plugin = grok.listInstalled().find(candidate => candidate.id === id);
-  if (plugin?.path === undefined || plugin.enabled === false || (fingerprint !== undefined && fingerprintTree(plugin.path) !== fingerprint)) return false;
-  const repo = repos().find(([, candidate]) => candidate.path === plugin.path)?.[1];
-  if (repo === undefined) return false;
-  const provenance = provenanceOf(repo);
-  return provenance !== null && canonical(provenance.root) === canonical(root) && canonical(localSourceOf(repo) ?? '') === canonical(join(root, 'plugins', name)) && provenance.subdir === `plugins/${name}` && namesOf(repo).length === 1 && namesOf(repo)[0] === name && inspectCurrent(name, plugin.path);
-}
-function inspectCurrent(name: string, path: string): boolean { try { const value: unknown = JSON.parse(run(['inspect', '--json'])); if (value === null || typeof value !== 'object' || Array.isArray(value)) return false; const plugins = (value as Record<string, unknown>)['plugins']; return Array.isArray(plugins) && plugins.some(entry => entry !== null && typeof entry === 'object' && !Array.isArray(entry) && (entry as Record<string, unknown>)['name'] === name && (entry as Record<string, unknown>)['enabled'] !== false && typeof (entry as Record<string, unknown>)['path'] === 'string' && canonical((entry as Record<string, unknown>)['path'] as string) === canonical(path)); } catch { return false; } }
-function validateGrokSource(dir: string): string {
-  const stage = mkdtempSync(join(tmpdir(), 'plgnz-grok-preflight-'));
-  try { cpSync(dir, stage, { recursive: true }); projectGrokSource(stage); return fingerprintTree(stage); }
-  finally { rmSync(stage, { recursive: true, force: true }); }
-}
-
-/** Grok consumes native Markdown commands and frontmatter, not Codex policy sidecars. */
-function projectGrokSource(dir: string): void {
-  const manifest = join(dir, 'plugin.json');
-  if (existsSync(manifest)) {
-    const doc = JSON.parse(readFileSync(manifest, 'utf8')) as Record<string, unknown>;
-    if (doc['permissions'] !== undefined) throw new Error(`Grok permission semantics are unverified: ${manifest}`);
-    if (doc['commands'] !== undefined && doc['commands'] !== './commands' && doc['commands'] !== './commands/') throw new Error(`Grok custom command path is unverified: ${manifest}`);
-  }
-  const skills = join(dir, 'skills');
-  if (existsSync(skills)) for (const name of readdirSync(skills)) {
-    const skill = join(skills, name); if (!lstatSync(skill).isDirectory()) continue;
-    const file = join(skill, 'SKILL.md'); if (!existsSync(file)) continue;
-    const raw = readFileSync(file, 'utf8'); const fm = openingFrontmatter(raw, file);
-    const hadAlias = fm !== undefined && (Object.hasOwn(fm, 'disable_model_invocation') || Object.hasOwn(fm, 'user_invocable'));
-    const manual = fm === undefined ? undefined : normalizeBooleanPolicy(fm, 'disable-model-invocation', 'disable_model_invocation', file);
-    if (fm !== undefined) normalizeBooleanPolicy(fm, 'user-invocable', 'user_invocable', file);
-    const sidecar = join(skill, 'agents', 'openai.yaml');
-    let sidecarManual: boolean | undefined;
-    if (existsSync(sidecar)) {
-      const parsed: unknown = Bun.YAML.parse(readFileSync(sidecar, 'utf8'));
-      const policy = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? (parsed as Record<string, unknown>)['policy'] : undefined;
-      if (policy !== undefined) {
-        if (!policy || typeof policy !== 'object' || Array.isArray(policy) || typeof (policy as Record<string, unknown>)['allow_implicit_invocation'] !== 'boolean') throw new Error(`invalid Grok invocation sidecar: ${sidecar}`);
-        sidecarManual = !(policy as Record<string, boolean>)['allow_implicit_invocation'];
-      }
-    }
-    if (manual !== undefined && sidecarManual !== undefined && manual !== sidecarManual) throw new Error(`conflicting Grok invocation policy: ${file}`);
-    if (sidecarManual !== undefined && manual === undefined) {
-      if (fm === undefined) throw new Error(`Grok skill frontmatter required for sidecar policy: ${file}`);
-      fm['disable-model-invocation'] = sidecarManual;
-    }
-    if (fm !== undefined && (sidecarManual !== undefined && manual === undefined || hadAlias)) writeFileSync(file, withFrontmatter(raw, fm, file));
-  }
-  const commands = join(dir, 'commands'); const claudeCommands = join(dir, '.claude', 'commands');
-  const seen = new Set<string>();
-  for (const source of [commands, claudeCommands]) {
-    if (!existsSync(source)) continue;
-    for (const entry of readdirSync(source)) {
-      const path = join(source, entry); const stat = lstatSync(path);
-      if (!stat.isFile() || !/\.(md|toml)$/u.test(entry)) continue;
-      const name = entry.replace(/\.(md|toml)$/u, '');
-      if (seen.has(name)) throw new Error(`duplicate Grok command ${name}`); seen.add(name);
-      if (existsSync(join(skills, name, 'SKILL.md'))) throw new Error(`Grok command ${name} collides with a native skill`);
-      const output = join(commands, `${name}.md`);
-      if (entry.endsWith('.md')) {
-        const raw = readFileSync(path, 'utf8'); const fm = openingFrontmatter(raw, path);
-        if (!fm || typeof fm.description !== 'string') throw new Error(`Grok command needs description frontmatter: ${path}`);
-        const manual = normalizeBooleanPolicy(fm, 'disable-model-invocation', 'disable_model_invocation', path);
-        normalizeBooleanPolicy(fm, 'user-invocable', 'user_invocable', path);
-        if (/!`[\s\S]*?`/u.test(raw)) throw new Error(`Grok executable command preprocessing is unsupported: ${path}`);
-        if (fm['allowed-tools'] !== undefined || fm['permissionMode'] !== undefined) throw new Error(`Grok command permission semantics are unverified: ${path}`);
-        mkdirSync(commands, { recursive: true });
-        if (manual === undefined) fm['disable-model-invocation'] = true;
-        writeFileSync(output, withFrontmatter(raw, fm, path));
-      } else {
-        const parsed: unknown = parseToml(readFileSync(path, 'utf8'));
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error(`invalid Grok TOML command: ${path}`);
-        const doc = parsed as Record<string, unknown>;
-        if (typeof doc.description !== 'string' || typeof doc.prompt !== 'string') throw new Error(`Grok TOML command needs description and prompt: ${path}`);
-        if (Object.keys(doc).some(key => !['description', 'prompt', 'argument-hint', 'argument_hint', 'disable-model-invocation', 'disable_model_invocation', 'user-invocable', 'user_invocable'].includes(key))) throw new Error(`Grok TOML command has unsupported metadata: ${path}`);
-        for (const [native, alias] of [['argument-hint', 'argument_hint'], ['disable-model-invocation', 'disable_model_invocation'], ['user-invocable', 'user_invocable']] as const) if (doc[native] !== undefined && doc[alias] !== undefined && doc[native] !== doc[alias]) throw new Error(`conflicting Grok TOML command metadata: ${path}`);
-        if (/!`[\s\S]*?`/u.test(doc.prompt)) throw new Error(`Grok executable command preprocessing is unsupported: ${path}`);
-        const hint = doc['argument-hint'] ?? doc.argument_hint;
-        const disabled = doc['disable-model-invocation'] ?? doc.disable_model_invocation ?? true;
-        const invocable = doc['user-invocable'] ?? doc.user_invocable ?? true;
-        if ((hint !== undefined && typeof hint !== 'string') || typeof disabled !== 'boolean' || typeof invocable !== 'boolean') throw new Error(`invalid Grok TOML command policy: ${path}`);
-        mkdirSync(commands, { recursive: true });
-        writeFileSync(output, `---\ndescription: ${JSON.stringify(doc.description)}\n${hint === undefined ? '' : `argument-hint: ${JSON.stringify(hint)}\n`}disable-model-invocation: ${disabled}\nuser-invocable: ${invocable}\n---\n\n${doc.prompt}`);
-      }
-    }
-  }
-  const legacyMcp = join(dir, 'mcp.json'); const nativeMcp = join(dir, '.mcp.json');
-  if (existsSync(legacyMcp) && existsSync(nativeMcp) && readFileSync(legacyMcp, 'utf8') !== readFileSync(nativeMcp, 'utf8')) throw new Error(`conflicting Grok MCP declarations: ${legacyMcp} and ${nativeMcp}`);
-  if (existsSync(legacyMcp) && !existsSync(nativeMcp)) cpSync(legacyMcp, nativeMcp);
-  if (existsSync(nativeMcp)) { const value = JSON.parse(readFileSync(nativeMcp, 'utf8')) as Record<string, unknown>; const servers = value?.['mcpServers']; if (!value || typeof value !== 'object' || !servers || typeof servers !== 'object' || Array.isArray(servers)) throw new Error(`invalid Grok MCP declaration: ${nativeMcp}`); }
-}
-function openingFrontmatter(raw: string, path: string): Record<string, unknown> | undefined { const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(raw); if (match === null) return undefined; let value: unknown; try { value = Bun.YAML.parse(match[1] ?? ''); } catch { throw new Error(`Grok skill frontmatter has invalid YAML: ${path}`); } if (value === null || typeof value !== 'object' || Array.isArray(value)) throw new Error(`Grok skill frontmatter must be an object: ${path}`); return value as Record<string, unknown>; }
-function normalizeBooleanPolicy(metadata: Record<string, unknown>, native: string, alias: string, path: string): boolean | undefined {
-  const first = metadata[native], second = metadata[alias];
-  if (first !== undefined && second !== undefined && first !== second) throw new Error(`conflicting Grok invocation policy spellings: ${path}`);
-  const value = first ?? second;
-  if (value !== undefined && typeof value !== 'boolean') throw new Error(`Grok ${native} must be boolean: ${path}`);
-  if (second !== undefined) { metadata[native] = value; delete metadata[alias]; }
-  return value as boolean | undefined;
-}
-function withFrontmatter(raw: string, metadata: Record<string, unknown>, path: string): string {
-  const match = /^---\r?\n[\s\S]*?\r?\n---(?=\r?\n|$)/u.exec(raw);
-  if (match === null) throw new Error(`Grok frontmatter required: ${path}`);
-  return `---\n${Bun.YAML.stringify(metadata).trimEnd()}\n---${raw.slice(match[0].length)}`;
-}
-type LegacyInstall = { source: string; fingerprint: string; link?: string };
-function legacyCandidate(plugin: PluginSource, adopt: boolean, prior: string | undefined): LegacyInstall | undefined {
-  const matches = grok.listInstalled().filter(candidate => candidate.name === plugin.name);
-  if (matches.length === 0 || matches.length === 1 && matches[0]?.id === stableId(plugin)) return undefined;
-  if (!adopt || prior !== undefined || matches.length !== 1 || matches[0]?.path === undefined || matches[0].enabled === false) throw new Error(`Grok ${plugin.name}: an existing native install is not plgnz-owned; refusing to replace it`);
-  const installed = canonical(matches[0].path);
-  const base = canonical(join(grokRoot(), 'installed-plugins'));
-  if (installed === undefined || base === undefined || !installed.startsWith(`${base}/`) || lstatSync(matches[0].path).isSymbolicLink()) throw new Error(`Grok ${plugin.name}: legacy native path is unsafe`);
-  const rows = repos().filter(([, repo]) => canonical(typeof repo.path === 'string' ? repo.path : '') === installed);
-  if (rows.length !== 1 || provenanceOf(rows[0]![1]) !== null || namesOf(rows[0]![1]).length !== 1 || namesOf(rows[0]![1])[0] !== plugin.name) throw new Error(`Grok ${plugin.name}: legacy native identity is ambiguous`);
-  const source = localSourceOf(rows[0]![1]);
-  if (source === undefined || !existsSync(source) || lstatSync(source).isSymbolicLink()) throw new Error(`Grok ${plugin.name}: legacy source is missing or unsafe`);
-  const oldManifest = JSON.parse(readFileSync(join(installed, 'plugin.json'), 'utf8')) as Record<string, unknown>;
-  const newManifest = JSON.parse(readFileSync(join(plugin.dir, 'plugin.json'), 'utf8')) as Record<string, unknown>;
-  if (oldManifest.name !== plugin.name || newManifest.name !== plugin.name || oldManifest.version !== newManifest.version || fingerprintTree(source) !== fingerprintTree(installed)) throw new Error(`Grok ${plugin.name}: legacy source, version, and native bytes must match before adoption`);
-  const link = join(grokRoot(), 'plugins', plugin.name);
-  if (existsSync(link) || lstatExists(link)) {
-    if (!lstatSync(link).isSymbolicLink() || canonical(resolve(dirname(link), readlinkSync(link))) !== installed) throw new Error(`Grok ${plugin.name}: unmanaged same-name plugin link blocks adoption`);
-  }
-  return { source, fingerprint: fingerprintTree(installed), ...(lstatExists(link) ? { link } : {}) };
-}
-function lstatExists(path: string): boolean { try { lstatSync(path); return true; } catch { return false; } }
-function assertExistingNativeOwnership(id: string, name: string, root: string): void { const matches = grok.listInstalled().filter(plugin => plugin.name === name); if (matches.length === 0) return; if (matches.length !== 1 || matches[0]?.id !== id || matches[0].path === undefined) throw new Error(`Grok ${name}: an existing native install is not plgnz-owned; refusing to replace it`); const repo = repos().find(([, candidate]) => candidate.path === matches[0]!.path)?.[1]; if (repo === undefined) throw new Error(`Grok ${name}: an existing native install has no registry record`); const provenance = provenanceOf(repo); if (provenance === null || canonical(provenance.root) !== canonical(root) || canonical(localSourceOf(repo) ?? '') !== canonical(join(root, 'plugins', name)) || provenance.subdir !== `plugins/${name}` || namesOf(repo).length !== 1) throw new Error(`Grok ${name}: an existing native install has foreign provenance; refusing to replace it`); }
-function assertOwnedRoot(root: string): void { const base = canonical(marketplacesRoot()); if (base === undefined || root === base || !root.startsWith(`${base}/`)) throw new Error(`Grok marketplace root escapes plgnz storage: ${root}`); const relative = root.slice(base.length + 1).split('/'); let current = base; for (const part of relative) { current = join(current, part); const stat = lstatSync(current); if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error(`Grok marketplace root is not a safe owned directory: ${current}`); } }

package/src/hosts/grok.ts

@@ -1,94 +0,0 @@
-/** Grok Build reader. The writer is deliberately in grok-writer.ts. */
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
-import { join } from 'node:path';
-import { parse as parseToml } from 'smol-toml';
-import type { HostReader, InstalledPlugin, McpServerEntry } from '../host';
-import { grokRoot } from '../paths';
-import { collectPluginServers } from '../mcp';
-
-export const MARKER = '.plgnz-install.json';
-export type GrokOwnership = { source: string; pluginId: string; fingerprint: string; nativeFingerprint?: string };
-type Repo = { path?: unknown; plugins?: unknown; kind?: unknown; marketplace?: unknown };
-
-export function registryFile(): string { return join(grokRoot(), 'installed-plugins', 'registry.json'); }
-export function marketplacesRoot(): string { return join(grokRoot(), 'plgnz-marketplaces'); }
-export function configFile(): string { return join(grokRoot(), 'config.toml'); }
-export function readJson(path: string): Record<string, unknown> | null {
-  try { const value: unknown = JSON.parse(readFileSync(path, 'utf8')); return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null; }
-  catch { return null; }
-}
-export function canonical(path: string): string | undefined { try { return realpathSync(path); } catch { return undefined; } }
-export function ownership(root: string): GrokOwnership | null {
-  const value = readJson(join(root, MARKER));
-  if (value === null || typeof value['source'] !== 'string' || typeof value['pluginId'] !== 'string' || typeof value['fingerprint'] !== 'string') return null;
-  return value as GrokOwnership;
-}
-export function repos(): Array<[string, Repo]> {
-  const registry = readJson(registryFile());
-  if (registry?.['version'] !== 1 || registry['repos'] === null || typeof registry['repos'] !== 'object' || Array.isArray(registry['repos'])) return [];
-  return Object.entries(registry['repos'] as Record<string, unknown>).flatMap(([key, value]) => value !== null && typeof value === 'object' && !Array.isArray(value) ? [[key, value as Repo] as [string, Repo]] : []);
-}
-/** Absence is valid before first native install; a present registry must match the measured v1 shape. */
-export function registryIsReadable(): boolean {
-  if (!existsSync(registryFile())) return true;
-  const registry = readJson(registryFile());
-  return registry?.['version'] === 1 && registry['repos'] !== null && typeof registry['repos'] === 'object' && !Array.isArray(registry['repos']);
-}
-export function localSourceOf(repo: Repo): string | undefined {
-  const kind = repo.kind;
-  if (kind === null || typeof kind !== 'object' || Array.isArray(kind)) return undefined;
-  const record = kind as Record<string, unknown>;
-  return record['type'] === 'Local' && typeof record['source_path'] === 'string' ? record['source_path'] : undefined;
-}
-function marketplace(repo: Repo): { root: string; subdir: string; name?: string } | null {
-  const value = repo.marketplace;
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) return null;
-  const source = (value as Record<string, unknown>)['source_url_or_path']; const subdir = (value as Record<string, unknown>)['plugin_subdir']; const name = (value as Record<string, unknown>)['source_display_name'];
-  return typeof source === 'string' && typeof subdir === 'string' ? { root: source, subdir, ...(typeof name === 'string' ? { name } : {}) } : null;
-}
-function pluginNames(repo: Repo): string[] { return repo.plugins !== null && typeof repo.plugins === 'object' && !Array.isArray(repo.plugins) ? Object.keys(repo.plugins as Record<string, unknown>) : []; }
-function disabledPlugins(): Set<string> {
-  try {
-    const config: unknown = parseToml(readFileSync(configFile(), 'utf8'));
-    const plugins = config !== null && typeof config === 'object' && !Array.isArray(config) ? (config as Record<string, unknown>)['plugins'] : undefined;
-    const disabled = plugins !== null && typeof plugins === 'object' && !Array.isArray(plugins) ? (plugins as Record<string, unknown>)['disabled'] : undefined;
-    return new Set(Array.isArray(disabled) ? disabled.filter((value): value is string => typeof value === 'string') : []);
-  } catch { return new Set(); }
-}
-function validMarker(repo: Repo, name: string, marker: GrokOwnership | null, provenance: { root: string; subdir: string; name?: string } | null, root: string | undefined): marker is GrokOwnership {
-  if (marker === null || root === undefined || marker.source === '' || marker.pluginId.split('@', 1)[0] !== name || provenance?.subdir !== `plugins/${name}`) return false;
-  return canonical(localSourceOf(repo) ?? '') === canonical(join(root, 'plugins', name));
-}
-
-export const grok: HostReader = {
-  id: 'grok', gui: false,
-  detect(): boolean { return existsSync(grokRoot()) || process.env['OPEN_PLUGIN_GROK_BIN'] !== undefined || Bun.which('grok') !== null; },
-  stores(): string[] { return [join(grokRoot(), 'installed-plugins'), marketplacesRoot()]; },
-  listInstalled(): InstalledPlugin[] {
-    const out: InstalledPlugin[] = [];
-    const disabled = disabledPlugins();
-    for (const [, repo] of repos()) {
-      if (typeof repo.path !== 'string' || !existsSync(repo.path)) continue;
-      const provenance = marketplace(repo); const root = provenance === null ? undefined : canonical(provenance.root);
-      const marker = root === undefined ? null : ownership(root);
-      for (const name of pluginNames(repo)) {
-        const id = validMarker(repo, name, marker, provenance, root) ? marker.pluginId : (provenance?.name === undefined ? name : `${name}@${provenance.name}`);
-        const at = id.indexOf('@');
-        out.push({ id, name: at < 0 ? id : id.slice(0, at), ...(at < 0 ? {} : { marketplace: id.slice(at + 1) }), path: repo.path, contentRoots: { native: repo.path }, enabled: !disabled.has(name) });
-      }
-    }
-    return out;
-  },
-  mcpEntries(): McpServerEntry[] {
-    return this.listInstalled().flatMap(plugin => plugin.path === undefined || plugin.enabled === false ? [] :
-      collectPluginServers(plugin.id, plugin.path, [
-        { kind: 'spec', file: '.mcp.json' },
-        { kind: 'inline', manifest: 'plugin.json' },
-      ]));
-  },
-};
-
-export function provenanceOf(repo: Repo): { root: string; subdir: string; name?: string } | null { return marketplace(repo); }
-export function namesOf(repo: Repo): string[] { return pluginNames(repo); }
-
-declare const Bun: { which(command: string): string | null };