@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.10

package/dist/catalog/catalog-items.js

@@ -0,0 +1,676 @@
+import { pluginDescription } from "@capybara-hq/plugin-sdk";
+import { sql } from "kysely";
+import semver from "semver";
+import { ApiError } from "../errors.js";
+import { enabledExtensionsByOrg } from "../extensions/enabled.js";
+import { blockingKeys } from "../extensions/permission-set.js";
+import { audit } from "../identity/audit.js";
+import { endpointCredentialIssues } from "../tools/endpoint.js";
+import { gitLocationIdentity } from "./git-source.js";
+import { entryCompatible, entryContentChanged, entryDeprecated, sourceEffective, unimportable, } from "./marketplaces.service.js";
+import { ownerOf, ownersOf, PLATFORM_OWNER, packageOwner, pendingDigest, } from "./ownership.js";
+import { schemaHasPath } from "./schema-path.js";
+import { compareVersions, newestFirst, sameRelease, withBuild } from "./versions.js";
+/**
+ * The object storage prefix of one import (relative to `deployment/`):
+ * `directory/<itemId>/<version>/<importId>/`. Each import gets a new `importId`, so the losing one of
+ * two concurrent imports of the same version never overwrites the committed version's files; reads
+ * always go through the `object_prefix` stored on the version row. Build metadata's `+` is written
+ * as `_` (a `+` in a key can turn into a space through URL query encoding).
+ */
+export const catalogObjectPrefix = (itemId, version, importId) => `directory/${itemId}/${version.replace(/\+/g, "_")}/${importId}/`;
+const PUT_CONCURRENCY = 8;
+/**
+ * Checks a connector template against the loaded connector `c` (problem paths start with `at`): the
+ * endpoint matches its `endpointSchema` and carries no credential-like headers / query / URL user
+ * info (the same rule as connector installs); every `editableEndpoint` path exists in the endpoint
+ * schema.
+ */
+export function templateProblems(c, t, at) {
+    const problems = [];
+    const r = c.endpointSchema.safeParse(t.endpoint);
+    if (!r.success) {
+        for (const i of r.error.issues) {
+            problems.push(`${[`${at}.endpoint`, ...i.path.map(String)].join(".")}: ${i.message}`);
+        }
+    }
+    else {
+        for (const leak of endpointCredentialIssues(r.data)) {
+            problems.push(`${at}.${leak.path}: ${leak.message}`);
+        }
+    }
+    for (const p of t.editableEndpoint ?? []) {
+        if (!schemaHasPath(c.endpointSchema, p.split("."))) {
+            problems.push(`${at}.editableEndpoint "${p}" is not a field of the ${t.connector} connector's endpoint`);
+        }
+    }
+    return problems;
+}
+/** Writes the files to `deployment/<prefix><path>` ({@link PUT_CONCURRENCY} at a time). */
+export async function putCatalogFiles(storage, prefix, files) {
+    const store = storage.deployment();
+    const queue = [...files];
+    await Promise.all(Array.from({ length: Math.min(PUT_CONCURRENCY, queue.length) }, async () => {
+        for (let f = queue.shift(); f; f = queue.shift()) {
+            await store.put(`${prefix}${f.path}`, f.data, {
+                contentType: "application/octet-stream",
+                size: f.size,
+            });
+        }
+    }));
+}
+/** Compares the marketplace's permission summary with the computed keys ({@link PermissionsMismatch}). */
+export function permissionsMismatch(declared, actual) {
+    if (declared === undefined || actual === undefined)
+        return null;
+    const want = new Set(declared);
+    const have = new Set(actual);
+    const missing = [...have].filter((k) => !want.has(k)).sort();
+    const extra = [...want].filter((k) => !have.has(k)).sort();
+    return missing.length > 0 || extra.length > 0 ? { missing, extra } : null;
+}
+/**
+ * The live item of a name, with the source identity of its latest version
+ * ({@link sourceIdentity}; null when there is none).
+ */
+async function liveItem(db, name) {
+    const item = await db
+        .selectFrom("catalog_items")
+        .select(["id", "package_name", "latest_version", "marketplace_id"])
+        .where("name", "=", name)
+        .where("deleted_at", "is", null)
+        .executeTakeFirst();
+    if (!item)
+        return undefined;
+    const latest = await db
+        .selectFrom("catalog_item_versions")
+        .select("source_detail")
+        .where("item_id", "=", item.id)
+        .where("version", "=", item.latest_version)
+        .executeTakeFirst();
+    return {
+        ...item,
+        source: sourceIdentity(latest?.source_detail ?? undefined, item.marketplace_id ?? undefined),
+    };
+}
+/**
+ * The identity of a git source, `<host>/<repo>:<path>` (host lower case, no `.git`), or null when
+ * the source is not git. An item without package.json is identified by it instead of a package name.
+ */
+export function gitIdentity(detail) {
+    if (detail === undefined || !("commit" in detail))
+        return null;
+    return gitLocationIdentity(detail);
+}
+/**
+ * What identifies the source of a plugin without package.json: `git <host>/<repo>:<path>`, or, for
+ * a marketplace archive (a skills-only tgz without plugin.json), `marketplace <id>` (the
+ * marketplace vouches for its entries; archive URLs change from version to version). null for
+ * anything else.
+ */
+function sourceIdentity(detail, marketplaceId) {
+    const git = gitIdentity(detail);
+    if (git !== null)
+        return `git ${git}`;
+    if (detail !== undefined && "url" in detail && marketplaceId !== undefined) {
+        return `marketplace ${marketplaceId}`;
+    }
+    return null;
+}
+/** The versions of an item, with what tells their content apart. */
+async function itemVersions(db, itemId) {
+    return db
+        .selectFrom("catalog_item_versions")
+        .select(["version", "content_digest", "integrity"])
+        .where("item_id", "=", itemId)
+        .execute();
+}
+/**
+ * An org's own version imported but not applied (pre-flight F4, ruling P3-12): the live item named
+ * `name` owned by `ownerOrgId` (same package) has a version of the release of `p.version` with the
+ * same content digest and no extension, other than the platform's version. Uploading it again
+ * retries its update instead of `catalog.version_exists`. undefined otherwise.
+ */
+export async function unappliedOwnVersion(db, name, ownerOrgId, p) {
+    const item = await db
+        .selectFrom("catalog_items")
+        .select(["id", "package_name", "platform_synced_version"])
+        .where("name", "=", name)
+        .where("deleted_at", "is", null)
+        .where("owner_org_id", "=", ownerOrgId)
+        .executeTakeFirst();
+    if (!item || item.package_name !== p.packageName)
+        return undefined;
+    const rows = await db
+        .selectFrom("catalog_item_versions")
+        .select(["version", "content_digest", "extension_sha256"])
+        .where("item_id", "=", item.id)
+        .where("content_digest", "=", p.contentDigest)
+        .execute();
+    const same = rows.find((v) => sameRelease(v.version, p.version) &&
+        v.extension_sha256 === null &&
+        v.version !== item.platform_synced_version);
+    return same && { itemId: item.id, version: same.version };
+}
+/** `atConfirm`: found under the lock at confirm (another import committed after the review). */
+const versionExists = (version, sameContent, atConfirm = false) => new ApiError("catalog.version_exists", (sameContent
+    ? `Version ${version} of this catalog item is already imported with the same content`
+    : `Version ${version} of this catalog item has already been imported`) +
+    (atConfirm
+        ? " (by another import since this one was prepared); prepare the import again"
+        : ""));
+/**
+ * No version of the release of `p.version` (equal but for build metadata) holds the same content
+ * (digest; for a version without one, the same integrity), else `catalog.version_exists`.
+ */
+function assertNewContent(existing, p, atConfirm = false) {
+    const same = existing.find((v) => sameRelease(v.version, p.version) &&
+        (v.content_digest !== null
+            ? v.content_digest === p.contentDigest
+            : v.integrity !== null && v.integrity === p.integrity));
+    if (same)
+        throw versionExists(same.version, true, atConfirm);
+}
+/**
+ * The version a new import records (Decision 6, spec §5.3): the plugin's own version, unless that
+ * release is already imported. A version of the same release (equal but for build metadata) with
+ * the same content (digest; for versions without one, the same integrity) -> `catalog.version_exists`
+ * "already imported"; other content -> `<version>+git.<sha12>` (git) or `+sha256.<12>` (any other
+ * source, the digest's first 12 hex), never overwriting the imported version. A git commit already
+ * recorded with other content (a Claude Code plugin whose marketplace entry changed while its own
+ * commit did not, see `claudeContentDigest`) falls back to `+sha256.<12>`.
+ */
+export function recordedVersion(existing, p) {
+    assertNewContent(existing, p);
+    if (!existing.some((v) => v.version === p.version))
+        return p.version;
+    const d = p.detail;
+    const byDigest = withBuild(p.version, `sha256.${p.contentDigest.slice(0, 12)}`);
+    let next = d !== undefined && "commit" in d
+        ? withBuild(p.version, `git.${d.commit.slice(0, 12)}`)
+        : byDigest;
+    if (existing.some((v) => v.version === next))
+        next = byDigest;
+    if (existing.some((v) => v.version === next))
+        throw versionExists(next, false);
+    return next;
+}
+/**
+ * Conflict precheck before writing (no lock; {@link writeCatalogVersion}'s re-check inside the
+ * transaction is final): an item with the same name from another npm package (or, without one,
+ * another git source) -> `catalog.name_conflict`; the release already imported with the same
+ * content -> `catalog.version_exists`. Returns the existing item (undefined when there is none) and
+ * the version to record ({@link recordedVersion}).
+ */
+export async function precheckCatalogImport(db, name, p) {
+    const existing = await liveItem(db, name);
+    if (!existing)
+        return { existing, version: p.version };
+    assertSameSource(existing, p.packageName, sourceIdentity(p.detail, p.marketplaceId));
+    return { existing, version: recordedVersion(await itemVersions(db, existing.id), p) };
+}
+/**
+ * Writes a catalog version in the caller's transaction (`db` is its handle; the caller has
+ * re-checked the super admin and holds the name's {@link CatalogItemLock}): checks conflicts again (the same source; no version of
+ * the release with the same content; `version` not taken meanwhile), creates the item when there is
+ * none or adds the version (latest and display fields change only for a newer version, a version
+ * equal but for build metadata being newer as the later import), and writes the version row (with
+ * its content digest) and the `catalog.imported` audit. Returns the item id.
+ */
+export async function writeCatalogVersion(db, w) {
+    const t = db;
+    const { name, version, listing } = w;
+    const live = await liveItem(t, name);
+    let id;
+    const created = live === undefined;
+    if (live) {
+        id = live.id;
+        assertSameSource(live, w.packageName, sourceIdentity(w.source.detail, w.marketplaceId));
+        const existing = await itemVersions(t, id);
+        // the same content under any version of the release, then the recorded version itself
+        assertNewContent(existing, {
+            version,
+            contentDigest: w.contentDigest,
+            ...(w.source.integrity !== undefined && { integrity: w.source.integrity }),
+        }, true);
+        if (existing.some((v) => v.version === version))
+            throw versionExists(version, false, true);
+        const newer = w.keepLatest !== true && compareVersions(version, live.latest_version) >= 0;
+        await t
+            .updateTable("catalog_items")
+            .set({
+            updated_at: sql `now()`,
+            ...(w.marketplaceId !== undefined && { marketplace_id: w.marketplaceId }),
+            ...(newer && {
+                latest_version: version,
+                publisher: listing.publisher,
+                description: listing.description,
+                display_name: listing.displayName ? JSON.stringify(listing.displayName) : null,
+            }),
+        })
+            .where("id", "=", id)
+            .execute();
+    }
+    else {
+        id = w.newItemId;
+        await t
+            .insertInto("catalog_items")
+            .values({
+            id,
+            name,
+            package_name: w.packageName,
+            publisher: listing.publisher,
+            description: listing.description,
+            display_name: listing.displayName ? JSON.stringify(listing.displayName) : null,
+            latest_version: version,
+            created_by: w.actor,
+            marketplace_id: w.marketplaceId ?? null,
+        })
+            .execute();
+    }
+    await t
+        .insertInto("catalog_item_versions")
+        .values({
+        item_id: id,
+        version,
+        manifest: JSON.stringify(w.manifest),
+        source: w.source.source,
+        source_ref: w.source.ref,
+        integrity: w.source.integrity ?? null,
+        source_detail: w.source.detail !== undefined ? JSON.stringify(w.source.detail) : null,
+        content_digest: w.contentDigest,
+        object_prefix: w.objectPrefix,
+        extension_sha256: w.extensionSha256,
+        files: JSON.stringify(w.files.map(({ path, size, sha256 }) => ({ path, size, sha256 }))),
+        size: w.size,
+        imported_by: w.actor,
+        source_format: w.sourceFormat ?? "capybara",
+        translation: w.translation != null ? JSON.stringify(w.translation) : null,
+        license_text: w.licenseText ?? null,
+        license_truncated: w.licenseTruncated === true,
+        // an org's version is usable only once applied or confirmed (ruling P3-52)
+        ...(w.keepLatest === true && { applied_at: null }),
+    })
+        .execute();
+    await audit(t, {
+        ...(w.actor !== null && { actorAccountId: w.actor }),
+        ...(w.actorTokenId !== undefined && { actorTokenId: w.actorTokenId }),
+        action: "catalog.imported",
+        target: id,
+        detail: {
+            name,
+            version,
+            source: w.source.source,
+            sourceRef: w.source.ref,
+            contentDigest: w.contentDigest,
+            ...(w.extensionSha256 !== null && { sha256: w.extensionSha256 }),
+            ...(w.source.integrity !== undefined && { integrity: w.source.integrity }),
+            ...(w.marketplaceId !== undefined && { marketplaceId: w.marketplaceId }),
+            ...w.auditDetail,
+        },
+    });
+    return { id, created };
+}
+/**
+ * Records that `version` of the item was applied or confirmed (ruling P3-52), in the caller's
+ * transaction: from then on it may serve other orgs and the generic update. Idempotent.
+ */
+export async function markVersionApplied(db, itemId, version) {
+    await db
+        .updateTable("catalog_item_versions")
+        .set({ applied_at: sql `now()` })
+        .where("item_id", "=", itemId)
+        .where("version", "=", version)
+        .where("applied_at", "is", null)
+        .execute();
+}
+/**
+ * Whether a version may serve other orgs, dependency resolution and the generic update (ruling
+ * P3-52): applied or confirmed, and never rejected, whoever owns the item now.
+ */
+export function versionUsable(v) {
+    return v.applied_at !== null && v.rejected_at === null;
+}
+/**
+ * An extension name belongs to the npm package that first installed it (`extension_name_owners`,
+ * Ruling P3): when another package owns it, the import is refused right away with
+ * `extension.name_conflict` (the same code as at install, details `[{ owner }]`: the owner of the
+ * package holding it), instead of failing only at deploy time.
+ */
+export async function assertPluginNameOwner(db, name, packageName) {
+    const owner = await db
+        .selectFrom("extension_name_owners")
+        .select("package_name")
+        .where("name", "=", name)
+        .executeTakeFirst();
+    if (owner && owner.package_name !== packageName) {
+        throw new ApiError("extension.name_conflict", `Extension name ${name} belongs to package ${owner.package_name}; ${packageLabel(packageName)} cannot use it`, 
+        // who holds it (package -> item -> owner, ruling P3-14)
+        [{ owner: await packageOwner(db, owner.package_name, name) }]);
+    }
+}
+/** "package <name>", or what a plugin without package.json is called in messages. */
+const packageLabel = (p) => p === null ? "a plugin without package.json" : `package ${p}`;
+/**
+ * Whether a plugin may add a version to an existing item: the same npm package, or, for an item
+ * without package.json, the same source ({@link sourceIdentity}: git host, repo and path, so
+ * unrelated repos that resolve to the same name never merge; or the same marketplace for an
+ * archive); never a mix of the two.
+ */
+function assertSameSource(item, packageName, source) {
+    const from = (p, src) => p !== null ? `package ${p}` : (src ?? "a plugin without package.json");
+    const same = item.package_name !== null
+        ? item.package_name === packageName
+        : packageName === null && item.source !== null && item.source === source;
+    if (!same) {
+        throw new ApiError("catalog.name_conflict", `A catalog item with this name comes from ${from(item.package_name, item.source)}; ${from(packageName, source)} cannot add versions to it`);
+    }
+}
+/**
+ * For each marketplace-imported item, its marketplace (when enabled): the version to update to
+ * (the highest compatible, importable, non-deprecated stable version listed, a prerelease only
+ * when no such stable version exists, as the market rows fold them), and whether a compatible,
+ * non-deprecated entry's content changed at an imported version.
+ */
+export async function marketplaceLatest(db, config, items, versions) {
+    const out = new Map();
+    const sourced = items.filter((i) => typeof i.marketplace_id === "string");
+    if (sourced.length === 0)
+        return out;
+    const rows = await db
+        .selectFrom("marketplace_entries as e")
+        .innerJoin("marketplaces as s", "s.id", "e.source_id")
+        .select([
+        "e.source_id",
+        "e.name",
+        "e.version",
+        "e.entry",
+        "e.head_commit",
+        "e.tree_oid",
+        "s.builtin",
+        "s.enabled",
+        "s.url",
+        "s.form",
+        "s.last_commit",
+    ])
+        .where("e.source_id", "in", [...new Set(sourced.map((i) => i.marketplace_id))])
+        .where("e.name", "in", [...new Set(sourced.map((i) => i.name))])
+        .execute();
+    for (const i of sourced) {
+        const listed = rows.filter((r) => r.source_id === i.marketplace_id &&
+            r.name === i.name &&
+            sourceEffective(r, config) &&
+            entryCompatible(r.entry) &&
+            // a deprecated version is never the one to update to, nor content to import again
+            !entryDeprecated(r.entry));
+        // As the market rows fold them: the newest importable stable version, a prerelease only when
+        // no stable one can be imported
+        const importable = listed
+            .filter((r) => r.version !== "" &&
+            unimportable(r.entry, r.form, config) === undefined)
+            .map((r) => r.version)
+            .sort(newestFirst);
+        const best = importable.find((v) => semver.prerelease(v) === null) ?? importable[0];
+        const recorded = versions.get(i.id) ?? [];
+        out.set(i.id, {
+            latest: best ?? null,
+            contentChanged: listed.some((r) => entryContentChanged(r.entry, {
+                marketplaceId: r.source_id,
+                headCommit: r.head_commit,
+                treeOid: r.tree_oid,
+                url: r.url,
+                lastCommit: r.last_commit,
+            }, recorded)),
+        });
+    }
+    return out;
+}
+/** Org install counts per item (see {@link CatalogItemView.installs}). */
+export async function countInstalls(db, items, versions) {
+    const orgs = new Map(items.map((i) => [i.id, new Set()]));
+    const installed = await db
+        .selectFrom("plugin_installs")
+        .select(["item_id", "org_id"])
+        .where("item_id", "in", items.map((i) => i.id))
+        .where("status", "in", ["installed", "upgrading"])
+        .execute();
+    for (const r of installed)
+        orgs.get(r.item_id)?.add(r.org_id);
+    const withExtension = items.filter((i) => (versions.get(i.id) ?? []).find((v) => v.version === i.latest_version)?.extension_sha256 !=
+        null);
+    if (withExtension.length > 0) {
+        const enabled = await db
+            .selectFrom(enabledExtensionsByOrg(db).as("en"))
+            .select(["en.plugin", "en.org_id"])
+            .where("en.plugin", "in", withExtension.map((p) => p.name))
+            .execute();
+        for (const i of withExtension) {
+            for (const r of enabled)
+                if (r.plugin === i.name)
+                    orgs.get(i.id)?.add(r.org_id);
+        }
+    }
+    return new Map([...orgs].map(([id, set]) => [id, set.size]));
+}
+/**
+ * Every id is a live org (`validation_failed` naming the unknown ones otherwise): the orgs of a
+ * `named` scope.
+ */
+export async function assertOrgsExist(db, orgs) {
+    if (orgs.length === 0)
+        return;
+    const found = await db
+        .selectFrom("orgs")
+        .select("id")
+        .where("id", "in", [...orgs])
+        .where("deleted_at", "is", null)
+        .execute();
+    const known = new Set(found.map((o) => o.id));
+    const unknown = orgs.filter((o) => !known.has(o));
+    if (unknown.length > 0) {
+        throw new ApiError("validation_failed", `orgs: unknown organizations ${unknown.join(", ")}`, [
+            { path: "orgs", message: `unknown organizations: ${unknown.join(", ")}` },
+        ]);
+    }
+}
+/** The facts of a view that shows none of the scope facts, only the item's owner. */
+export function ownerOnlyFacts(owner) {
+    return {
+        scopeOrgs: [],
+        enabledOrgs: 0,
+        offCount: 0,
+        pending: false,
+        permissionsHash: null,
+        owner,
+    };
+}
+const NO_FACTS = ownerOnlyFacts(PLATFORM_OWNER);
+/**
+ * Per item id: is its extension waiting for a person's confirmation (pending) and the permission
+ * digest to confirm. Pending when the extension is not installed on the deployment, when the
+ * installed version's permission set is not covered by the stored snapshot, or (a builtin item)
+ * when the snapshot is the bootstrap step's, never confirmed by a person. Items whose latest
+ * version has no extension are never pending.
+ */
+export async function itemConfirmations(admin, items, versions) {
+    const out = new Map();
+    // An org-owned item waits only while an upload of it does (rulings P3-9, P3-10): the digest of
+    // that version's package (P3-11); nothing else of an org's item is the super admin's to confirm
+    for (const i of items) {
+        if (i.owner_org_id === null)
+            continue;
+        const sha = i.pending_version === null
+            ? null
+            : ((versions.get(i.id) ?? []).find((v) => v.version === i.pending_version)
+                ?.extension_sha256 ?? null);
+        if (sha === null) {
+            out.set(i.id, { pending: false, permissionsHash: null });
+            continue;
+        }
+        const hash = await admin.packageReviewHash(sha);
+        out.set(i.id, {
+            pending: true,
+            permissionsHash: hash === null ? null : pendingDigest(sha, hash),
+        });
+    }
+    const withExtension = items.flatMap((i) => {
+        if (i.owner_org_id !== null)
+            return [];
+        const sha = (versions.get(i.id) ?? []).find((v) => v.version === i.latest_version)?.extension_sha256 ??
+            null;
+        return sha === null ? [] : [{ item: i, sha }];
+    });
+    if (withExtension.length === 0)
+        return out;
+    // only these items' extensions: reading every installed package would also log each one that
+    // cannot be read right now (the bootstrap step confirms before the object store is loaded)
+    const names = new Set(withExtension.map((w) => w.item.name));
+    const installed = new Map((await admin.list(names)).map((v) => [v.name, v]));
+    for (const { item, sha } of withExtension) {
+        const v = installed.get(item.name);
+        if (!v) {
+            out.set(item.id, { pending: true, permissionsHash: await admin.packageReviewHash(sha) });
+            continue;
+        }
+        const pending = v.snapshot === null ||
+            blockingKeys(v.added).length > 0 ||
+            (item.builtin && v.snapshot.source === "bootstrap");
+        out.set(item.id, {
+            pending,
+            permissionsHash: pending && v.error === undefined ? v.reviewHash : null,
+        });
+    }
+    return out;
+}
+const LIVE_INSTALL = ["installing", "installed", "upgrading"];
+/**
+ * Per item: the orgs of its `named` list, the orgs it is on in (a live plugin install; every org for
+ * a builtin item) and whether it is pending (`confirmations`, see {@link itemConfirmations}).
+ */
+export async function itemScopeFacts(db, items, confirmations) {
+    const owners = await ownersOf(db, items.flatMap((i) => (i.owner_org_id === null ? [] : [i.owner_org_id])));
+    const out = new Map(items.map((i) => [
+        i.id,
+        {
+            scopeOrgs: [],
+            enabledOrgs: 0,
+            offCount: 0,
+            pending: confirmations.get(i.id)?.pending ?? false,
+            permissionsHash: confirmations.get(i.id)?.permissionsHash ?? null,
+            owner: ownerOf(i.owner_org_id, owners),
+        },
+    ]));
+    if (items.length === 0)
+        return out;
+    const ids = items.map((i) => i.id);
+    // one after the other: `db` may be a transaction's single connection
+    const listed = await db
+        .selectFrom("catalog_item_scope_orgs")
+        .select(["item_id", "org_id"])
+        .where("item_id", "in", ids)
+        .orderBy("org_id")
+        .execute();
+    for (const r of listed)
+        out.get(r.item_id)?.scopeOrgs.push(r.org_id);
+    const live = await db
+        .selectFrom("plugin_installs as a")
+        .innerJoin("orgs as o", "o.id", "a.org_id")
+        .select(["a.item_id", (eb) => eb.fn.count("a.org_id").distinct().as("n")])
+        .where("a.item_id", "in", ids)
+        .where("a.status", "in", [...LIVE_INSTALL])
+        .where("o.deleted_at", "is", null)
+        .groupBy("a.item_id")
+        .execute();
+    for (const r of live) {
+        const f = out.get(r.item_id);
+        if (f)
+            f.enabledOrgs = Number(r.n);
+    }
+    // the orgs that switched an `all` item off (layering spec §4): one grouped count for the page
+    const everywhere = items.filter((i) => i.scope === "all" && !i.builtin).map((i) => i.id);
+    if (everywhere.length > 0) {
+        const off = await db
+            .selectFrom("catalog_item_org_switches as s")
+            .innerJoin("orgs as o", "o.id", "s.org_id")
+            .select(["s.item_id", (eb) => eb.fn.countAll().as("n")])
+            .where("s.item_id", "in", everywhere)
+            .where("s.enabled", "=", false)
+            .where("o.deleted_at", "is", null)
+            .groupBy("s.item_id")
+            .execute();
+        for (const r of off) {
+            const f = out.get(r.item_id);
+            if (f)
+                f.offCount = Number(r.n);
+        }
+    }
+    if (items.some((i) => i.builtin)) {
+        const orgs = await db
+            .selectFrom("orgs")
+            .select((eb) => eb.fn.countAll().as("n"))
+            .where("deleted_at", "is", null)
+            .executeTakeFirstOrThrow();
+        for (const i of items) {
+            const f = out.get(i.id);
+            if (i.builtin && f)
+                f.enabledOrgs = Number(orgs.n);
+        }
+    }
+    return out;
+}
+/** The `zh` text of a stored manifest's description; null without one (or an unreadable manifest). */
+function descriptionZhOf(manifest) {
+    const d = manifest?.description;
+    if (typeof d !== "object" || d === null)
+        return null;
+    const zh = pluginDescription(d).zh;
+    return typeof zh === "string" ? zh : null;
+}
+export function itemView(i, versions, installs = 0, marketplace = { latest: null, contentChanged: false }, facts = NO_FACTS) {
+    const sorted = [...versions].sort((a, b) => newestFirst({ version: a.version, importedAt: a.imported_at ?? null }, { version: b.version, importedAt: b.imported_at ?? null }));
+    const top = sorted[0]?.version ?? i.latest_version;
+    const latestMarketplaceVersion = marketplace.latest;
+    const current = versions.find((v) => v.version === i.latest_version);
+    return {
+        id: i.id,
+        name: i.name,
+        publisher: i.publisher,
+        displayName: i.display_name,
+        description: i.description,
+        descriptionZh: descriptionZhOf(current?.manifest),
+        policy: i.policy,
+        scope: i.builtin ? "all" : i.scope,
+        scopeOrgs: [...facts.scopeOrgs],
+        builtin: i.builtin,
+        disabled: i.disabled,
+        shownToOthers: i.shown_to_others,
+        owner: facts.owner,
+        shareable: i.shareable,
+        awaitingConfirmation: i.awaiting_confirmation,
+        pendingVersion: i.pending_version,
+        enabledOrgs: facts.enabledOrgs,
+        offCount: facts.offCount,
+        pending: facts.pending,
+        permissionsHash: facts.permissionsHash,
+        latestVersion: i.latest_version,
+        versions: sorted.map((v) => v.version),
+        installs,
+        source: current?.source ?? "file",
+        marketplaceId: i.marketplace_id ?? null,
+        latestMarketplaceVersion,
+        newerInMarketplace: latestMarketplaceVersion !== null && compareVersions(latestMarketplaceVersion, top) > 0,
+        contentChanged: marketplace.contentChanged,
+        componentCounts: componentCountsOf(current?.manifest),
+        sourceFormat: current?.source_format ?? "capybara",
+        updatedAt: i.updated_at.toISOString(),
+    };
+}
+/** The components a version's plugin.json brings, by kind (none without a manifest). */
+export function componentCountsOf(m) {
+    return {
+        extension: m?.extension === undefined ? 0 : 1,
+        skills: m?.skills?.length ?? 0,
+        connectorTemplates: m?.connectorTemplates?.length ?? 0,
+        agentTemplates: m?.agents?.length ?? 0,
+    };
+}