@x12i/memorix-service 3.2.1 → 3.3.0

package/dist/routes/metadata.js

@@ -1,9 +1,14 @@
 import { METADATA_KIND_IDS, METADATA_KIND_REGISTRY, validateMetadataPack, } from "@x12i/memorix-metadata";
 import { resolveScope } from "../request-scope.js";
+import { resolveEffectiveForListing } from "../effective-listing.js";
 import { ServiceError } from "../errors.js";
 import { listKnownPackIds, loadKnownMetadataPack } from "../known-packs.js";
 import { stripOrgRuntimeSourcesFromPack } from "../org-sources.js";
-import { PACKAGE_CATALOG_ORG, associationsFromPack, buildPackagePayload, catalogAgentId, discoverPackageCatalog, packageVersionMessage, parsePackageMessage, releaseAssociations, resolveOwnerAgent, } from "../magit/package-catalog-bridge.js";
+import { associationsFromPack, buildPackagePayload, catalogAgentId, discoverPackageCatalog, releaseAssociations, resolveOwnerAgent, } from "../magit/package-catalog-bridge.js";
+import { packagePayloadToPack } from "../magit/pack-to-patchset.js";
+import { createCatalogService } from "../catalog/catalog-service.js";
+import { collapseCatalogVersions, parsePackagesSource, selectPackagesBySource, } from "../catalog/package-list-source.js";
+import { isMagitCatalogKind } from "../catalog/types.js";
 function requireMagit(platform) {
     if (!platform.magit) {
         throw new ServiceError("MAGIT_UNAVAILABLE", "metadata versioning requires a durable Mongo connection (set METADATA_MAGIT=0 to disable)", 503);
@@ -144,7 +149,7 @@ export async function registerMetadataRoutes(app, platform) {
     });
     app.get("/api/metadata/effective", async (req) => {
         const scope = resolveScope(req);
-        const resolved = platform.metadata.resolveEffective(scope.agentIds);
+        const resolved = resolveEffectiveForListing((ids) => platform.metadata.resolveEffective(ids), scope.agentIds);
         return {
             scope,
             ok: resolved.ok,
@@ -156,12 +161,12 @@ export async function registerMetadataRoutes(app, platform) {
                 issues: resolved.issues ?? [],
                 referenceIssues: resolved.referenceIssues ?? [],
             },
-            note: "agentIds select effective metadata only; effective is the resolved definition array",
+            note: "agentIds select effective metadata only; Any/* fans out and unions when multi-agent joint resolve conflicts",
         };
     });
     app.get("/api/metadata/kinds", async (req) => {
         const scope = resolveScope(req);
-        const effective = platform.metadata.resolveEffective(scope.agentIds);
+        const effective = resolveEffectiveForListing((ids) => platform.metadata.resolveEffective(ids), scope.agentIds);
         const customDeclarations = (effective.effective ?? []).filter((e) => e.kind === "kind-declarations");
         return {
             scope,
@@ -184,7 +189,7 @@ export async function registerMetadataRoutes(app, platform) {
     app.get("/api/metadata/kinds/:kind", async (req) => {
         const scope = resolveScope(req);
         const { kind } = req.params;
-        const effective = platform.metadata.resolveEffective(scope.agentIds);
+        const effective = resolveEffectiveForListing((ids) => platform.metadata.resolveEffective(ids), scope.agentIds);
         const items = (effective.effective ?? []).filter((e) => e.kind === kind);
         return { scope, kind, items };
     });
@@ -596,8 +601,8 @@ export async function registerMetadataRoutes(app, platform) {
         return { scope, definition: def };
     });
     // ---------------------------------------------------------------------------
-    // Package catalog (Magit 2.9+ packages/ — Pack / list / fetch; Restore → install)
-    // Spec: .operational/magit-central-package-storage-FR.md
+    // Central package catalog (org-free Pack/List/Fetch; org required
+    // only on Restore as the install target)
     // ---------------------------------------------------------------------------
     function installedPacks() {
         return platform.metadata.exportMetadata().packs;
@@ -608,95 +613,52 @@ export async function registerMetadataRoutes(app, platform) {
             return k;
         throw new ServiceError("VALIDATION", "kind must be agent | connector | service", 400);
     }
-    /** Optional Magit actor from request headers (audit; not ownership ACL until Magit G1). */
-    function actorFromRequest(req) {
-        const h = req.headers;
-        const pick = (name) => {
-            const v = h[name] ?? h[name.toLowerCase()];
-            if (Array.isArray(v))
-                return v[0]?.trim() || undefined;
-            return typeof v === "string" && v.trim() ? v.trim() : undefined;
-        };
-        const subject = pick("x-memorix-actor") ??
-            pick("x-actor-id") ??
-            pick("x-authix-subject");
-        return subject ? { subject } : undefined;
-    }
-    /**
-     * Magit published catalog and/or packable live installs.
-     * Query: source=catalog|packable|all (default all); optional kind filter.
-     * packages = Magit published (distinct kind+id, latest version row as summary).
-     * packable = installed live (for Publish-from-this-env).
-     * No publisher "ours only" filter until Magit G1–G3 ship.
-     */
+    // Local packable by default. source=catalog proxies Magit inventory collapse;
+    // source=all returns both planes. Global product inventory is GET /api/catalog.
     app.get("/api/metadata/packages", async (req) => {
         const magit = requireMagit(platform);
         const q = req.query;
         const kindFilter = q.kind?.trim() && q.kind.trim() !== "all"
             ? parseKind(q.kind)
             : undefined;
-        const sourceRaw = (q.source?.trim() || "all").toLowerCase();
-        const source = sourceRaw === "catalog" || sourceRaw === "packable" || sourceRaw === "all"
-            ? sourceRaw
-            : (() => {
-                throw new ServiceError("VALIDATION", "source must be catalog | packable | all", 400);
-            })();
-        const wantCatalog = source === "catalog" || source === "all";
-        const wantPackable = source === "packable" || source === "all";
-        let packages = [];
-        let remote = magit.hasRemoteCatalog();
-        if (wantCatalog) {
-            const listed = await magit.listCatalogPackages({
+        const source = parsePackagesSource(q.source);
+        const packable = discoverPackageCatalog(installedPacks()).filter((e) => kindFilter ? e.kind === kindFilter : true);
+        let catalogRows = [];
+        if (source === "catalog" || source === "all") {
+            const catalog = createCatalogService({
+                magit,
+                metadata: platform.metadata,
+                connectorRegistry: platform.connectorRegistry,
+                genericConnectors: platform.genericConnectors,
+            });
+            const versions = await catalog.listMagitVersionRows({
                 kind: kindFilter,
-                maxCount: 500,
             });
-            remote = listed.remote || remote;
-            // Collapse versions → one catalog entry per kind+id (latest createdAt wins).
-            const byKey = new Map();
-            for (const v of listed.items) {
-                if (kindFilter && v.kind !== kindFilter)
-                    continue;
-                const key = `${v.kind}::${v.id}`;
-                const prev = byKey.get(key);
-                if (prev?.createdAt && prev.createdAt >= v.createdAt)
-                    continue;
-                byKey.set(key, {
-                    kind: v.kind,
-                    id: v.id,
-                    // Owner agent is live concern; catalog packages are org-free.
-                    agentId: v.kind === "agent" ? v.id : "",
-                    label: v.kind === "agent"
-                        ? v.id
-                        : `${v.kind}:${v.id}${v.version ? ` @ ${v.version.slice(0, 12)}` : ""}`,
-                    version: v.version,
-                    checksum: v.checksum,
-                    createdAt: v.createdAt,
-                    mode: v.mode,
-                    associations: v.associations,
-                });
-            }
-            packages = [...byKey.values()].sort((a, b) => a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id));
-        }
-        const packable = wantPackable
-            ? discoverPackageCatalog(installedPacks()).filter((e) => kindFilter ? e.kind === kindFilter : true)
-            : [];
-        // Backward-compat: when clients only read `packages`, prefer catalog when requested.
-        // For source=packable only, packages[] mirrors packable so older clients still work.
-        if (source === "packable") {
-            packages = packable.map((e) => ({
-                kind: e.kind,
-                id: e.id,
-                agentId: e.agentId,
-                label: e.label,
+            catalogRows = versions
+                .filter((v) => isMagitCatalogKind(v.kind))
+                .map((v) => ({
+                kind: v.kind,
+                id: v.id,
+                version: v.version,
+                createdAt: v.createdAt,
+                checksum: v.checksum,
             }));
         }
-        return {
-            packages,
+        const selected = selectPackagesBySource({
+            source,
+            packages: collapseCatalogVersions(catalogRows),
             packable,
+        });
+        const note = source === "packable"
+            ? "Package identities discoverable from packs installed in this environment."
+            : source === "catalog"
+                ? "Collapsed Magit catalog identities (latest version per kind+id). Prefer GET /api/catalog for product inventory."
+                : "packages=Magit catalog (collapsed); packable=installed pack identities.";
+        return {
+            packages: selected.packages,
+            ...(source === "all" ? { packable: selected.packable } : {}),
             source,
-            remote,
-            catalogOrg: PACKAGE_CATALOG_ORG,
-            note: "packages = Magit published catalog; packable = live installs for Publish. Publisher-scoped catalog awaits Magit G1–G3 (.operational/magit-package-ownership-catalog-FR.md).",
+            note,
         };
     });
     app.get("/api/metadata/packages/:kind/:id/associations", async (req) => {
@@ -719,6 +681,8 @@ export async function registerMetadataRoutes(app, platform) {
             associations: associationsFromPack(pack),
         };
     });
+    // FR-CPS-3/5 — flat catalog listing. Org-free: kind + id only, no agentId
+    // resolution needed (a catalog package isn't owned by any installed pack).
     app.get("/api/metadata/packages/:kind/:id/versions", async (req) => {
         const magit = requireMagit(platform);
         const kind = parseKind(req.params.kind);
@@ -726,44 +690,42 @@ export async function registerMetadataRoutes(app, platform) {
         if (!id)
             throw new ServiceError("VALIDATION", "id required", 400);
         const q = req.query;
-        const packs = installedPacks();
-        let ownerAgentId;
-        try {
-            ownerAgentId = resolveOwnerAgent(packs, kind, id, q.agentId);
-        }
-        catch {
-            ownerAgentId = kind === "agent" ? id : q.agentId?.trim() || "";
-        }
         const maxCount = q.maxCount ? Number(q.maxCount) : 50;
-        const listed = await magit.listCatalogPackages({
+        const versions = await magit.listPackages({
             kind,
             id,
             maxCount: Number.isFinite(maxCount) ? maxCount : 50,
         });
-        const versions = listed.items.map((v) => {
-            const parsed = parsePackageMessage(v.message);
-            return {
-                commit: v.version,
-                agentId: ownerAgentId || id,
-                checksum: v.checksum,
-                message: v.message,
-                createdAt: v.createdAt,
-                source: "save-version",
-                packageKind: (parsed.kind ?? v.kind),
-                packageId: parsed.id ?? v.id,
-                mode: parsed.mode ?? v.mode,
-                displayMessage: parsed.message || v.message,
-                associations: v.associations,
-            };
-        });
         return {
             kind,
             id,
-            agentId: ownerAgentId || id,
-            versions,
-            remote: listed.remote || magit.hasRemoteCatalog(),
-            catalogOrg: PACKAGE_CATALOG_ORG,
-            note: "Versions from Magit package catalog (packages/). Org is not package identity.",
+            // `commit` aliases `version` for existing HTTP callers written against
+            // the pre-cutover org-scoped history shape (e.g. Studio's
+            // PackVersionsPage.tsx keys/renders list rows by `.commit`). `version`
+            // is the FR-CPS-4/5 field name and the one new callers should use.
+            versions: versions.map((v) => ({ ...v, commit: v.version })),
+            note: "Versions from the central Magit package catalog.",
+        };
+    });
+    // FR-CPS-5 — fetch a package version's payload directly (§7 of the FR).
+    // Org header is ignored: catalog reads are org-free.
+    app.get("/api/metadata/packages/:kind/:id/versions/:version", async (req) => {
+        const magit = requireMagit(platform);
+        const kind = parseKind(req.params.kind);
+        const id = String(req.params.id ?? "").trim();
+        if (!id)
+            throw new ServiceError("VALIDATION", "id required", 400);
+        const version = String(req.params.version ?? "").trim();
+        if (!version)
+            throw new ServiceError("VALIDATION", "version required", 400);
+        const fetched = await magit.fetchPackage({ kind, id, version });
+        return {
+            kind,
+            id,
+            version,
+            checksum: fetched.checksum,
+            payload: fetched.payload,
+            associations: fetched.associations,
         };
     });
     app.post("/api/metadata/packages/pack", async (req) => {
@@ -788,11 +750,7 @@ export async function registerMetadataRoutes(app, platform) {
         if (!live) {
             throw new ServiceError("NOT_FOUND", `No installed pack for agent ${agentId}`, 404);
         }
-        const mode = kind === "agent"
-            ? body.mode === "narrow"
-                ? "narrow"
-                : "full"
-            : "narrow";
+        const mode = kind === "agent" ? (body.mode === "narrow" ? "narrow" : "full") : undefined;
         const payload = buildPackagePayload(live, {
             kind,
             id,
@@ -807,74 +765,51 @@ export async function registerMetadataRoutes(app, platform) {
         const associations = kind === "agent" && mode
             ? releaseAssociations(live, mode, body.includeConnectorIds, body.includeServiceIds)
             : undefined;
-        // Full agent pack: publish pin packages first, then agent with Magit pins.
-        const actor = actorFromRequest(req);
-        const pins = [];
+        const saved = await magit.packPackage({
+            kind,
+            id,
+            message,
+            pack: payload,
+            mode,
+            associations,
+        });
+        // Full agent pack also snapshots selected connector/service packages.
+        // `commit` aliases `version` for the same backward-compat reason as the
+        // versions-list route above.
         const bundled = [];
         if (kind === "agent" && mode === "full" && associations) {
             for (const connectorId of associations.connectorIds) {
-                const slice = buildPackagePayload(live, {
-                    kind: "connector",
-                    id: connectorId,
-                });
+                const slice = buildPackagePayload(live, { kind: "connector", id: connectorId });
                 const ok = validateMetadataPack(slice);
                 if (!ok.ok)
                     continue;
-                const b = await magit.packCatalogPackage({
+                const b = await magit.packPackage({
                     kind: "connector",
                     id: connectorId,
-                    message: packageVersionMessage("connector", connectorId, `bundled with agent ${id}: ${message}`),
+                    message: `bundled with agent ${id}: ${message}`,
                     pack: slice,
-                    mode: "narrow",
-                    actor,
-                });
-                pins.push({
-                    kind: "connector",
-                    id: connectorId,
-                    version: b.version,
-                });
-                bundled.push({
-                    kind: "connector",
-                    id: connectorId,
-                    commit: b.version,
-                    version: b.version,
                 });
+                bundled.push({ kind: "connector", id: connectorId, version: b.version, commit: b.version });
             }
             for (const serviceId of associations.serviceIds) {
-                const slice = buildPackagePayload(live, {
-                    kind: "service",
-                    id: serviceId,
-                });
+                const slice = buildPackagePayload(live, { kind: "service", id: serviceId });
                 const ok = validateMetadataPack(slice);
                 if (!ok.ok)
                     continue;
-                const b = await magit.packCatalogPackage({
+                const b = await magit.packPackage({
                     kind: "service",
                     id: serviceId,
-                    message: packageVersionMessage("service", serviceId, `bundled with agent ${id}: ${message}`),
+                    message: `bundled with agent ${id}: ${message}`,
                     pack: slice,
-                    mode: "narrow",
-                    actor,
-                });
-                pins.push({ kind: "service", id: serviceId, version: b.version });
-                bundled.push({
-                    kind: "service",
-                    id: serviceId,
-                    commit: b.version,
-                    version: b.version,
                 });
+                bundled.push({ kind: "service", id: serviceId, version: b.version, commit: b.version });
             }
         }
-        const saved = await magit.packCatalogPackage({
-            kind,
-            id,
-            message: packageVersionMessage(kind, id, message, mode),
-            pack: payload,
-            mode: kind === "agent" ? mode : "narrow",
-            associations,
-            pins: pins.length ? pins : undefined,
-            actor,
-        });
+        const note = saved.published === false
+            ? "Pack wrote locally but was not published to the central store (published=false)."
+            : saved.published === true
+                ? "Pack published to the Magit typed package store."
+                : "Pack stored in the central Magit package catalog.";
         return {
             packed: true,
             kind,
@@ -883,13 +818,13 @@ export async function registerMetadataRoutes(app, platform) {
             mode: mode ?? null,
             associations,
             bundled,
-            commit: saved.version,
             version: saved.version,
             checksum: saved.checksum,
             reused: saved.reused,
-            remote: saved.remote || magit.hasRemoteCatalog(),
-            catalogOrg: PACKAGE_CATALOG_ORG,
-            note: "Packed into Magit package catalog (not live).",
+            ...(saved.published !== undefined ? { published: saved.published } : {}),
+            ...(saved.storeId ? { storeId: saved.storeId } : {}),
+            ...(saved.packageTypeId ? { packageTypeId: saved.packageTypeId } : {}),
+            note,
         };
     });
     app.post("/api/metadata/packages/restore", async (req) => {
@@ -921,13 +856,14 @@ export async function registerMetadataRoutes(app, platform) {
             throw new ServiceError("VALIDATION", "agentId required to restore connector/service into an agent pack", 400);
         }
         const sliceAgentId = catalogAgentId(kind, id, agentId);
-        const loaded = await magit.fetchCatalogPackage({ kind, id, version }, sliceAgentId);
-        let installPack = loaded.pack;
+        const fetched = await magit.fetchPackage({ kind, id, version });
+        const loadedPack = packagePayloadToPack(sliceAgentId, fetched.payload);
+        let installPack = loadedPack;
         // Connector/service restore merges slice into current live agent pack.
         if (kind === "connector" || kind === "service") {
             const live = packs[agentId] ?? emptyPackForRestore(agentId);
             if (kind === "connector") {
-                const keepRefs = new Set((loaded.pack.sources ?? [])
+                const keepRefs = new Set((loadedPack.sources ?? [])
                     .map((s) => s && typeof s === "object" && "connectorRef" in s
                     ? String(s.connectorRef ?? "")
                     : "")
@@ -941,19 +877,16 @@ export async function registerMetadataRoutes(app, platform) {
                 installPack = {
                     ...live,
                     agentId,
-                    sources: [...otherSources, ...(loaded.pack.sources ?? [])],
+                    sources: [...otherSources, ...(loadedPack.sources ?? [])],
                 };
             }
             else {
                 const svcId = id;
-                const otherServices = (live.services ?? []).filter((s) => !(s &&
-                    typeof s === "object" &&
-                    "id" in s &&
-                    String(s.id) === svcId));
+                const otherServices = (live.services ?? []).filter((s) => !(s && typeof s === "object" && "id" in s && String(s.id) === svcId));
                 installPack = {
                     ...live,
                     agentId,
-                    services: [...otherServices, ...(loaded.pack.services ?? [])],
+                    services: [...otherServices, ...(loadedPack.services ?? [])],
                 };
             }
         }
@@ -981,12 +914,10 @@ export async function registerMetadataRoutes(app, platform) {
             id,
             agentId,
             version,
+            checksum: fetched.checksum,
             targetOrgId: scope.orgId,
-            checksum: loaded.checksum,
             result,
-            remote: loaded.remote || magit.hasRemoteCatalog(),
-            catalogOrg: PACKAGE_CATALOG_ORG,
-            note: "Restored from Magit package catalog into this environment. Org is restore target only.",
+            note: "Restored from the central Magit package catalog into this environment. Org is the restore target only.",
         };
     });
     app.post("/api/metadata/packages/diff", async (req) => {
@@ -1010,12 +941,31 @@ export async function registerMetadataRoutes(app, platform) {
             agentId = kind === "agent" ? id : body.agentId?.trim() || id;
         }
         const sliceAgentId = catalogAgentId(kind, id, agentId);
-        // version↔version: Magit catalog commits; installed vs version uses catalog org Mongo lens.
+        // "installed" sentinel → live / installed pack slice for typed-store compare.
+        // Flat Mode B still maps installed → "live" commit/mongo side via MagitPackService.
         const fromRef = from === "installed" ? "live" : from;
         const toRef = to === "installed" ? "live" : to;
-        const diff = await magit.diff(PACKAGE_CATALOG_ORG, sliceAgentId, {
+        const needsInstalled = fromRef === "live" ||
+            toRef === "live" ||
+            from === "installed" ||
+            to === "installed";
+        let installedPack = null;
+        if (needsInstalled) {
+            const live = packs[agentId];
+            if (live) {
+                installedPack = buildPackagePayload(live, {
+                    kind,
+                    id,
+                    mode: kind === "agent" ? "narrow" : undefined,
+                });
+            }
+        }
+        const diff = await magit.diffPackages(sliceAgentId, {
             from: fromRef,
             to: toRef,
+            kind,
+            id,
+            installedPack,
         });
         return {
             ...diff,
@@ -1023,7 +973,6 @@ export async function registerMetadataRoutes(app, platform) {
             id,
             agentId,
             catalogAgentId: sliceAgentId,
-            remote: magit.hasRemoteCatalog(),
             note: "Compare package versions or version vs installed. Not env→env copy.",
         };
     });