@rynx-ai/daemon 0.1.10 → 0.1.11-beta.2

package/dist/plugin-installer.js

@@ -1,81 +1,30 @@
-/**
- * Transactional plugin installation.
- *
- * Packages are first materialized in a host-owned staging directory. The
- * installer reads only static JSON metadata, validates every declared entry,
- * hashes the package, and atomically renames the validated tree into an
- * immutable installation path. Plugin code is never imported here.
- */
-import { randomUUID } from "node:crypto";
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync, } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
-import { PLUGIN_ID_PATTERN, pluginCliInvocationLeasePid, readPluginRuntimeLeases, removePluginRuntimeLease, } from "@rynx-ai/plugin-sdk";
+/** Transactional, package-manager-neutral plugin installation. */
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, realpathSync, renameSync, rmSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import { MARKETPLACE_ID_PATTERN, pluginCliInvocationLeasePid, readPluginRuntimeLeases, removePluginRuntimeLease, } from "@rynx-ai/plugin-sdk";
 import { rynxHome } from "@rynx-ai/core";
-import { getPlugin, isRunnablePluginRecord, removePlugin, upsertPlugin, } from "./plugin-store.js";
-import { detectPluginSource, inspectPluginPackage, materializePluginPackage, normalizePluginSpec, rebuildPluginPackage, } from "./plugin-package.js";
-import { pluginsDir } from "./registry.js";
 import { db } from "./db.js";
-const INSTALLATION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const STAGING_TRANSACTION_PATTERN = /^install-[A-Za-z0-9]{6}$/;
-const STAGING_OWNER_FILE = ".rynx-staging-owner.json";
-const PROMOTION_MARKER_SUFFIX = ".rynx-promoted";
-const MAX_HOST_MARKER_BYTES = 4 * 1024;
-const DEFAULT_STAGING_GC_AGE_MS = 24 * 60 * 60 * 1_000;
-/**
- * Install or replace one arbitrary npm/local/git/URL plugin package.
- *
- * A failed validation, materialization, atomic move, or registry update leaves
- * the previously registered installation untouched.
- */
+import { isBuiltInPluginMarketplace } from "./plugin-marketplace.js";
+import { detectPluginSource, inspectPluginPackage, materializePluginPackage, } from "./plugin-package.js";
+import { canonicalPluginId, getPlugin, removePlugin, upsertPlugin, } from "./plugin-store.js";
 export async function installPlugin(spec, onProgress = () => { }, opts = {}) {
     const prepared = await preparePluginInstallation(spec, onProgress, opts);
     try {
-        if (opts.expectedDigest !== undefined &&
-            !/^sha256-[A-Za-z0-9+/]{43}={0,2}$/.test(opts.expectedDigest)) {
-            throw new Error("expected plugin digest is invalid");
+        if (opts.expectedDigest && opts.expectedDigest !== prepared.integrity) {
+            throw new Error(`prepared plugin digest does not match ${opts.expectedDigest}`);
         }
-        if (opts.expectedDigest !== undefined &&
-            opts.expectedDigest !== prepared.integrity) {
-            throw new Error(`prepared plugin digest ${prepared.integrity} does not match ` +
-                `expected digest ${opts.expectedDigest}`);
-        }
-        if (prepared.manifest.requiresBuildScripts) {
-            if (!opts.allowScripts) {
-                throw new Error(`plugin "${prepared.name}" requires package build scripts; review digest ` +
-                    `${prepared.integrity} and re-run with --allow-scripts ` +
-                    `--expect-digest ${prepared.integrity}`);
-            }
-            if (opts.expectedDigest === undefined) {
-                throw new Error(`build-script approval must be bound to the prepared artifact; ` +
-                    `re-run with --expect-digest ${prepared.integrity}`);
-            }
-        }
-        const existing = prepared.existing;
-        if (existing && opts.onConflict && !(await opts.onConflict(existing))) {
+        if (prepared.existing && opts.onConflict && !(await opts.onConflict(prepared.existing))) {
             return {
-                name: prepared.name,
+                name: prepared.canonicalId,
+                canonicalId: prepared.canonicalId,
+                marketplaceId: prepared.marketplaceId,
+                pluginId: prepared.pluginId,
                 source: prepared.source,
-                ...(prepared.version ? { version: prepared.version } : {}),
+                version: prepared.version,
                 skipped: true,
             };
         }
-        if (opts.signal?.aborted)
-            throw new Error("plugin installation aborted");
-        const requested = new Set(prepared.manifest.requestedCapabilities);
-        if (!opts.approveCapabilities &&
-            opts.grants === undefined &&
-            !existing &&
-            requested.size > 0) {
-            throw new Error(`plugin "${prepared.name}" requests host capabilities; explicit grants or approval are required`);
-        }
-        const grants = opts.approveCapabilities
-            ? await opts.approveCapabilities(prepared.manifest, existing)
-            : opts.grants ??
-                (existing
-                    ? existing.grants.filter((capability) => requested.has(capability))
-                    : []);
         return await prepared.commit({
-            grants,
             expectedDigest: opts.expectedDigest ?? prepared.integrity,
             signal: opts.signal,
         });
@@ -84,163 +33,124 @@ export async function installPlugin(spec, onProgress = () => { }, opts = {}) {
         prepared.discard();
     }
 }
-/**
- * Materialize, build (only when explicitly allowed), inspect, and hash one
- * plugin into host-owned staging without mutating the registry.
- */
 export async function preparePluginInstallation(spec, onProgress = () => { }, opts = {}) {
     if (!spec.trim())
-        throw new Error("plugin spec must not be empty");
-    const progress = safeProgress(onProgress);
+        throw new Error("plugin source must not be empty");
+    opts.signal?.throwIfAborted();
     const source = detectPluginSource(spec);
-    const storedSpec = normalizePluginSpec(spec, source);
     const storage = ensureStorageRoots();
     const transactionDir = mkdtempSync(join(storage.stagingRoot, "install-"));
-    try {
-        writeStagingOwner(transactionDir);
-    }
-    catch (error) {
-        rmSync(transactionDir, { recursive: true, force: true });
-        throw error;
-    }
     const stagedPackage = join(transactionDir, "package");
-    let finalPath;
-    let registryUpdated = false;
     let consumed = false;
+    let promotedPath;
+    let promotedByThisTransaction = false;
     try {
-        await (opts.materializer ?? materializePluginPackage)({
-            spec: storedSpec,
+        const materialized = await (opts.materializer ?? materializePluginPackage)({
+            spec,
             source,
             destination: stagedPackage,
-            onProgress: progress,
+            onProgress: safeProgress(onProgress),
             signal: opts.signal,
         });
-        let inspected = await inspectPluginPackage(stagedPackage, {
-            requireEntries: false,
-            signal: opts.signal,
-        });
-        if (opts.allowScripts && !inspected.manifest.requiresBuildScripts) {
-            throw new Error(`plugin "${inspected.manifest.id}" does not declare requiresBuildScripts; ` +
-                "refusing unnecessary --allow-scripts approval");
+        validateMaterialized(materialized);
+        const inspected = await inspectPluginPackage(stagedPackage, { signal: opts.signal });
+        if (opts.expectedId && inspected.manifest.id !== opts.expectedId) {
+            throw new Error(`plugin update id mismatch: expected "${opts.expectedId}", received "${inspected.manifest.id}"`);
         }
-        const requiresBuildScripts = Boolean(inspected.manifest.requiresBuildScripts);
-        if (!requiresBuildScripts) {
-            inspected = await inspectPluginPackage(stagedPackage, { signal: opts.signal });
+        const marketplaceId = opts.marketplaceId ?? `direct-${materialized.sourceFingerprint}`;
+        if (!MARKETPLACE_ID_PATTERN.test(marketplaceId)) {
+            throw new Error(`invalid marketplace id "${marketplaceId}"`);
         }
-        const name = inspected.manifest.id;
-        if (opts.expectedId && name !== opts.expectedId) {
-            throw new Error(`plugin update id mismatch: expected "${opts.expectedId}", received "${name}"`);
+        const canonicalId = canonicalPluginId(inspected.manifest.id, marketplaceId);
+        if (opts.expectedIdentity && opts.expectedIdentity !== canonicalId) {
+            throw new Error(`plugin update identity mismatch: expected "${opts.expectedIdentity}", received "${canonicalId}"`);
         }
-        const existing = getPlugin(name);
+        const existing = getPlugin(canonicalId);
+        const manifest = cloneManifest(inspected.manifest);
         const cleanup = () => {
-            if (!registryUpdated && finalPath) {
-                removeOwnedInstallation(storage.installationsRoot, basename(dirname(finalPath)), finalPath);
-            }
-            try {
-                rmSync(transactionDir, { recursive: true, force: true });
-            }
-            catch {
-                /* orphaned staging is inactive and can be collected later */
+            rmSync(transactionDir, { recursive: true, force: true });
+            if (promotedByThisTransaction && promotedPath && !getPlugin(canonicalId)) {
+                rmSync(promotedPath, { recursive: true, force: true });
             }
         };
-        const preparedManifest = cloneManifest(inspected.manifest);
-        const preparedExisting = existing ? clonePluginRecord(existing) : undefined;
         return {
-            name,
+            name: canonicalId,
+            canonicalId,
+            marketplaceId,
+            pluginId: manifest.id,
             source,
-            ...(inspected.version ? { version: inspected.version } : {}),
-            manifest: cloneManifest(preparedManifest),
+            version: manifest.version,
+            manifest: cloneManifest(manifest),
             integrity: inspected.integrity,
-            ...(preparedExisting ? { existing: clonePluginRecord(preparedExisting) } : {}),
-            commit: async ({ grants, expectedDigest, signal }) => {
+            requestedSource: structuredClone(materialized.requestedSource),
+            resolvedRevision: materialized.resolvedRevision,
+            sourceFingerprint: materialized.sourceFingerprint,
+            ...(existing ? { existing: clonePluginRecord(existing) } : {}),
+            commit: async ({ expectedDigest, signal }) => {
                 if (consumed)
                     throw new Error("prepared plugin installation was already consumed");
                 consumed = true;
                 try {
-                    if (signal?.aborted)
-                        throw new Error("plugin installation aborted");
+                    signal?.throwIfAborted();
                     if (expectedDigest !== inspected.integrity) {
                         throw new Error("prepared plugin digest does not match expected digest");
                     }
-                    const rechecked = await inspectPluginPackage(stagedPackage, {
-                        ...(requiresBuildScripts ? { requireEntries: false } : {}),
-                        signal,
-                    });
+                    const rechecked = await inspectPluginPackage(stagedPackage, { signal });
                     if (rechecked.integrity !== inspected.integrity ||
-                        rechecked.version !== inspected.version ||
-                        JSON.stringify(rechecked.manifest) !== JSON.stringify(preparedManifest)) {
-                        throw new Error("prepared plugin artifact changed after approval");
+                        JSON.stringify(rechecked.manifest) !== JSON.stringify(manifest)) {
+                        throw new Error("prepared plugin artifact changed after preparation");
                     }
-                    let promoted = rechecked;
-                    if (requiresBuildScripts) {
-                        if (!opts.allowScripts) {
-                            throw new Error(`plugin "${name}" requires package build scripts; ` +
-                                `approve digest ${inspected.integrity} before running scripts`);
-                        }
-                        progress(`running digest-approved build scripts for plugin "${name}"`);
-                        await rebuildPluginPackage(stagedPackage, progress, signal);
-                        const built = await inspectPluginPackage(stagedPackage, { signal });
-                        if (JSON.stringify(built.manifest) !== JSON.stringify(preparedManifest) ||
-                            built.version !== inspected.version) {
-                            throw new Error("plugin build scripts changed static package identity or manifest metadata");
-                        }
-                        promoted = built;
-                    }
-                    const requested = new Set(preparedManifest.requestedCapabilities);
-                    for (const grant of grants) {
-                        if (!requested.has(grant)) {
-                            throw new Error(`plugin capability was not requested: ${grant}`);
+                    const target = pluginCachePath(marketplaceId, manifest.id, inspected.integrity, storage.cacheRoot);
+                    mkdirSync(join(storage.cacheRoot, marketplaceStorageSegment(marketplaceId), manifest.id), {
+                        recursive: true,
+                        mode: 0o700,
+                    });
+                    if (existsSync(target)) {
+                        const cached = await inspectPluginPackage(target, { signal });
+                        if (cached.integrity !== inspected.integrity) {
+                            throw new Error("plugin cache integrity collision");
                         }
+                        rmSync(stagedPackage, { recursive: true, force: true });
                     }
-                    if (new Set(grants).size !== grants.length) {
-                        throw new Error("plugin grants must be unique");
+                    else {
+                        renameSync(stagedPackage, target);
+                        promotedByThisTransaction = true;
                     }
+                    promotedPath = realpathSync(target);
                     db().transaction(() => {
-                        const current = getPlugin(name);
+                        const current = getPlugin(canonicalId);
                         if (!samePluginGeneration(existing, current)) {
-                            throw new Error(`plugin "${name}" changed concurrently; retry the installation`);
-                        }
-                        const leases = activeRuntimeLeases(name, storage.installationsRoot);
-                        if (leases.length > 0) {
-                            throw new Error(`plugin "${name}" has active runtime lease(s): ${leases
-                                .map((lease) => lease.leaseId)
-                                .join(", ")}; stop its managed services or CLI commands before updating`);
+                            throw new Error(`plugin "${canonicalId}" changed concurrently; retry`);
                         }
-                        const idRoot = ensureDirectDirectory(storage.installationsRoot, name, "plugin id directory");
-                        const installationId = randomUUID();
-                        finalPath = join(idRoot, installationId);
-                        const marker = promotionMarkerPath(idRoot, installationId);
-                        writePromotionMarker(marker);
-                        try {
-                            renameSync(stagedPackage, finalPath);
-                        }
-                        catch (error) {
-                            rmSync(marker, { force: true });
-                            finalPath = undefined;
-                            throw error;
-                        }
-                        progress(`staged validated plugin "${name}" → ${finalPath}`);
+                        // Keep the generation check and lease check in the same synchronous
+                        // transaction as the registry pointer switch. A CLI invocation
+                        // acquires its lease in its own immediate transaction, so the two
+                        // operations cannot pass each other's checks.
+                        assertNoActiveLeases(current);
                         upsertPlugin({
-                            name,
-                            spec: storedSpec,
+                            canonicalId,
+                            marketplaceId,
+                            pluginId: manifest.id,
                             source,
-                            version: promoted.version,
-                            installPath: finalPath,
-                            manifest: preparedManifest,
-                            integrity: promoted.integrity,
-                            grants,
+                            requestedSource: materialized.requestedSource,
+                            resolvedRevision: materialized.resolvedRevision,
+                            sourceFingerprint: materialized.sourceFingerprint,
+                            version: manifest.version,
+                            installPath: promotedPath,
+                            manifest,
+                            integrity: inspected.integrity,
                             enabled: current?.enabled,
                         });
                     }).immediate();
-                    registryUpdated = true;
-                    if (existing?.installPath && existing.installPath !== finalPath) {
-                        progress("retained superseded installation until the daemon switches versions");
-                    }
-                    progress(`installed plugin "${name}"${promoted.version ? `@${promoted.version}` : ""}`);
+                    promotedByThisTransaction = false;
+                    onProgress(`installed plugin "${canonicalId}" at ${manifest.version}`);
                     return {
-                        name,
+                        name: canonicalId,
+                        canonicalId,
+                        marketplaceId,
+                        pluginId: manifest.id,
                         source,
-                        ...(promoted.version ? { version: promoted.version } : {}),
+                        version: manifest.version,
                     };
                 }
                 finally {
@@ -256,138 +166,105 @@ export async function preparePluginInstallation(spec, onProgress = () => { }, op
         };
     }
     catch (error) {
-        if (!registryUpdated && finalPath) {
-            removeOwnedInstallation(storage.installationsRoot, basename(dirname(finalPath)), finalPath);
-        }
         rmSync(transactionDir, { recursive: true, force: true });
         throw error;
     }
 }
-/**
- * Remove the registry row but retain the immutable package until the next
- * daemon boot. A currently running supervisor may still be executing it.
- */
-export async function uninstallPlugin(name, onProgress = () => { }) {
-    const progress = safeProgress(onProgress);
+export async function uninstallPlugin(identity, onProgress = () => { }, options = {}) {
     let record;
     const removed = db().transaction(() => {
-        record = getPlugin(name);
+        record = getPlugin(identity);
         if (!record)
             return false;
-        const leases = activeRuntimeLeases(name, ensureStorageRoots().installationsRoot);
-        if (leases.length > 0) {
-            throw new Error(`plugin "${name}" has active runtime lease(s): ${leases
-                .map((lease) => lease.leaseId)
-                .join(", ")}; stop its managed services or CLI commands before uninstalling`);
+        if (isBuiltInPluginMarketplace(record.marketplaceId)) {
+            throw new Error(`bundled plugin "${record.canonicalId}" cannot be uninstalled; disable it instead`);
         }
-        return removePlugin(name);
+        assertNoActiveLeases(record);
+        return removePlugin(record.canonicalId);
     }).immediate();
-    if (!removed || !record)
+    if (!removed)
         return false;
-    if (record.installPath)
-        progress(`retained active package until the daemon stops using it`);
-    progress(`uninstalled plugin "${name}"`);
+    if (!record)
+        return false;
+    if (options.purgeData) {
+        rmSync(pluginDataDir(record.marketplaceId, record.pluginId), { recursive: true, force: true });
+        onProgress(`removed plugin data for "${record.canonicalId}"`);
+    }
+    onProgress(`uninstalled plugin "${record.canonicalId}"`);
     return true;
 }
-/**
- * Delete inactive immutable versions at a daemon-start safe point.
- *
- * A short grace window prevents a concurrently materializing install (renamed
- * just before its registry transaction) from being mistaken for an orphan.
- */
-export function pruneInactivePluginInstallations({ minAgeMs = 60_000, stagingMinAgeMs = DEFAULT_STAGING_GC_AGE_MS, now = Date.now(), } = {}) {
-    const { stagingRoot, installationsRoot } = ensureStorageRoots();
-    const minimumAge = Math.max(0, minAgeMs);
+export function pruneInactivePluginInstallations() {
+    const { cacheRoot } = ensureStorageRoots();
+    const active = new Set(listActivePaths().map(canonicalFilesystemPath));
     const removed = [];
-    pruneStagingTransactions(stagingRoot, Math.max(0, stagingMinAgeMs), now, removed);
-    for (const pluginId of readdirSync(installationsRoot)) {
-        if (!PLUGIN_ID_PATTERN.test(pluginId))
-            continue;
-        db().transaction(() => {
-            const active = new Set();
-            const current = getPlugin(pluginId);
-            if (current && isRunnablePluginRecord(current))
-                active.add(resolve(current.installPath));
-            for (const lease of activeRuntimeLeases(pluginId, installationsRoot)) {
-                active.add(resolve(lease.installPath));
-            }
-            const idRoot = join(installationsRoot, pluginId);
-            let idStat;
-            try {
-                idStat = lstatSync(idRoot);
-            }
-            catch {
-                return;
-            }
-            if (!idStat.isDirectory() || idStat.isSymbolicLink())
-                return;
-            const entries = readdirSync(idRoot);
-            for (const installationId of entries) {
-                if (!INSTALLATION_ID_PATTERN.test(installationId))
-                    continue;
-                const candidate = join(idRoot, installationId);
-                if (active.has(resolve(candidate)))
-                    continue;
-                let candidateStat;
-                try {
-                    candidateStat = lstatSync(candidate);
-                }
-                catch {
-                    continue;
-                }
-                if (!candidateStat.isDirectory() ||
-                    candidateStat.isSymbolicLink() ||
-                    now - promotionTimestampMs(idRoot, installationId, candidateStat.ctimeMs) < minimumAge) {
+    for (const marketplace of safeDirectories(cacheRoot)) {
+        for (const plugin of safeDirectories(join(cacheRoot, marketplace))) {
+            for (const integrity of safeDirectories(join(cacheRoot, marketplace, plugin))) {
+                const candidate = resolve(join(cacheRoot, marketplace, plugin, integrity));
+                if (active.has(canonicalFilesystemPath(candidate)))
                     continue;
-                }
-                if (removeOwnedInstallation(installationsRoot, pluginId, candidate)) {
-                    removed.push(candidate);
-                }
+                rmSync(candidate, { recursive: true, force: true });
+                removed.push(candidate);
             }
-            for (const entry of entries) {
-                const installationId = promotionMarkerInstallationId(entry);
-                if (!installationId || existsSync(join(idRoot, installationId)))
-                    continue;
-                const marker = join(idRoot, entry);
-                try {
-                    const stat = lstatSync(marker);
-                    if (stat.isFile() &&
-                        !stat.isSymbolicLink() &&
-                        now - stat.mtimeMs >= minimumAge) {
-                        rmSync(marker, { force: true });
-                    }
-                }
-                catch {
-                    // A concurrently removed orphan marker needs no further work.
-                }
-            }
-        }).immediate();
+        }
     }
     return removed;
 }
-function activeRuntimeLeases(pluginId, installationsRoot) {
-    const dataDir = join(rynxHome(), "plugin-data", pluginId);
-    return readPluginRuntimeLeases(dataDir).filter((lease) => {
-        if (lease.pluginId !== pluginId)
-            return false;
-        const invocationPid = pluginCliInvocationLeasePid(lease.leaseId);
-        if (invocationPid !== undefined && !isProcessAlive(invocationPid)) {
+export function pluginDataDir(marketplaceId, pluginId) {
+    return join(rynxHome(), "plugins", "data", marketplaceStorageSegment(marketplaceId), pluginId);
+}
+export function pluginRuntimeCacheDir(marketplaceId, pluginId, integrity) {
+    return join(rynxHome(), "plugins", "runtime-cache", marketplaceStorageSegment(marketplaceId), pluginId, integrityPath(integrity));
+}
+function pluginCachePath(marketplaceId, pluginId, integrity, root = join(rynxHome(), "plugins", "cache")) {
+    return join(root, marketplaceStorageSegment(marketplaceId), pluginId, integrityPath(integrity));
+}
+export function marketplaceStorageSegment(marketplaceId) {
+    if (!MARKETPLACE_ID_PATTERN.test(marketplaceId)) {
+        throw new Error(`invalid marketplace id "${marketplaceId}"`);
+    }
+    return encodeURIComponent(marketplaceId);
+}
+function integrityPath(integrity) {
+    const match = /^sha256-([A-Za-z0-9+/]{43}=?)$/.exec(integrity);
+    if (!match)
+        throw new Error("plugin integrity is invalid");
+    return `sha256-${match[1].replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")}`;
+}
+function ensureStorageRoots() {
+    const root = join(rynxHome(), "plugins");
+    const cacheRoot = join(root, "cache");
+    const stagingRoot = join(root, "staging");
+    mkdirSync(cacheRoot, { recursive: true, mode: 0o700 });
+    mkdirSync(stagingRoot, { recursive: true, mode: 0o700 });
+    return { cacheRoot, stagingRoot };
+}
+function assertNoActiveLeases(record) {
+    if (!record)
+        return;
+    const dataDir = pluginDataDir(record.marketplaceId, record.pluginId);
+    const active = readPluginRuntimeLeases(dataDir).filter((lease) => {
+        const pid = pluginCliInvocationLeasePid(lease.leaseId);
+        if (pid !== undefined && !isProcessAlive(pid)) {
             removePluginRuntimeLease(dataDir, lease.leaseId);
             return false;
         }
-        const candidate = resolve(lease.installPath);
-        if (dirname(candidate) !== join(installationsRoot, pluginId) ||
-            !INSTALLATION_ID_PATTERN.test(basename(candidate))) {
-            return false;
-        }
-        try {
-            const stat = lstatSync(candidate);
-            return stat.isDirectory() && !stat.isSymbolicLink() && realpathSync(candidate) === candidate;
-        }
-        catch {
-            return false;
-        }
+        return sameFilesystemPath(lease.installPath, record.installPath);
     });
+    if (active.length > 0) {
+        throw new Error(`plugin "${record.canonicalId}" has active generation lease(s): ${active.map((lease) => lease.leaseId).join(", ")}`);
+    }
+}
+function sameFilesystemPath(left, right) {
+    return canonicalFilesystemPath(left) === canonicalFilesystemPath(right);
+}
+function canonicalFilesystemPath(value) {
+    try {
+        return realpathSync(value);
+    }
+    catch {
+        return resolve(value);
+    }
 }
 function isProcessAlive(pid) {
     try {
@@ -401,144 +278,54 @@ function isProcessAlive(pid) {
 function samePluginGeneration(before, current) {
     if (!before || !current)
         return before === current;
-    return JSON.stringify(before) === JSON.stringify(current);
+    return before.canonicalId === current.canonicalId &&
+        before.integrity === current.integrity &&
+        before.updatedAt === current.updatedAt;
+}
+function validateMaterialized(value) {
+    if (!value ||
+        typeof value.resolvedRevision !== "string" ||
+        !value.resolvedRevision ||
+        !/^[0-9a-f]{32}$/.test(value.sourceFingerprint) ||
+        !value.requestedSource) {
+        throw new Error("plugin source materializer returned invalid provenance");
+    }
 }
 function cloneManifest(manifest) {
-    return JSON.parse(JSON.stringify(manifest));
+    return structuredClone(manifest);
 }
 function clonePluginRecord(record) {
-    return {
-        ...record,
-        ...(record.manifest ? { manifest: cloneManifest(record.manifest) } : {}),
-        grants: [...record.grants],
-    };
+    return structuredClone(record);
 }
-function writeStagingOwner(transactionDir) {
-    writeFileSync(join(transactionDir, STAGING_OWNER_FILE), `${JSON.stringify({ schemaVersion: 1, pid: process.pid, createdAt: new Date().toISOString() })}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
-}
-function pruneStagingTransactions(stagingRoot, minAgeMs, now, removed) {
-    for (const entry of readdirSync(stagingRoot)) {
-        if (!STAGING_TRANSACTION_PATTERN.test(entry))
-            continue;
-        const candidate = join(stagingRoot, entry);
+function safeDirectories(root) {
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root).filter((entry) => {
         try {
-            const stat = lstatSync(candidate);
-            if (!stat.isDirectory() ||
-                stat.isSymbolicLink() ||
-                dirname(realpathSync(candidate)) !== realpathSync(stagingRoot)) {
-                continue;
-            }
-            const owner = readStagingOwner(candidate);
-            if (owner?.pid && isProcessAlive(owner.pid))
-                continue;
-            const createdAt = owner?.createdAtMs ?? Math.max(stat.ctimeMs, stat.mtimeMs);
-            if (now - createdAt < minAgeMs)
-                continue;
-            rmSync(candidate, { recursive: true, force: true });
-            removed.push(candidate);
+            const info = lstatSync(join(root, entry));
+            return info.isDirectory() && !info.isSymbolicLink();
         }
         catch {
-            // Invalid or concurrently removed staging data is never followed.
-        }
-    }
-}
-function readStagingOwner(transactionDir) {
-    const file = join(transactionDir, STAGING_OWNER_FILE);
-    try {
-        const stat = lstatSync(file);
-        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_HOST_MARKER_BYTES)
-            return undefined;
-        const parsed = JSON.parse(readFileSync(file, "utf8"));
-        if (parsed.schemaVersion !== 1 ||
-            !Number.isSafeInteger(parsed.pid) ||
-            Number(parsed.pid) <= 0 ||
-            typeof parsed.createdAt !== "string" ||
-            !Number.isFinite(Date.parse(parsed.createdAt))) {
-            return undefined;
-        }
-        return { pid: Number(parsed.pid), createdAtMs: stat.mtimeMs };
-    }
-    catch {
-        return undefined;
-    }
-}
-function promotionMarkerPath(idRoot, installationId) {
-    return join(idRoot, `${installationId}${PROMOTION_MARKER_SUFFIX}`);
-}
-function writePromotionMarker(marker) {
-    writeFileSync(marker, `${JSON.stringify({ schemaVersion: 1, promotedAt: new Date().toISOString() })}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
-}
-function promotionTimestampMs(idRoot, installationId, conservativeFallback) {
-    try {
-        const stat = lstatSync(promotionMarkerPath(idRoot, installationId));
-        if (stat.isFile() && !stat.isSymbolicLink() && stat.size <= MAX_HOST_MARKER_BYTES) {
-            return stat.mtimeMs;
+            return false;
         }
-    }
-    catch {
-        // Installations predating promotion markers fall back to rename-sensitive ctime.
-    }
-    return conservativeFallback;
-}
-function promotionMarkerInstallationId(entry) {
-    const match = /^([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\.rynx-promoted$/i.exec(entry);
-    return match?.[1];
-}
-function ensureStorageRoots() {
-    const configuredRoot = resolve(pluginsDir());
-    mkdirSync(configuredRoot, { recursive: true, mode: 0o700 });
-    const root = realpathSync(configuredRoot);
-    return {
-        stagingRoot: ensureDirectDirectory(root, "staging", "plugin staging directory"),
-        installationsRoot: ensureDirectDirectory(root, "installed", "plugin installations directory"),
-    };
-}
-/** Create/validate one non-symlink direct child of a canonical parent. */
-function ensureDirectDirectory(parent, child, label) {
-    const path = join(parent, child);
-    if (!existsSync(path))
-        mkdirSync(path, { mode: 0o700 });
-    const stat = lstatSync(path);
-    if (!stat.isDirectory() || stat.isSymbolicLink()) {
-        throw new Error(`${label} must be a host-owned directory, not a symlink`);
-    }
-    const real = realpathSync(path);
-    if (dirname(real) !== realpathSync(parent)) {
-        throw new Error(`${label} resolves outside its host-owned parent`);
-    }
-    return real;
+    });
 }
-/**
- * Delete only `<installations>/<validated-id>/<host UUID>`.
- * Legacy paths, source directories, traversal strings, and symlinks are kept.
- */
-function removeOwnedInstallation(installationsRoot, pluginId, installPath) {
-    try {
-        if (!PLUGIN_ID_PATTERN.test(pluginId))
-            return false;
-        const root = realpathSync(installationsRoot);
-        const idRoot = join(root, pluginId);
-        const candidate = resolve(installPath);
-        if (dirname(candidate) !== idRoot || !INSTALLATION_ID_PATTERN.test(basename(candidate))) {
-            return false;
+function listActivePaths() {
+    const connection = db();
+    const paths = connection.prepare("SELECT install_path FROM plugin_installations").all().map((row) => resolve(row.install_path));
+    for (const row of connection.prepare("SELECT execution FROM sessions").all()) {
+        try {
+            const execution = JSON.parse(row.execution);
+            for (const skill of execution.pluginSkills ?? []) {
+                if (typeof skill.packageRoot === "string")
+                    paths.push(resolve(skill.packageRoot));
+            }
         }
-        const idStat = lstatSync(idRoot);
-        const candidateStat = lstatSync(candidate);
-        if (!idStat.isDirectory() ||
-            idStat.isSymbolicLink() ||
-            !candidateStat.isDirectory() ||
-            candidateStat.isSymbolicLink()) {
-            return false;
+        catch {
+            // Invalid Session snapshots pin nothing; the Session store rejects them.
         }
-        if (realpathSync(idRoot) !== idRoot || realpathSync(candidate) !== candidate)
-            return false;
-        rmSync(candidate, { recursive: true, force: true });
-        rmSync(promotionMarkerPath(idRoot, basename(candidate)), { force: true });
-        return true;
-    }
-    catch {
-        return false;
     }
+    return paths;
 }
 function safeProgress(callback) {
     return (line) => {
@@ -546,7 +333,7 @@ function safeProgress(callback) {
             callback(line);
         }
         catch {
-            /* progress reporting must never change installation state */
+            // Progress reporting never changes installation correctness.
         }
     };
 }