@x12i/memorix-service 3.3.0 → 3.6.0

package/dist/magit/magit-pack-service.js

@@ -137,20 +137,26 @@ export function resolveMagitRepoRootParent() {
  * Central Magit package-catalog tenant (FR-CPS-1). This is a fixed
  * developer/solution scope for Memorix's own package storage — it must NEVER
  * be a runtime `orgId`. Org only appears as a Restore install target, never as
- * the catalog key. Default `"memorix"`.
+ * the catalog key. Default `"x12i"` (dedicated Memorix catalog workspace).
  */
 export function resolveMagitCatalogTenant() {
-    return process.env.MAGIT_CATALOG_TENANT?.trim() || "memorix";
+    return process.env.MAGIT_CATALOG_TENANT?.trim() || "x12i";
 }
 /**
  * Magit storage repo id for the central package catalog (FR-CPS). Defaults to
- * `memorix-metadata-_package-catalog`. Override with MAGIT_CATALOG_REPO when the
- * Authix token only grants a specific repo (e.g. `demo`).
+ * `memorix` (dedicated catalog repo). Override with MAGIT_CATALOG_REPO only when
+ * targeting a non-standard host layout.
  */
 export function resolveMagitCatalogRepoName() {
-    return (process.env.MAGIT_CATALOG_REPO?.trim() ||
-        `memorix-metadata-${PACKAGE_CATALOG_LOCAL_DIR}`);
+    return process.env.MAGIT_CATALOG_REPO?.trim() || "memorix";
 }
+/** Write-once on createGlobalStore — kinds omitted can only be fixed with a second store. */
+export const DEFAULT_TYPED_STORE_ALLOWED_KINDS = [
+    "agent",
+    "connector",
+    "service",
+    "agent-bundle",
+];
 /**
  * Env var *name* Magit uses to load the central-storage bearer token.
  * Priority: MAGIT_STORAGE_TOKEN_ENV (explicit name) → AUTHIX_TOKEN if set → MAGIT_TOKEN.
@@ -1127,14 +1133,18 @@ export class MagitPackService {
      * Provision a typed global package store (create + pushStore + verify).
      * Returns the selector EXACTLY ONCE — caller must write it to a secret store.
      * Duplicate packageTypeId stores abort unless force=true.
+     * allowedKinds is write-once on the Magit store — decide the list before create.
      */
     async provisionTypedPackageStore(opts) {
         const packageTypeId = opts?.packageTypeId?.trim() ||
             process.env.MAGIT_PACKAGE_TYPE_ID?.trim() ||
             "memorix.packages.v1";
         const allowedKinds = opts?.allowedKinds && opts.allowedKinds.length > 0
-            ? opts.allowedKinds
-            : ["agent", "connector", "service", "agent-bundle"];
+            ? opts.allowedKinds.map((k) => k.trim()).filter(Boolean)
+            : [...DEFAULT_TYPED_STORE_ALLOWED_KINDS];
+        if (allowedKinds.length === 0) {
+            throw new ServiceError("VALIDATION", "allowedKinds must list at least one package kind (write-once on create)", 400);
+        }
         try {
             const repo = await this.ensureCatalogRepo();
             const existing = await repo.listStores();
@@ -1157,6 +1167,7 @@ export class MagitPackService {
                 storeId: created.storeId,
                 storeSelector: created.storeSelector,
                 packageTypeId: created.packageTypeId,
+                allowedKinds: [...allowedKinds],
                 pushed: {
                     uploaded: pushed.uploaded ?? 0,
                     skipped: pushed.skipped ?? 0,
@@ -1172,6 +1183,388 @@ export class MagitPackService {
             });
         }
     }
+    /** Mode A required: package / release channels live on the typed store only. */
+    requireTypedStoreConfig() {
+        const store = resolveMagitTypedStoreConfig();
+        if (!store) {
+            throw new ServiceError("VALIDATION", "Package channels and release sets require Mode A (MAGIT_PACKAGE_STORE_SELECTOR + MAGIT_PACKAGE_TYPE_ID)", 400);
+        }
+        return store;
+    }
+    /**
+     * Promote a package channel pointer (Mode A). Packages never move — only the pointer.
+     */
+    async setPackageChannel(opts) {
+        const store = this.requireTypedStoreConfig();
+        const kind = String(opts.kind ?? "").trim();
+        const id = String(opts.id ?? "").trim();
+        const channel = String(opts.channel ?? "").trim();
+        const version = String(opts.version ?? "").trim();
+        if (!kind || !id || !channel || !version) {
+            throw new ServiceError("VALIDATION", "kind, id, channel, and version are required", 400);
+        }
+        try {
+            const repo = await this.ensureCatalogRepo();
+            const result = await repo.setPackageChannel({
+                storeSelector: store.storeSelector,
+                packageTypeId: store.packageTypeId,
+                kind,
+                id,
+                channel,
+                version,
+                message: opts.message?.trim() || undefined,
+                expectedVersion: opts.expectedVersion,
+                publisher: store.publisher,
+            });
+            this.catalogHealth = { reachable: true, reason: null };
+            return {
+                storeId: result.storeId,
+                kind: result.kind,
+                id: result.id,
+                channel: result.channel,
+                version: result.version,
+                previousVersion: result.previousVersion,
+                seq: result.seq,
+                movedAt: result.movedAt,
+                message: result.message,
+                unchanged: result.unchanged,
+            };
+        }
+        catch (err) {
+            if (err instanceof ServiceError)
+                throw err;
+            throw this.mapError(err, "failed to promote package channel", {
+                catalog: true,
+            });
+        }
+    }
+    /** Resolve where a package channel points (Mode A; Magit pulls first by default). */
+    async resolvePackageChannel(opts) {
+        const store = this.requireTypedStoreConfig();
+        const kind = String(opts.kind ?? "").trim();
+        const id = String(opts.id ?? "").trim();
+        const channel = String(opts.channel ?? "").trim();
+        if (!kind || !id || !channel) {
+            throw new ServiceError("VALIDATION", "kind, id, and channel are required", 400);
+        }
+        try {
+            const repo = await this.ensureCatalogRepo();
+            const result = await repo.resolvePackageChannel({
+                storeSelector: store.storeSelector,
+                packageTypeId: store.packageTypeId,
+                kind,
+                id,
+                channel,
+                sync: opts.sync,
+            });
+            this.catalogHealth = { reachable: true, reason: null };
+            return {
+                storeId: result.storeId,
+                kind: result.kind,
+                id: result.id,
+                channel: result.channel,
+                version: result.version,
+                seq: result.seq,
+                movedAt: result.movedAt,
+                message: result.message,
+            };
+        }
+        catch (err) {
+            if (err instanceof ServiceError)
+                throw err;
+            throw this.mapError(err, "failed to resolve package channel", {
+                catalog: true,
+            });
+        }
+    }
+    /** Cut an immutable release set (content-addressed members). Mode A only. */
+    async packRelease(opts) {
+        const store = this.requireTypedStoreConfig();
+        const members = (opts.members ?? [])
+            .map((m) => ({
+            kind: String(m.kind ?? "").trim(),
+            id: String(m.id ?? "").trim(),
+            version: String(m.version ?? "").trim(),
+        }))
+            .filter((m) => m.kind && m.id && m.version);
+        if (members.length === 0) {
+            throw new ServiceError("VALIDATION", "members must list at least one { kind, id, version }", 400);
+        }
+        try {
+            const repo = await this.ensureCatalogRepo();
+            const result = await repo.packRelease({
+                storeSelector: store.storeSelector,
+                packageTypeId: store.packageTypeId,
+                members,
+                message: opts.message?.trim() || undefined,
+                publisher: store.publisher,
+            });
+            this.catalogHealth = { reachable: true, reason: null };
+            return {
+                releaseId: result.release.releaseId,
+                storeId: result.release.storeId,
+                members: result.release.members.map((m) => ({
+                    kind: m.kind,
+                    id: m.id,
+                    version: m.version,
+                })),
+                reused: result.reused,
+                published: result.published,
+                message: result.release.message,
+                createdAt: result.release.createdAt,
+            };
+        }
+        catch (err) {
+            if (err instanceof ServiceError)
+                throw err;
+            throw this.mapError(err, "failed to pack release set", { catalog: true });
+        }
+    }
+    /** Point a release channel at a releaseId (atomic promote of a set). Mode A. */
+    async setReleaseChannel(opts) {
+        const store = this.requireTypedStoreConfig();
+        const channel = String(opts.channel ?? "").trim();
+        const releaseId = String(opts.releaseId ?? "").trim();
+        if (!channel || !releaseId) {
+            throw new ServiceError("VALIDATION", "channel and releaseId are required", 400);
+        }
+        try {
+            const repo = await this.ensureCatalogRepo();
+            const result = await repo.setReleaseChannel({
+                storeSelector: store.storeSelector,
+                packageTypeId: store.packageTypeId,
+                channel,
+                releaseId,
+                message: opts.message?.trim() || undefined,
+                expectedReleaseId: opts.expectedReleaseId,
+                publisher: store.publisher,
+            });
+            this.catalogHealth = { reachable: true, reason: null };
+            return {
+                storeId: result.storeId,
+                channel: result.channel,
+                releaseId: result.releaseId,
+                previousReleaseId: result.previousReleaseId,
+                seq: result.seq,
+                movedAt: result.movedAt,
+                message: result.message,
+                unchanged: result.unchanged,
+            };
+        }
+        catch (err) {
+            if (err instanceof ServiceError)
+                throw err;
+            throw this.mapError(err, "failed to promote release channel", {
+                catalog: true,
+            });
+        }
+    }
+    /** Resolve a release channel with full member set (Magit pulls first). Mode A. */
+    async resolveReleaseChannel(opts) {
+        const store = this.requireTypedStoreConfig();
+        const channel = String(opts.channel ?? "").trim();
+        if (!channel) {
+            throw new ServiceError("VALIDATION", "channel is required", 400);
+        }
+        try {
+            const repo = await this.ensureCatalogRepo();
+            const result = await repo.resolveReleaseChannel({
+                storeSelector: store.storeSelector,
+                packageTypeId: store.packageTypeId,
+                channel,
+                sync: opts.sync,
+            });
+            this.catalogHealth = { reachable: true, reason: null };
+            return {
+                storeId: result.storeId,
+                channel: result.channel,
+                releaseId: result.releaseId,
+                seq: result.seq,
+                movedAt: result.movedAt,
+                message: result.message,
+                release: {
+                    releaseId: result.release.releaseId,
+                    members: result.release.members.map((m) => ({
+                        kind: m.kind,
+                        id: m.id,
+                        version: m.version,
+                    })),
+                    message: result.release.message,
+                    createdAt: result.release.createdAt,
+                },
+            };
+        }
+        catch (err) {
+            if (err instanceof ServiceError)
+                throw err;
+            throw this.mapError(err, "failed to resolve release channel", {
+                catalog: true,
+            });
+        }
+    }
+    /** Rollback list for a release channel (Mode A). */
+    async releaseChannelHistory(opts) {
+        const store = this.requireTypedStoreConfig();
+        const channel = String(opts.channel ?? "").trim();
+        if (!channel) {
+            throw new ServiceError("VALIDATION", "channel is required", 400);
+        }
+        try {
+            const repo = await this.ensureCatalogRepo();
+            const rows = await repo.releaseChannelHistory({
+                storeSelector: store.storeSelector,
+                packageTypeId: store.packageTypeId,
+                channel,
+                sync: opts.sync,
+            });
+            this.catalogHealth = { reachable: true, reason: null };
+            return rows.map((r) => ({
+                channel: r.channel,
+                seq: r.seq,
+                releaseId: r.releaseId,
+                previousReleaseId: r.previousReleaseId,
+                movedAt: r.movedAt,
+                message: r.message,
+            }));
+        }
+        catch (err) {
+            if (err instanceof ServiceError)
+                throw err;
+            throw this.mapError(err, "failed to list release channel history", {
+                catalog: true,
+            });
+        }
+    }
+    /**
+     * List package channel heads (Mode A). Optionally filter by kind/id/channel.
+     * Magit pulls first unless sync:false.
+     */
+    async listPackageChannels(opts = {}) {
+        const store = this.requireTypedStoreConfig();
+        try {
+            const repo = await this.ensureCatalogRepo();
+            const rows = await repo.listPackageChannels({
+                storeSelector: store.storeSelector,
+                packageTypeId: store.packageTypeId,
+                kind: opts.kind?.trim() || undefined,
+                id: opts.id?.trim() || undefined,
+                channel: opts.channel?.trim() || undefined,
+                sync: opts.sync,
+            });
+            this.catalogHealth = { reachable: true, reason: null };
+            return rows.map((r) => ({
+                storeId: r.storeId,
+                kind: r.kind,
+                id: r.id,
+                channel: r.channel,
+                version: r.version,
+                seq: r.seq,
+                movedAt: r.movedAt,
+                message: r.message,
+            }));
+        }
+        catch (err) {
+            if (err instanceof ServiceError)
+                throw err;
+            throw this.mapError(err, "failed to list package channels", {
+                catalog: true,
+            });
+        }
+    }
+    /** Every promotion ever made on a package channel (Mode A). */
+    async packageChannelHistory(opts) {
+        const store = this.requireTypedStoreConfig();
+        const kind = String(opts.kind ?? "").trim();
+        const id = String(opts.id ?? "").trim();
+        const channel = String(opts.channel ?? "").trim();
+        if (!kind || !id || !channel) {
+            throw new ServiceError("VALIDATION", "kind, id, and channel are required", 400);
+        }
+        try {
+            const repo = await this.ensureCatalogRepo();
+            const rows = await repo.packageChannelHistory({
+                storeSelector: store.storeSelector,
+                packageTypeId: store.packageTypeId,
+                kind,
+                id,
+                channel,
+                sync: opts.sync,
+            });
+            this.catalogHealth = { reachable: true, reason: null };
+            return rows.map((r) => ({
+                kind: r.kind,
+                id: r.id,
+                channel: r.channel,
+                version: r.version,
+                previousVersion: r.previousVersion,
+                seq: r.seq,
+                movedAt: r.movedAt,
+                message: r.message,
+            }));
+        }
+        catch (err) {
+            if (err instanceof ServiceError)
+                throw err;
+            throw this.mapError(err, "failed to list package channel history", {
+                catalog: true,
+            });
+        }
+    }
+    /** List all release channel heads in the store (Mode A). */
+    async listReleaseChannels(opts = {}) {
+        const store = this.requireTypedStoreConfig();
+        try {
+            const repo = await this.ensureCatalogRepo();
+            const rows = await repo.listReleaseChannels({
+                storeSelector: store.storeSelector,
+                packageTypeId: store.packageTypeId,
+                sync: opts.sync,
+            });
+            this.catalogHealth = { reachable: true, reason: null };
+            return rows.map((r) => ({
+                storeId: r.storeId,
+                channel: r.channel,
+                releaseId: r.releaseId,
+                seq: r.seq,
+                movedAt: r.movedAt,
+                message: r.message,
+                release: {
+                    releaseId: r.release.releaseId,
+                    members: r.release.members.map((m) => ({
+                        kind: m.kind,
+                        id: m.id,
+                        version: m.version,
+                    })),
+                    message: r.release.message,
+                    createdAt: r.release.createdAt,
+                },
+            }));
+        }
+        catch (err) {
+            if (err instanceof ServiceError)
+                throw err;
+            throw this.mapError(err, "failed to list release channels", {
+                catalog: true,
+            });
+        }
+    }
+    /**
+     * Safe catalog capability flags for Studio (never include selector/token).
+     */
+    packageCatalogCapabilities() {
+        const store = resolveMagitTypedStoreConfig();
+        const typed = Boolean(store);
+        return {
+            magitOn: true,
+            typedStoreConfigured: typed,
+            packageTypeId: store?.packageTypeId ?? null,
+            canBrowse: true,
+            canPublish: true,
+            canPromote: typed,
+            canUseChannels: typed,
+            canUseReleases: typed,
+        };
+    }
     /**
      * Verify configured catalog reachability (typed store via pullStore, or flat pull).
      * Never prints selector/token values.