@capybara-hq/kernel 0.1.0-rc.0 → 0.1.0-rc.2

package/dist/catalog/plugin-import.js

@@ -1,24 +1,47 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 import { createHash, randomUUID } from "node:crypto";
 import { PLUGIN_MANIFEST_FILE, parseSkillMd, SDK_VERSION, SKILL_ENTRY_FILE, } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import semver from "semver";
 import { ApiError } from "../errors.js";
+import { ExtensionAdminOps } from "../extensions/admin-ops.js";
 import { writeSnapshot } from "../extensions/approvals.js";
+import { ExtensionBlobs } from "../extensions/blobs.js";
+import { ExtensionInstalls } from "../extensions/installs.js";
+import { PluginApproveLock, PluginInstallLock } from "../extensions/locks.js";
 import { unrunMigrations } from "../extensions/migrate-lock.js";
 import { ExtensionPackageError, permissionSetOfPackage, readExtensionPackage, } from "../extensions/package.js";
 import { diffPermissions, permissionKeys, WARNINGS_KEY_PREFIX, } from "../extensions/permission-set.js";
 import { reviewHash as extensionReviewHash, migrationWarnings, permissionGroups, permissionKeyItems, } from "../extensions/permission-view.js";
+import { ExtensionRegistry } from "../extensions/registry.js";
 import { audit } from "../identity/audit.js";
-import { lockEnterpriseAdmins, lockEnterpriseAdminsAndAuthorize, } from "../identity/enterprise-admin.js";
+import { EnterpriseAdminLock } from "../identity/enterprise-admin.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { KERNEL_LOGGER } from "../infra/tokens.js";
 import { packPackageTgz } from "../packages/tgz.js";
 import { checkSkillFiles, SkillArchiveError } from "../skills/package.js";
+import { StorageService } from "../storage/storage.service.js";
 import { endpointCredentialIssues } from "../tools/endpoint.js";
 import { canonicalJson } from "../tools/registry.js";
-import { assertPluginNameOwner, catalogObjectPrefix, itemView, permissionsMismatch, precheckCatalogImport, putCatalogFiles, templateProblems, writeCatalogVersion, } from "./catalog.service.js";
+import { findConnectorIn } from "./catalog-content.js";
+import { assertPluginNameOwner, catalogObjectPrefix, itemView, permissionsMismatch, precheckCatalogImport, putCatalogFiles, templateProblems, writeCatalogVersion, } from "./catalog-items.js";
 import { CLAUDE_PLUGIN_FILE, claudeContentDigest, } from "./claude/manifest.js";
 import { CLAUDE_MCP_CONNECTOR } from "./claude/mcp.js";
 import { item as reportItem, sortItems, } from "./claude/report.js";
 import { isClaudePluginTree, translateClaudePlugin } from "./claude/translate.js";
+import { CatalogItemLock } from "./locks.js";
 import { PluginPackageError, packagePath, readPluginFiles, readPluginPackage, } from "./plugin-package.js";
 import { maxSatisfying, satisfiesRange } from "./versions.js";
 /**
@@ -67,6 +90,7 @@ const NOT_NPM = { provenance: { checked: false, reason: "not an npm package" } }
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const notFound = () => new ApiError("plugin.staging_not_found", "This plugin import was not found or has expired (staged imports are kept for 24 hours); prepare it again");
 const invalid = (problems) => new ApiError("catalog.invalid_manifest", `Invalid plugin package: ${problems[0] ?? "unknown problem"}`, problems.slice(0, 50));
+const reviewStale = (review) => new ApiError("plugin.review_stale", `The review of plugin ${review.name} ${review.version} is out of date (it changed, or its extension on this deployment changed since it was prepared); review it again`);
 const mismatch = (what) => new ApiError("marketplace.package_mismatch", `The downloaded package does not match the marketplace entry: ${what}`);
 /**
  * The API error of a plugin package that cannot be read in a catalog path: the pre-0.1.0 format ->
@@ -96,15 +120,75 @@ const fileOf = (path, data) => ({
     sha256: createHash("sha256").update(data).digest("hex"),
     data,
 });
-/**
- * The enterprise-admin re-check under the lock. `actor` null is the CLI (the operator of the
- * deployment: no account to re-check, audits carry no actor), like `ExtensionInstalls.ingest`.
- */
-const authorizeActor = (trx, actor) => actor === null ? lockEnterpriseAdmins(trx) : lockEnterpriseAdminsAndAuthorize(trx, actor);
-export class PluginImport {
-    d;
-    constructor(d) {
-        this.d = d;
+let PluginImport = class PluginImport {
+    kdb;
+    adminLock;
+    installLock;
+    approveLock;
+    itemLock;
+    config;
+    installs;
+    ops;
+    blobs;
+    registry;
+    log;
+    txHost;
+    /** Where plugin files go (the kernel's object storage; the CLI's own, see {@link useCliStorage}). */
+    files;
+    /**
+     * false: this process loads no connectors (the CLI), so a template of an unknown connector gets
+     * only the static endpoint checks and `endpointChecked: false`; the org install re-checks it
+     * against the loaded connector.
+     */
+    connectorsLoaded = true;
+    constructor(kdb, 
+    /** The enterprise admin lock (identity/enterprise-admin.ts): joins the caller's transaction. */
+    adminLock, installLock, approveLock, itemLock, config, storage, installs, ops, 
+    /** Reads a package from the package store (confirm recomputes the permission set). */
+    blobs, 
+    /** Config-declared names, loaded connectors and extension versions (the extension registry). */
+    registry, log, txHost) {
+        this.kdb = kdb;
+        this.adminLock = adminLock;
+        this.installLock = installLock;
+        this.approveLock = approveLock;
+        this.itemLock = itemLock;
+        this.config = config;
+        this.installs = installs;
+        this.ops = ops;
+        this.blobs = blobs;
+        this.registry = registry;
+        this.log = log;
+        this.txHost = txHost;
+        this.files = storage;
+    }
+    /** The kernel-schema handle of the current context (the transaction, else the pool). */
+    get db() {
+        return this.kdb.db;
+    }
+    /**
+     * CLI only (like `ExtensionHost.noteInspected`): plugin files go to the object store the CLI set
+     * up itself, and connector templates get static checks only (the CLI loads no connector). Called
+     * once, right after the command's context is created.
+     */
+    useCliStorage(storage) {
+        this.files = storage;
+        this.connectorsLoaded = false;
+    }
+    /**
+     * The enterprise-admin re-check under the lock, in the caller's transaction. `actor` null is the
+     * CLI (the operator of the deployment: no account to re-check, audits carry no actor), like
+     * `ExtensionInstalls.ingest`.
+     */
+    async authorizeActor(actor) {
+        if (actor === null)
+            await this.adminLock.lock();
+        else
+            await this.adminLock.lockAndAuthorize(actor);
+    }
+    /** The re-check alone, in a transaction of its own (before anything is written). */
+    async authorize(actor) {
+        await this.authorizeActor(actor);
     }
     /**
      * Reads, checks and stages a plugin (see the file header). Returns the staging id and review.
@@ -112,7 +196,7 @@ export class PluginImport {
      * versioned and published by it (the version defaulting to `0.0.0-sha256.h<12>`, spec §5.3).
      */
     async prepare(actor, bytes, source, opts = {}) {
-        const maxBytes = this.d.config().packages.maxBytes;
+        const maxBytes = this.config.get().packages.maxBytes;
         const pkg = await readingPackage(() => readPluginPackage(bytes, {
             maxBytes,
             hostSdkVersion: SDK_VERSION,
@@ -143,7 +227,7 @@ export class PluginImport {
                     entryVersion: opts.fallback.entryVersion,
                 }),
                 ...(claude !== undefined && { overlay: claude }),
-                allowInsecureLoopback: this.d.config().marketplaces.allowInsecureLoopback,
+                allowInsecureLoopback: this.config.get().marketplaces.allowInsecureLoopback,
             }));
             const translated = await readingPackage(async () => readPluginFiles(t.tree, {
                 hostSdkVersion: SDK_VERSION,
@@ -194,7 +278,7 @@ export class PluginImport {
      * (required with an extension: it is stored in the package store); `size` is recorded.
      */
     async prepareContents(actor, pkg, tgz, source, opts) {
-        const maxBytes = this.d.config().packages.maxBytes;
+        const maxBytes = this.config.get().packages.maxBytes;
         // 1. Every check (nothing written)
         const m = pkg.manifest;
         const packageName = packageNameOf(pkg);
@@ -208,7 +292,7 @@ export class PluginImport {
             ? await readingPackage(() => readExtensionPackage(bytes, { maxBytes, hostSdkVersion: SDK_VERSION }))
             : undefined;
         const content = this.checkContent(pkg, format);
-        const { existing, version } = await precheckCatalogImport(this.d.db, m.name, {
+        const { existing, version } = await precheckCatalogImport(this.db, m.name, {
             packageName,
             version: m.version,
             contentDigest: pkg.contentDigest,
@@ -219,14 +303,14 @@ export class PluginImport {
         // The catalog name space is the extension name space: a declarative plugin cannot take a
         // config-declared or another package's extension name either
         this.assertNotDeclared(m.name);
-        await assertPluginNameOwner(this.d.db, m.name, packageName);
+        await assertPluginNameOwner(this.db, m.name, packageName);
         let extension;
         if (ext) {
             extension = await this.reviewExtension(ext, await this.extensionState(m.name, packageName));
-            await assertDowngradable(this.d.db, extension, ext.migrationSql);
+            await assertDowngradable(this.db, extension, ext.migrationSql);
         }
         if (content.files.length > 0)
-            this.d.storage.assertAvailable();
+            this.files.assertAvailable();
         const src = {
             kind: source.kind,
             ref: source.ref,
@@ -281,13 +365,13 @@ export class PluginImport {
         };
         review.reviewHash = pluginReviewHash(review, content.files);
         // Re-check under the lock that the actor is still an enterprise admin before writing
-        await this.d.db.transaction().execute((trx) => authorizeActor(trx, actor));
+        await this.authorize(actor);
         // 2. Write: the extension into the package store, files into object storage, the staging row
         const stagingId = randomUUID();
         const itemId = existing?.id ?? randomUUID();
         if (ext) {
             const bootstrap = src.kind === "bootstrap";
-            await this.d.installs.ingest(actor, bytes, bootstrap
+            await this.installs.ingest(actor, bytes, bootstrap
                 ? { source: "bootstrap", ref: src.ref }
                 : {
                     source: "catalog",
@@ -300,7 +384,7 @@ export class PluginImport {
         let objectPrefix = null;
         if (content.files.length > 0) {
             objectPrefix = catalogObjectPrefix(itemId, version, stagingId);
-            await putCatalogFiles(this.d.storage, objectPrefix, content.files);
+            await putCatalogFiles(this.files, objectPrefix, content.files);
         }
         const keys = ext
             ? permissionKeys(permissionSetOfPackage(ext))
@@ -322,46 +406,50 @@ export class PluginImport {
             ...(license.text !== undefined && { licenseText: license.text }),
             ...(license.truncated && { licenseTruncated: true }),
         };
-        await this.d.db.transaction().execute(async (trx) => {
-            await authorizeActor(trx, actor);
-            await trx
-                .insertInto("plugin_import_staging")
-                .values({
-                id: stagingId,
-                review: JSON.stringify(review),
-                manifest: JSON.stringify(staged),
-                object_prefix: objectPrefix,
-                source: JSON.stringify(src),
-                created_by: actor,
-                expires_at: new Date(Date.now() + PLUGIN_STAGING_TTL_MS),
-            })
-                .execute();
-            await audit(trx, {
-                ...(actor !== null && { actorAccountId: actor }),
-                ...(opts.actorTokenId !== undefined && { actorTokenId: opts.actorTokenId }),
-                action: "catalog.plugin_staged",
-                target: stagingId,
-                detail: {
-                    stagingId,
-                    name: m.name,
-                    version,
-                    source: src.kind,
-                    sourceRef: src.ref,
-                    ...(src.integrity !== undefined && { integrity: src.integrity }),
-                    ...(src.marketplaceId !== undefined && { marketplaceId: src.marketplaceId }),
-                    reviewHash: review.reviewHash,
-                    ...(extension && {
-                        extension: { sha256: extension.sha256, action: extension.action },
-                    }),
-                },
-            });
-        });
+        await this.writeStaging(actor, stagingId, review, staged, objectPrefix, src, opts);
         return { stagingId, review, permissionKeys: keys, permissionsMismatch: mismatch };
     }
+    /** The staging row and the `catalog.plugin_staged` audit, the actor re-checked under the lock. */
+    async writeStaging(actor, stagingId, review, staged, objectPrefix, src, opts) {
+        const { extension } = review;
+        const t = this.db;
+        await this.authorizeActor(actor);
+        await t
+            .insertInto("plugin_import_staging")
+            .values({
+            id: stagingId,
+            review: JSON.stringify(review),
+            manifest: JSON.stringify(staged),
+            object_prefix: objectPrefix,
+            source: JSON.stringify(src),
+            created_by: actor,
+            expires_at: new Date(Date.now() + PLUGIN_STAGING_TTL_MS),
+        })
+            .execute();
+        await audit(t, {
+            ...(actor !== null && { actorAccountId: actor }),
+            ...(opts.actorTokenId !== undefined && { actorTokenId: opts.actorTokenId }),
+            action: "catalog.plugin_staged",
+            target: stagingId,
+            detail: {
+                stagingId,
+                name: review.name,
+                version: staged.version,
+                source: src.kind,
+                sourceRef: src.ref,
+                ...(src.integrity !== undefined && { integrity: src.integrity }),
+                ...(src.marketplaceId !== undefined && { marketplaceId: src.marketplaceId }),
+                reviewHash: review.reviewHash,
+                ...(extension && {
+                    extension: { sha256: extension.sha256, action: extension.action },
+                }),
+            },
+        });
+    }
     /** Fetches a plugin from the configured npm registry (verified by `dist.integrity`), then prepares it. */
     async prepareNpm(actor, input, opts = {}) {
-        const got = await this.d.installs.fetchNpm(input);
-        const provenance = await this.d.installs.fetchProvenance({
+        const got = await this.installs.fetchNpm(input);
+        const provenance = await this.installs.fetchProvenance({
             package: input.package,
             version: got.version,
             integrity: got.integrity,
@@ -370,7 +458,7 @@ export class PluginImport {
             kind: "npm",
             ref: `${input.package}@${got.version}`,
             integrity: got.integrity,
-            detail: { registry: new URL(this.d.config().packages.npmRegistry).origin },
+            detail: { registry: new URL(this.config.get().packages.npmRegistry).origin },
         }, { ...opts, expect: { packageName: input.package }, provenance: { provenance } });
         return { stagingId: r.stagingId, review: r.review };
     }
@@ -382,7 +470,7 @@ export class PluginImport {
     async staged(stagingId) {
         if (!UUID_RE.test(stagingId))
             throw notFound();
-        const row = await this.d.db
+        const row = await this.db
             .selectFrom("plugin_import_staging")
             .select(["id", "review", "manifest"])
             .where("id", "=", stagingId)
@@ -404,7 +492,7 @@ export class PluginImport {
     async confirm(actor, stagingId, input, opts = {}) {
         if (!UUID_RE.test(stagingId))
             throw notFound();
-        const row = await this.d.db
+        const row = await this.db
             .selectFrom("plugin_import_staging")
             .selectAll()
             .where("id", "=", stagingId)
@@ -415,114 +503,125 @@ export class PluginImport {
         const review = row.review;
         const staged = row.manifest;
         const src = row.source;
-        const stale = () => new ApiError("plugin.review_stale", `The review of plugin ${review.name} ${review.version} is out of date (it changed, or its extension on this deployment changed since it was prepared); review it again`);
         if (input.reviewHash !== review.reviewHash)
-            throw stale();
+            throw reviewStale(review);
         const manifest = withPinned(staged.manifest, review, input.pinnedSuggestions);
         const reviewed = review.extension;
         // Read the stored package outside the transaction (unless it was already installed as is)
         const stored = reviewed && reviewed.action !== "keep" ? await this.readStored(reviewed.sha256) : undefined;
-        const committed = await this.d.db.transaction().execute(async (trx) => {
-            await authorizeActor(trx, actor);
-            const used = await trx
-                .deleteFrom("plugin_import_staging")
-                .where("id", "=", stagingId)
-                .where("expires_at", ">", sql `now()`)
-                .returning("id")
-                .executeTakeFirst();
-            if (!used)
-                throw notFound();
-            let now;
-            let previous;
-            if (reviewed) {
-                // The same per-name advisory lock as ExtensionAdminOps.install; under it the action is
-                // recomputed from the current deployment state (installed / upgraded / swapped since the
-                // review -> stale)
-                await sql `SELECT pg_advisory_xact_lock(hashtext(${`capybara.plugin-install:${reviewed.name}`}))`.execute(trx);
-                now = {
-                    ...reviewed,
-                    ...actionOf(await this.extensionState(reviewed.name, staged.packageName, trx), reviewed.sha256),
-                };
-                if (pluginReviewHash({ ...review, extension: now }, staged.files) !== review.reviewHash) {
-                    throw stale();
-                }
-                // A foreseeable deploy failure (a downgrade to a version with unrun migrations) is refused
-                // before anything is written
-                if (input.deployExtension && now.action === "upgrade" && stored) {
-                    await assertDowngradable(trx, now, stored.migrationSql);
-                }
-                if (now.action === "install" || (now.action === "upgrade" && input.deployExtension)) {
-                    previous = await this.approve(trx, actor, review, staged, now, stored, opts);
-                }
-            }
-            const m = manifest;
-            const itemId = await writeCatalogVersion(trx, {
-                actor,
-                ...(opts.actorTokenId !== undefined && { actorTokenId: opts.actorTokenId }),
-                name: m.name,
-                packageName: staged.packageName,
-                version: staged.version,
-                contentDigest: staged.contentDigest,
-                manifest: m,
-                listing: {
-                    publisher: m.publisher,
-                    description: m.description,
-                    displayName: m.displayName ?? null,
-                },
-                newItemId: staged.itemId,
-                source: {
-                    source: src.kind,
-                    ref: src.ref,
-                    ...(src.integrity !== undefined && { integrity: src.integrity }),
-                    ...(src.detail !== undefined && { detail: src.detail }),
-                },
-                ...(src.marketplaceId !== undefined && { marketplaceId: src.marketplaceId }),
-                objectPrefix: row.object_prefix,
-                extensionSha256: reviewed?.sha256 ?? null,
-                files: staged.files,
-                size: staged.size,
-                sourceFormat: staged.sourceFormat ?? "capybara",
-                translation: staged.translation ?? null,
-                licenseText: staged.licenseText ?? null,
-                licenseTruncated: staged.licenseTruncated === true,
-                auditDetail: {
-                    stagingId,
-                    deployExtension: input.deployExtension,
-                    suggestedPinned: pinnedNames(manifest, review),
-                    ...(now && { extension: { name: now.name, version: now.version, action: now.action } }),
-                },
-            });
-            return { itemId, now, previous };
-        });
+        const committed = await this.commit(actor, { stagingId, review, staged, src, manifest, objectPrefix: row.object_prefix }, input, stored, opts);
         const { now } = committed;
         const deploy = input.deployExtension && now && now.action !== "keep"
             ? await this.deploy(actor, review, committed.itemId, now, committed.previous, opts, input.enable ?? true)
             : null;
         return { item: await this.itemView(committed.itemId), deploy };
     }
+    /**
+     * The confirm's transaction: the staging row consumed, the extension's action recomputed under
+     * its install lock (stale -> `plugin.review_stale`), its snapshot approved, and the catalog
+     * version written under the item name's lock.
+     */
+    async commit(actor, c, input, stored, opts) {
+        const { stagingId, review, staged, src, manifest } = c;
+        const reviewed = review.extension;
+        const stale = () => reviewStale(review);
+        await this.authorizeActor(actor);
+        const t = this.db;
+        const used = await t
+            .deleteFrom("plugin_import_staging")
+            .where("id", "=", stagingId)
+            .where("expires_at", ">", sql `now()`)
+            .returning("id")
+            .executeTakeFirst();
+        if (!used)
+            throw notFound();
+        let now;
+        let previous;
+        if (reviewed) {
+            // The same per-name advisory lock as ExtensionAdminOps.install; under it the action is
+            // recomputed from the current deployment state (installed / upgraded / swapped since the
+            // review -> stale)
+            await this.installLock.lock(reviewed.name);
+            now = {
+                ...reviewed,
+                ...actionOf(await this.extensionState(reviewed.name, staged.packageName), reviewed.sha256),
+            };
+            if (pluginReviewHash({ ...review, extension: now }, staged.files) !== review.reviewHash) {
+                throw stale();
+            }
+            // A foreseeable deploy failure (a downgrade to a version with unrun migrations) is refused
+            // before anything is written
+            if (input.deployExtension && now.action === "upgrade" && stored) {
+                await assertDowngradable(t, now, stored.migrationSql);
+            }
+            if (now.action === "install" || (now.action === "upgrade" && input.deployExtension)) {
+                previous = await this.approve(actor, review, staged, now, stored, opts);
+            }
+        }
+        const m = manifest;
+        await this.itemLock.lock(m.name);
+        const itemId = await writeCatalogVersion(t, {
+            actor,
+            ...(opts.actorTokenId !== undefined && { actorTokenId: opts.actorTokenId }),
+            name: m.name,
+            packageName: staged.packageName,
+            version: staged.version,
+            contentDigest: staged.contentDigest,
+            manifest: m,
+            listing: {
+                publisher: m.publisher,
+                description: m.description,
+                displayName: m.displayName ?? null,
+            },
+            newItemId: staged.itemId,
+            source: {
+                source: src.kind,
+                ref: src.ref,
+                ...(src.integrity !== undefined && { integrity: src.integrity }),
+                ...(src.detail !== undefined && { detail: src.detail }),
+            },
+            ...(src.marketplaceId !== undefined && { marketplaceId: src.marketplaceId }),
+            objectPrefix: c.objectPrefix,
+            extensionSha256: reviewed?.sha256 ?? null,
+            files: staged.files,
+            size: staged.size,
+            sourceFormat: staged.sourceFormat ?? "capybara",
+            translation: staged.translation ?? null,
+            licenseText: staged.licenseText ?? null,
+            licenseTruncated: staged.licenseTruncated === true,
+            auditDetail: {
+                stagingId,
+                deployExtension: input.deployExtension,
+                suggestedPinned: pinnedNames(manifest, review),
+                ...(now && { extension: { name: now.name, version: now.version, action: now.action } }),
+            },
+        });
+        return { itemId, now, previous };
+    }
     /**
      * Writes the extension's permission snapshot for the version being imported (source web; cli
      * without an actor; bootstrap for the bootstrap step), after
      * registering the name owner like ExtensionAdminOps.install (Ruling P3). Returns the snapshot it
      * overwrote (null when there was none).
      */
-    async approve(trx, actor, review, staged, p, pkg, opts) {
+    async approve(actor, review, staged, p, pkg, opts) {
         const set = permissionSetOfPackage(pkg);
-        await sql `SELECT pg_advisory_xact_lock(hashtext(${`capybara.plugin-approve:${p.name}`}))`.execute(trx);
-        const snapRow = await trx
+        await this.approveLock.lock(p.name);
+        const t = this.db;
+        const snapRow = await t
             .selectFrom("extension_permission_snapshots")
             .selectAll()
             .where("plugin", "=", p.name)
             .forUpdate()
             .executeTakeFirst();
-        await trx
+        await t
             .insertInto("extension_name_owners")
             .values({ name: p.name, package_name: staged.packageName })
             .onConflict((oc) => oc.column("name").doNothing())
             .execute();
-        await assertPluginNameOwner(trx, p.name, staged.packageName);
+        await assertPluginNameOwner(t, p.name, staged.packageName);
         const { added, removed } = diffPermissions(snapRow?.permissions, set);
-        await writeSnapshot(trx, p.name, p.version, set, {
+        await writeSnapshot(t, p.name, p.version, set, {
             source: review.source.kind === "bootstrap" ? "bootstrap" : actor === null ? "cli" : "web",
             approvedBy: actor,
             ...(opts.actorTokenId !== undefined && { actorTokenId: opts.actorTokenId }),
@@ -561,12 +660,12 @@ export class PluginImport {
             ? { code: e.code, message: e.message }
             : { code: "internal", message: "Internal error" };
         try {
-            await this.d.ops.install(p.name, p.sha256, actor, opts.actorTokenId, {
+            await this.ops.install(p.name, p.sha256, actor, opts.actorTokenId, {
                 catalogItemId: itemId,
             });
         }
         catch (e) {
-            this.d.log.warn("installing a plugin's extension on the deployment failed", {
+            this.log.warn("installing a plugin's extension on the deployment failed", {
                 plugin: review.name,
                 err: e,
             });
@@ -579,7 +678,7 @@ export class PluginImport {
                     }
                 }
                 catch (err) {
-                    this.d.log.error("cannot restore the permission snapshot of a plugin's extension", {
+                    this.log.error("cannot restore the permission snapshot of a plugin's extension", {
                         plugin: p.name,
                         err,
                     });
@@ -590,11 +689,11 @@ export class PluginImport {
         if (!enable)
             return { ...base, result: "installed" };
         try {
-            await this.d.ops.enable(p.name, actor, opts.actorTokenId);
+            await this.ops.enable(p.name, actor, opts.actorTokenId);
             return { ...base, result: "enabled" };
         }
         catch (e) {
-            this.d.log.warn("enabling a plugin's extension failed", { plugin: p.name, err: e });
+            this.log.warn("enabling a plugin's extension failed", { plugin: p.name, err: e });
             return { ...base, result: "failed", ...failure(e) };
         }
     }
@@ -605,49 +704,45 @@ export class PluginImport {
      * approved or changed it meanwhile it is left alone and false is returned.
      */
     async restoreSnapshot(actor, review, p, prev, opts) {
-        return this.d.db.transaction().execute(async (trx) => {
-            await sql `SELECT pg_advisory_xact_lock(hashtext(${`capybara.plugin-approve:${p.name}`}))`.execute(trx);
-            const current = await trx
-                .selectFrom("extension_permission_snapshots")
-                .select(["version", "approved_by"])
+        const t = this.db;
+        await this.approveLock.lock(p.name);
+        const current = await t
+            .selectFrom("extension_permission_snapshots")
+            .select(["version", "approved_by"])
+            .where("plugin", "=", p.name)
+            .forUpdate()
+            .executeTakeFirst();
+        if (current?.version !== p.version || current.approved_by !== actor)
+            return false;
+        if (prev) {
+            await t
+                .updateTable("extension_permission_snapshots")
+                .set({
+                version: prev.version,
+                permissions: JSON.stringify(prev.permissions),
+                approved_by: prev.approvedBy,
+                approved_at: prev.approvedAt,
+                source: prev.source,
+            })
                 .where("plugin", "=", p.name)
-                .forUpdate()
-                .executeTakeFirst();
-            if (current?.version !== p.version || current.approved_by !== actor)
-                return false;
-            if (prev) {
-                await trx
-                    .updateTable("extension_permission_snapshots")
-                    .set({
-                    version: prev.version,
-                    permissions: JSON.stringify(prev.permissions),
-                    approved_by: prev.approvedBy,
-                    approved_at: prev.approvedAt,
-                    source: prev.source,
-                })
-                    .where("plugin", "=", p.name)
-                    .execute();
-            }
-            else {
-                await trx
-                    .deleteFrom("extension_permission_snapshots")
-                    .where("plugin", "=", p.name)
-                    .execute();
-            }
-            await audit(trx, {
-                ...(actor !== null && { actorAccountId: actor }),
-                ...(opts.actorTokenId !== undefined && { actorTokenId: opts.actorTokenId }),
-                action: "extension.permissions_restored",
-                target: p.name,
-                detail: {
-                    plugin: p.name,
-                    restoredVersion: prev?.version ?? null,
-                    reason: "plugin_deploy_failed",
-                    app: { name: review.name, version: review.version },
-                },
-            });
-            return true;
+                .execute();
+        }
+        else {
+            await t.deleteFrom("extension_permission_snapshots").where("plugin", "=", p.name).execute();
+        }
+        await audit(t, {
+            ...(actor !== null && { actorAccountId: actor }),
+            ...(opts.actorTokenId !== undefined && { actorTokenId: opts.actorTokenId }),
+            action: "extension.permissions_restored",
+            target: p.name,
+            detail: {
+                plugin: p.name,
+                restoredVersion: prev?.version ?? null,
+                reason: "plugin_deploy_failed",
+                app: { name: review.name, version: review.version },
+            },
         });
+        return true;
     }
     /**
      * Deletes expired staging rows and their object prefixes (maintenance job `app-staging-cleanup`).
@@ -657,7 +752,7 @@ export class PluginImport {
     async cleanupExpired() {
         let total = 0;
         for (;;) {
-            const batch = await this.d.db
+            const batch = await this.db
                 .selectFrom("plugin_import_staging")
                 .select(["id", "object_prefix"])
                 .where("expires_at", "<=", sql `now()`)
@@ -669,35 +764,41 @@ export class PluginImport {
             let progressed = 0;
             for (const r of batch) {
                 try {
-                    const done = await this.d.db.transaction().execute(async (trx) => {
-                        const locked = await trx
-                            .selectFrom("plugin_import_staging")
-                            .select("id")
-                            .where("id", "=", r.id)
-                            .where("expires_at", "<=", sql `now()`)
-                            .forUpdate()
-                            .skipLocked()
-                            .executeTakeFirst();
-                        if (!locked)
-                            return false;
-                        if (r.object_prefix)
-                            await this.d.storage.deployment().deletePrefix(r.object_prefix);
-                        await trx.deleteFrom("plugin_import_staging").where("id", "=", r.id).execute();
-                        return true;
-                    });
+                    const done = await this.cleanupOne(r);
                     if (done) {
                         total++;
                         progressed++;
                     }
                 }
                 catch (err) {
-                    this.d.log.warn("cannot clean up an expired plugin import", { stagingId: r.id, err });
+                    this.log.warn("cannot clean up an expired plugin import", { stagingId: r.id, err });
                 }
             }
             if (progressed === 0 || batch.length < CLEANUP_BATCH)
                 return total;
         }
     }
+    /**
+     * One expired staging row (row lock, `SKIP LOCKED`): its objects, then the row; false when another
+     * replica has it or it is gone.
+     */
+    async cleanupOne(r) {
+        const t = this.db;
+        const locked = await t
+            .selectFrom("plugin_import_staging")
+            .select("id")
+            .where("id", "=", r.id)
+            .where("expires_at", "<=", sql `now()`)
+            .forUpdate()
+            .skipLocked()
+            .executeTakeFirst();
+        if (!locked)
+            return false;
+        if (r.object_prefix)
+            await this.files.deployment().deletePrefix(r.object_prefix);
+        await t.deleteFrom("plugin_import_staging").where("id", "=", r.id).execute();
+        return true;
+    }
     // ---------------------------------------------------------------------------------------------
     /** npm / marketplace imports: the package must be the one that was asked for. */
     checkExpected(pkg, expect, format = "capybara") {
@@ -723,7 +824,7 @@ export class PluginImport {
     }
     /** A config-declared extension's name cannot be taken by an imported plugin. */
     assertNotDeclared(name) {
-        const declared = this.d.declared().get(name);
+        const declared = this.registry.declared().get(name);
         if (declared === "config") {
             throw new ApiError("extension.config_declared", `Extension ${name} is declared in the startup config (extensions); remove it there before importing a plugin with this name`);
         }
@@ -783,10 +884,10 @@ export class PluginImport {
             // The result depends on which connectors the replica serving this request has loaded right
             // now: it is the import-time gate, not the last word (an org install checks again against the
             // connector of the moment)
-            const loaded = this.d.findConnector(t.plugin, t.connector);
+            const loaded = findConnectorIn(this.registry, t.plugin, t.connector);
             if (loaded) {
                 problems.push(...templateProblems(loaded, t, at));
-                const v = this.d.pluginVersion?.(t.plugin);
+                const v = this.registry.manifests().find((x) => x.name === t.plugin)?.version;
                 if (t.pluginVersion !== undefined &&
                     v !== undefined &&
                     !satisfiesRange(v, t.pluginVersion)) {
@@ -794,7 +895,7 @@ export class PluginImport {
                 }
             }
             else if (local.has(t.plugin) ||
-                this.d.connectorsLoaded === false ||
+                !this.connectorsLoaded ||
                 (format === "claude-code" && t.plugin === CLAUDE_MCP_CONNECTOR.plugin)) {
                 // The connector comes with this plugin or a dependency (or this process loads no
                 // connectors, or a translated Claude template targets connector-mcp, which may not be
@@ -848,7 +949,7 @@ export class PluginImport {
         const deps = m.dependencies ?? [];
         if (deps.length === 0)
             return [];
-        const rows = await this.d.db
+        const rows = await this.db
             .selectFrom("catalog_items as i")
             .innerJoin("catalog_item_versions as v", "v.item_id", "i.id")
             .select(["i.name", "v.version", "v.imported_at"])
@@ -867,8 +968,8 @@ export class PluginImport {
      * The extension's state on the deployment; installed from another npm package ->
      * `extension.name_conflict`.
      */
-    async extensionState(name, packageName, db = this.d.db) {
-        const r = await db
+    async extensionState(name, packageName) {
+        const r = await this.db
             .selectFrom("extension_installs")
             .innerJoin("extension_packages", "extension_packages.sha256", "extension_installs.sha256")
             .select([
@@ -888,7 +989,7 @@ export class PluginImport {
     /** The review of the extension: permissions, the change against the snapshot, warnings, action. */
     async reviewExtension(pkg, state) {
         const name = pkg.section.name;
-        const snap = await this.d.db
+        const snap = await this.db
             .selectFrom("extension_permission_snapshots")
             .select("permissions")
             .where("plugin", "=", name)
@@ -912,26 +1013,64 @@ export class PluginImport {
         };
     }
     async readStored(sha256) {
-        const bytes = await this.d.blobs.get(sha256);
+        const bytes = await this.blobs.get(sha256);
         return readingPackage(() => readExtensionPackage(bytes, {
-            maxBytes: this.d.config().packages.maxBytes,
+            maxBytes: this.config.get().packages.maxBytes,
             hostSdkVersion: SDK_VERSION,
         }));
     }
     async itemView(itemId) {
-        const item = await this.d.db
+        const item = await this.db
             .selectFrom("catalog_items")
             .selectAll()
             .where("id", "=", itemId)
             .executeTakeFirstOrThrow();
-        const versions = await this.d.db
+        const versions = await this.db
             .selectFrom("catalog_item_versions")
             .select(["version", "source", "imported_at"])
             .where("item_id", "=", itemId)
             .execute();
         return itemView(item, versions);
     }
-}
+};
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], PluginImport.prototype, "authorizeActor", null);
+__decorate([
+    Transactional()
+], PluginImport.prototype, "authorize", null);
+__decorate([
+    Transactional()
+], PluginImport.prototype, "writeStaging", null);
+__decorate([
+    Transactional()
+], PluginImport.prototype, "commit", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], PluginImport.prototype, "approve", null);
+__decorate([
+    Transactional()
+], PluginImport.prototype, "restoreSnapshot", null);
+__decorate([
+    Transactional()
+], PluginImport.prototype, "cleanupOne", null);
+PluginImport = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(EnterpriseAdminLock)),
+    __param(2, Inject(PluginInstallLock)),
+    __param(3, Inject(PluginApproveLock)),
+    __param(4, Inject(CatalogItemLock)),
+    __param(5, Inject(KernelConfigService)),
+    __param(6, Inject(StorageService)),
+    __param(7, Inject(ExtensionInstalls)),
+    __param(8, Inject(ExtensionAdminOps)),
+    __param(9, Inject(ExtensionBlobs)),
+    __param(10, Inject(ExtensionRegistry)),
+    __param(11, Inject(KERNEL_LOGGER)),
+    __param(12, Inject(TransactionHost))
+], PluginImport);
+export { PluginImport };
 /**
  * plugin.json as stored on the version: skills and connector templates listed explicitly (what was
  * scanned when the manifest omitted them), `pinned` kept from the listing.