@x12i/memorix-service 3.0.5 → 3.1.0

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

@@ -0,0 +1,699 @@
+/**
+ * MagitPackService — server-only façade over @x12i/magit for pack versioning.
+ * Phase 0–5: ensureRepo, saveVersion, history, diff, packAtCommit, publish, proposals.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { MongoClient } from "mongodb";
+import { magit, listProposalLedgerEntries, isPatchsetError, createProgressReporter, labelDiff, } from "@x12i/magit";
+import { checksumMetadataPack } from "@x12i/memorix-metadata-runtime";
+import { ServiceError } from "../errors.js";
+import { isOrgRuntimeFolderSource, stripOrgRuntimeSourcesFromPack, } from "../org-sources.js";
+import { MAGIT_AGENTS_COLLECTION, MAGIT_SEED_AGENT_ID, packToPatchset, parseRecordId, parseSaveVersionIdempotencyKey, recordIdForDefinition, recordsToPack, } from "./pack-to-patchset.js";
+import { mergeProposalIntoPack, } from "./proposal-to-pack.js";
+const MEMORIX_LENS = {
+    [MAGIT_AGENTS_COLLECTION]: {
+        docKey: "agentId",
+        explode: {
+            path: "definitions",
+            recordId: "{agentId}/{kind}/{id}",
+            recordFields: ["kind", "id"],
+            carry: ["agentId"],
+        },
+        preserve: "passthrough",
+    },
+};
+const MAGITIGNORE = `# Memorix Phase 0 — ignore install ledger (not versioned)
+memorix_metadata_install_ledger
+memorix_metadata_releases
+`;
+const RELEASES_FILE = "memorix-releases.json";
+/**
+ * Magit is on by default when durable Mongo is configured (platform gates that).
+ * Set METADATA_MAGIT=0 / false / off to disable.
+ */
+export function isMetadataMagitEnabled() {
+    const v = process.env.METADATA_MAGIT?.trim().toLowerCase();
+    if (v === "0" || v === "false" || v === "off" || v === "no")
+        return false;
+    // Default-on when unset or any other truthy-ish value (including "1"/"true"/"on").
+    return true;
+}
+export function resolveMagitRepoRootParent() {
+    const fromEnv = process.env.MAGIT_REPO_ROOT?.trim();
+    if (fromEnv)
+        return fromEnv;
+    return join(process.cwd(), ".tmp", "magit-repos");
+}
+function isLiveRef(ref) {
+    return ref === "live" || ref === "LIVE";
+}
+function isHeadRef(ref) {
+    return ref === "HEAD" || ref === "head";
+}
+function fieldDiffs(before, after) {
+    const beforeObj = before && typeof before === "object" && !Array.isArray(before)
+        ? before
+        : null;
+    const afterObj = after && typeof after === "object" && !Array.isArray(after)
+        ? after
+        : null;
+    if (!beforeObj && !afterObj)
+        return undefined;
+    const keys = new Set([
+        ...Object.keys(beforeObj ?? {}),
+        ...Object.keys(afterObj ?? {}),
+    ]);
+    const fields = [];
+    for (const path of [...keys].sort()) {
+        const hasB = beforeObj != null && path in beforeObj;
+        const hasA = afterObj != null && path in afterObj;
+        if (!hasB && hasA)
+            fields.push({ path, change: "added" });
+        else if (hasB && !hasA)
+            fields.push({ path, change: "removed" });
+        else if (hasB &&
+            hasA &&
+            JSON.stringify(beforeObj[path]) !== JSON.stringify(afterObj[path])) {
+            fields.push({ path, change: "changed" });
+        }
+    }
+    return fields.length ? fields : undefined;
+}
+function unwrapDefinitionBody(body) {
+    if (!body || typeof body !== "object")
+        return body;
+    const rec = body;
+    if (rec.definition && typeof rec.definition === "object")
+        return rec.definition;
+    return body;
+}
+export class MagitPackService {
+    cfg;
+    ensured = new Set();
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    progress() {
+        const log = this.cfg.log;
+        createProgressReporter({ mode: "json" });
+        return {
+            tick(phase, detail) {
+                log?.(`[magit] ${phase}`, detail);
+            },
+        };
+    }
+    repoRootFor(orgId) {
+        return join(this.cfg.repoRootParent, orgId);
+    }
+    async ensureRepo(orgId) {
+        if (this.ensured.has(orgId))
+            return;
+        const { tick } = this.progress();
+        try {
+            this.ensureMongoEnv();
+            mkdirSync(this.cfg.repoRootParent, { recursive: true });
+            const repoRoot = this.repoRootFor(orgId);
+            mkdirSync(repoRoot, { recursive: true });
+            const repo = await magit.open({ repoRoot });
+            const configPath = join(repoRoot, ".magit", "config.json");
+            if (!existsSync(configPath)) {
+                tick("ensureRepo.init", { orgId });
+                await repo.init({
+                    name: `memorix-metadata-${orgId}`,
+                    driver: "transform",
+                    urlEnv: this.cfg.mongoUrlEnv,
+                    db: this.cfg.metadataDb,
+                    driverConfig: {
+                        kind: "transform",
+                        base: {
+                            kind: "mongo",
+                            urlEnv: this.cfg.mongoUrlEnv,
+                            db: this.cfg.metadataDb,
+                        },
+                        lens: MEMORIX_LENS,
+                        encodingProfile: "current",
+                    },
+                    storageProvider: "x12i-http",
+                    storageUrl: this.cfg.storageUrl ||
+                        process.env.MAGIT_STORAGE_URL?.trim() ||
+                        "https://magit-storage.x12i.com",
+                    storageTokenEnv: this.cfg.storageTokenEnv || "MAGIT_TOKEN",
+                    storageTenant: orgId,
+                    environmentName: "draft",
+                    skipRemoteBootstrap: true,
+                });
+                writeFileSync(join(repoRoot, ".magitignore"), MAGITIGNORE, "utf8");
+                await this.seedAgentsCollectionCommit(repo);
+            }
+            this.ensured.add(orgId);
+        }
+        catch (err) {
+            throw this.mapError(err, "failed to ensure Magit repo");
+        }
+    }
+    async saveVersion(orgId, pack, opts) {
+        const message = opts.message?.trim();
+        if (!message) {
+            throw new ServiceError("VALIDATION", "message required for save version", 400);
+        }
+        await this.ensureRepo(orgId);
+        const { tick } = this.progress();
+        try {
+            const cleanPack = stripOrgRuntimeSourcesFromPack(pack);
+            tick("saveVersion.start", { orgId, agentId: cleanPack.agentId });
+            const repo = await magit.open({ repoRoot: this.repoRootFor(orgId) });
+            const tip = (await repo.listCommitsFromHead({ maxCount: 1 }))[0]?.hash;
+            // Magit history is cumulative — delete prior org folder source records so
+            // packAtCommit cannot resurrect src_* after a stripped save.
+            const deleteRecordIds = [];
+            if (tip) {
+                try {
+                    const tipPack = await this.packAtCommitRaw(orgId, cleanPack.agentId, tip);
+                    for (const src of tipPack.pack.sources ?? []) {
+                        if (!isOrgRuntimeFolderSource(src))
+                            continue;
+                        const id = String(src.id ?? "");
+                        if (!id)
+                            continue;
+                        deleteRecordIds.push(recordIdForDefinition(cleanPack.agentId, "sources", id));
+                    }
+                }
+                catch {
+                    // Tip may be seed-only; proceed with puts only.
+                }
+            }
+            const { patchset, checksum } = packToPatchset(cleanPack, {
+                message,
+                actor: opts.actor?.subject,
+                baseCommit: tip,
+                deleteRecordIds,
+            });
+            const result = await repo.proposePatchset(patchset);
+            // Magit proposals are content-addressed and do not move HEAD. Pin the tip so
+            // the next agent/pack save inherits prior records (multi-agent release sets).
+            if (!result.reused) {
+                this.pinPackTip(repo, result.commitHash);
+            }
+            tick("saveVersion.done", { commit: result.commitHash, reused: result.reused });
+            return {
+                commit: result.commitHash,
+                checksum,
+                reused: result.reused,
+            };
+        }
+        catch (err) {
+            throw this.mapError(err, "failed to save pack version");
+        }
+    }
+    /**
+     * Advance Magit HEAD / main to a proposal commit so subsequent proposePatchset
+     * calls with base HEAD inherit prior agent records.
+     */
+    pinPackTip(repo, commitHash) {
+        const storeDir = repo.repoPaths().storeDir;
+        mkdirSync(join(storeDir, "refs", "heads"), { recursive: true });
+        writeFileSync(join(storeDir, "HEAD"), `${commitHash}\n`, "utf8");
+        writeFileSync(join(storeDir, "refs", "heads", "main"), `${commitHash}\n`, "utf8");
+    }
+    /**
+     * Merge proposal draft into base pack and save a Magit version (not live).
+     */
+    async importProposal(orgId, opts) {
+        const agentId = opts.agentId?.trim();
+        if (!agentId)
+            throw new ServiceError("VALIDATION", "agentId required", 400);
+        if (!opts.proposal?.proposalId?.trim()) {
+            throw new ServiceError("VALIDATION", "proposalId required", 400);
+        }
+        let pack;
+        try {
+            pack = mergeProposalIntoPack(opts.basePack, opts.proposal, agentId);
+        }
+        catch (err) {
+            throw new ServiceError("VALIDATION", err instanceof Error ? err.message : String(err), 400);
+        }
+        const saved = await this.saveVersion(orgId, pack, {
+            message: `proposal:${opts.proposal.proposalId.trim()}`,
+            actor: opts.actor,
+        });
+        return { ...saved, pack };
+    }
+    /**
+     * Snapshot a live pack as the initial Magit commit for legacy checksum-only installs.
+     */
+    async backfillLineage(orgId, pack, opts) {
+        return this.saveVersion(orgId, pack, {
+            message: "backfill: initial snapshot",
+            actor: opts?.actor,
+        });
+    }
+    async history(orgId, agentId, opts) {
+        if (!agentId?.trim()) {
+            throw new ServiceError("VALIDATION", "agentId required", 400);
+        }
+        await this.ensureRepo(orgId);
+        const maxCount = opts?.maxCount ?? 50;
+        try {
+            const repoRoot = this.repoRootFor(orgId);
+            const repo = await magit.open({ repoRoot });
+            const metagitDir = repo.repoPaths().metagitDir;
+            const proposals = await listProposalLedgerEntries(metagitDir);
+            const saved = [];
+            for (const entry of proposals) {
+                const parsed = parseSaveVersionIdempotencyKey(entry.idempotencyKey);
+                if (!parsed || parsed.agentId !== agentId)
+                    continue;
+                saved.push({
+                    commit: entry.commitHash,
+                    agentId: parsed.agentId,
+                    checksum: parsed.checksum,
+                    message: null,
+                    createdAt: entry.createdAt,
+                    source: "save-version",
+                });
+            }
+            const headCommits = await repo.listCommitsFromHead({ maxCount });
+            const head = headCommits.map((c) => ({
+                commit: c.hash,
+                agentId,
+                checksum: typeof c.proposal?.provenance?.checksum === "string"
+                    ? c.proposal.provenance.checksum
+                    : null,
+                message: c.message ?? null,
+                createdAt: c.timestamp,
+                source: "head",
+            }));
+            const byCommit = new Map();
+            for (const row of head)
+                byCommit.set(row.commit, row);
+            for (const row of saved)
+                byCommit.set(row.commit, row);
+            return [...byCommit.values()]
+                .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+                .slice(0, maxCount);
+        }
+        catch (err) {
+            throw this.mapError(err, "failed to list pack versions");
+        }
+    }
+    async diff(orgId, agentId, opts) {
+        if (!agentId?.trim()) {
+            throw new ServiceError("VALIDATION", "agentId required", 400);
+        }
+        const from = opts.from?.trim();
+        const to = opts.to?.trim();
+        if (!from || !to) {
+            throw new ServiceError("VALIDATION", "from and to required", 400);
+        }
+        await this.ensureRepo(orgId);
+        const { tick } = this.progress();
+        try {
+            tick("diff.start", { orgId, agentId, from, to });
+            this.ensureMongoEnv();
+            const repo = await magit.open({ repoRoot: this.repoRootFor(orgId) });
+            const changes = await this.collectDiffRows(repo, agentId, from, to);
+            tick("diff.done", { changeCount: changes.length });
+            return { agentId, from, to, changes };
+        }
+        catch (err) {
+            throw this.mapError(err, "failed to diff pack versions");
+        }
+    }
+    /** Reconstruct pack without org-source hygiene (used to emit Magit deletes). */
+    async packAtCommitRaw(orgId, agentId, commitHash) {
+        this.ensureMongoEnv();
+        const repo = await magit.open({ repoRoot: this.repoRootFor(orgId) });
+        const seed = await this.resolveSeedCommit(repo);
+        const diff = await repo.diffBetweenCommits({
+            from: seed,
+            to: commitHash,
+            recordFull: true,
+            includeRemovedRecordBodies: false,
+        });
+        const col = diff.collections[MAGIT_AGENTS_COLLECTION];
+        const rows = (col?.records ?? [])
+            .filter((r) => r.after != null)
+            .map((r) => ({ id: r.id, after: r.after }));
+        const pack = recordsToPack(agentId, rows);
+        const checksum = checksumMetadataPack(pack);
+        return { pack, checksum, commit: commitHash };
+    }
+    async packAtCommit(orgId, agentId, commit) {
+        if (!agentId?.trim()) {
+            throw new ServiceError("VALIDATION", "agentId required", 400);
+        }
+        const commitHash = commit?.trim();
+        if (!commitHash) {
+            throw new ServiceError("VALIDATION", "commit required", 400);
+        }
+        await this.ensureRepo(orgId);
+        const { tick } = this.progress();
+        try {
+            tick("packAtCommit.start", { agentId, commit: commitHash });
+            const loaded = await this.packAtCommitRaw(orgId, agentId, commitHash);
+            const pack = stripOrgRuntimeSourcesFromPack(loaded.pack);
+            const checksum = checksumMetadataPack(pack);
+            return { pack, checksum, commit: commitHash };
+        }
+        catch (err) {
+            throw this.mapError(err, "failed to load pack at commit");
+        }
+    }
+    /**
+     * Apply a Magit commit into live metadata Mongo (transform driver).
+     * Caller must rehydrate the Memorix metadata store afterward.
+     */
+    async applyCommit(orgId, opts) {
+        const commitHash = opts.commit?.trim();
+        if (!commitHash) {
+            throw new ServiceError("VALIDATION", "commit required", 400);
+        }
+        await this.ensureRepo(orgId);
+        try {
+            this.ensureMongoEnv();
+            const repo = await magit.open({ repoRoot: this.repoRootFor(orgId) });
+            void opts.agentId;
+            const result = await repo.applyCommit(commitHash, {
+                mongoTarget: {
+                    urlEnv: this.cfg.mongoUrlEnv,
+                    db: this.cfg.metadataDb,
+                },
+                recordsMode: "exact",
+            });
+            return {
+                commit: result.commit,
+                summary: {
+                    recordsUpserted: result.summary.recordsUpserted,
+                    recordsDeleted: result.summary.recordsDeleted,
+                },
+            };
+        }
+        catch (err) {
+            throw this.mapError(err, "failed to apply pack commit");
+        }
+    }
+    async publishPlan(orgId, opts) {
+        const release = opts.release?.trim();
+        const commit = opts.commit?.trim();
+        const agentIds = opts.agentIds.map((a) => a.trim()).filter(Boolean);
+        if (!release)
+            throw new ServiceError("VALIDATION", "release name required", 400);
+        if (!commit)
+            throw new ServiceError("VALIDATION", "commit required", 400);
+        if (!agentIds.length) {
+            throw new ServiceError("VALIDATION", "agentIds required", 400);
+        }
+        await this.ensureRepo(orgId);
+        try {
+            this.ensureMongoEnv();
+            const repo = await magit.open({ repoRoot: this.repoRootFor(orgId) });
+            const plan = await repo.diffCommitToLive(commit, {
+                mongoTarget: {
+                    urlEnv: this.cfg.mongoUrlEnv,
+                    db: this.cfg.metadataDb,
+                },
+                recordFull: true,
+                only: agentIds.map((id) => `agentId=${id}`),
+            });
+            let toInsert = 0;
+            let toUpdate = 0;
+            let wouldDelete = 0;
+            const changes = [];
+            for (const agentId of agentIds) {
+                const col = plan.collections[MAGIT_AGENTS_COLLECTION];
+                if (!col)
+                    continue;
+                toInsert += col.toInsert;
+                toUpdate += col.toUpdate;
+                wouldDelete += col.wouldDelete;
+                for (const row of col.records ?? []) {
+                    const parsed = parseRecordId(row.id);
+                    if (!parsed || parsed.agentId !== agentId)
+                        continue;
+                    let change = "changed";
+                    if (row.before == null && row.after != null)
+                        change = "added";
+                    else if (row.before != null && row.after == null)
+                        change = "removed";
+                    const beforeBody = unwrapDefinitionBody(row.before);
+                    const afterBody = unwrapDefinitionBody(row.after);
+                    const fields = fieldDiffs(beforeBody, afterBody);
+                    let labels;
+                    try {
+                        const labeled = labelDiff({
+                            kind: parsed.kind,
+                            id: parsed.id,
+                            change,
+                            before: beforeBody,
+                            after: afterBody,
+                        });
+                        if (Array.isArray(labeled)) {
+                            labels = labeled.map(String);
+                        }
+                        else if (labeled && typeof labeled === "object") {
+                            const maybe = labeled.labels;
+                            if (Array.isArray(maybe))
+                                labels = maybe.map(String);
+                        }
+                    }
+                    catch {
+                        /* optional enrichment */
+                    }
+                    changes.push({
+                        kind: parsed.kind,
+                        id: parsed.id,
+                        change,
+                        ...(labels?.length ? { labels } : {}),
+                        ...(fields ? { fields } : {}),
+                    });
+                }
+            }
+            const planHash = createHash("sha256")
+                .update(JSON.stringify({ release, commit, agentIds, toInsert, toUpdate, wouldDelete }))
+                .digest("hex");
+            return {
+                release,
+                commit,
+                agentIds,
+                planHash,
+                summary: { toInsert, toUpdate, wouldDelete },
+                changes,
+            };
+        }
+        catch (err) {
+            throw this.mapError(err, "failed to plan publish");
+        }
+    }
+    async recordRelease(orgId, release) {
+        await this.ensureRepo(orgId);
+        const path = this.releasesPath(orgId);
+        const all = this.readReleases(orgId);
+        const next = all.filter((r) => r.name !== release.name);
+        next.push(release);
+        next.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        writeFileSync(path, JSON.stringify({ releases: next }, null, 2), "utf8");
+        return release;
+    }
+    listReleases(orgId) {
+        return this.readReleases(orgId);
+    }
+    releasesPath(orgId) {
+        return join(this.repoRootFor(orgId), ".magit", RELEASES_FILE);
+    }
+    readReleases(orgId) {
+        const path = this.releasesPath(orgId);
+        if (!existsSync(path))
+            return [];
+        try {
+            const raw = JSON.parse(readFileSync(path, "utf8"));
+            return Array.isArray(raw.releases) ? raw.releases : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    async resolveSeedCommit(repo) {
+        const commits = await repo.listCommitsFromHead({ maxCount: 200 });
+        const seed = [...commits]
+            .reverse()
+            .find((c) => (c.message ?? "").includes("seed metadata"));
+        if (seed?.hash)
+            return seed.hash;
+        const oldest = commits[commits.length - 1];
+        if (!oldest?.hash) {
+            throw new ServiceError("MAGIT_UNAVAILABLE", "Magit repo has no commits", 503);
+        }
+        return oldest.hash;
+    }
+    async resolveCommitRef(repo, ref) {
+        if (isHeadRef(ref)) {
+            const head = await repo.listCommitsFromHead({ maxCount: 1 });
+            const hash = head[0]?.hash;
+            if (!hash) {
+                throw new ServiceError("VALIDATION", "HEAD has no commits", 400);
+            }
+            return hash;
+        }
+        return ref;
+    }
+    async collectDiffRows(repo, agentId, from, to) {
+        const rows = [];
+        const pushRows = (records, infer) => {
+            for (const r of records ?? []) {
+                const parsed = parseRecordId(r.id);
+                if (!parsed || parsed.agentId !== agentId)
+                    continue;
+                if (parsed.agentId === MAGIT_SEED_AGENT_ID)
+                    continue;
+                const change = infer(r);
+                if (!change)
+                    continue;
+                const beforeBody = unwrapDefinitionBody(r.before);
+                const afterBody = unwrapDefinitionBody(r.after);
+                const fields = fieldDiffs(beforeBody, afterBody);
+                let labels;
+                try {
+                    const labeled = labelDiff({
+                        kind: parsed.kind,
+                        id: parsed.id,
+                        change,
+                        before: beforeBody,
+                        after: afterBody,
+                    });
+                    if (Array.isArray(labeled))
+                        labels = labeled.map(String);
+                    else if (labeled && typeof labeled === "object") {
+                        const maybe = labeled.labels;
+                        if (Array.isArray(maybe))
+                            labels = maybe.map(String);
+                    }
+                }
+                catch {
+                    /* optional */
+                }
+                rows.push({
+                    kind: parsed.kind,
+                    id: parsed.id,
+                    change,
+                    ...(labels?.length ? { labels } : {}),
+                    ...(fields ? { fields } : {}),
+                });
+            }
+        };
+        if (isLiveRef(from) && isLiveRef(to)) {
+            return [];
+        }
+        if (isLiveRef(to) || isLiveRef(from)) {
+            const commitSide = isLiveRef(to) ? from : to;
+            const commitHash = await this.resolveCommitRef(repo, commitSide);
+            const plan = await repo.diffCommitToLive(commitHash, {
+                mongoTarget: {
+                    urlEnv: this.cfg.mongoUrlEnv,
+                    db: this.cfg.metadataDb,
+                },
+                recordFull: true,
+                only: [`agentId=${agentId}`],
+            });
+            const col = plan.collections[MAGIT_AGENTS_COLLECTION];
+            const invert = isLiveRef(from);
+            pushRows(col?.records, (r) => {
+                const hasBefore = r.before != null || Boolean(r.beforeHash);
+                const hasAfter = r.after != null || Boolean(r.afterHash);
+                let change = null;
+                if (!hasBefore && hasAfter)
+                    change = "added";
+                else if (hasBefore && !hasAfter)
+                    change = "removed";
+                else if (hasBefore && hasAfter)
+                    change = "changed";
+                if (!change)
+                    return null;
+                if (!invert)
+                    return change;
+                if (change === "added")
+                    return "removed";
+                if (change === "removed")
+                    return "added";
+                return "changed";
+            });
+            return rows;
+        }
+        const fromHash = await this.resolveCommitRef(repo, from);
+        const toHash = await this.resolveCommitRef(repo, to);
+        const diff = await repo.diffBetweenCommits({
+            from: fromHash,
+            to: toHash,
+            recordFull: true,
+            includeRemovedRecordBodies: true,
+        });
+        const col = diff.collections[MAGIT_AGENTS_COLLECTION];
+        pushRows(col?.records, (r) => {
+            const hasBefore = r.before != null || Boolean(r.beforeHash);
+            const hasAfter = r.after != null || Boolean(r.afterHash);
+            if (!hasBefore && hasAfter)
+                return "added";
+            if (hasBefore && !hasAfter)
+                return "removed";
+            if (hasBefore && hasAfter)
+                return "changed";
+            return null;
+        });
+        return rows;
+    }
+    /**
+     * Snapshot a temporary seed agent so HEAD carries `memorix_metadata_agents`,
+     * then remove the seed from live Mongo (saveVersion must stay non-live).
+     */
+    async seedAgentsCollectionCommit(repo) {
+        this.ensureMongoEnv();
+        const client = new MongoClient(this.cfg.mongoUri);
+        await client.connect();
+        try {
+            const col = client
+                .db(this.cfg.metadataDb)
+                .collection(MAGIT_AGENTS_COLLECTION);
+            await col.updateOne({ _id: MAGIT_SEED_AGENT_ID }, {
+                $set: {
+                    agentId: MAGIT_SEED_AGENT_ID,
+                    checksum: "magit-seed",
+                    definitions: [
+                        {
+                            kind: "agents",
+                            id: MAGIT_SEED_AGENT_ID,
+                            definition: {
+                                id: MAGIT_SEED_AGENT_ID,
+                                name: "magit-seed",
+                                parentId: null,
+                            },
+                        },
+                    ],
+                },
+            }, { upsert: true });
+            await repo.commit({ message: "memorix: seed metadata collections" });
+            await col.deleteOne({ _id: MAGIT_SEED_AGENT_ID });
+        }
+        finally {
+            await client.close();
+        }
+    }
+    ensureMongoEnv() {
+        if (!process.env[this.cfg.mongoUrlEnv]?.trim()) {
+            process.env[this.cfg.mongoUrlEnv] = this.cfg.mongoUri;
+        }
+    }
+    mapError(err, fallback) {
+        if (err instanceof ServiceError)
+            return err;
+        if (isPatchsetError(err)) {
+            return new ServiceError("VALIDATION", `${fallback}: ${err.message}`, 400);
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return new ServiceError("MAGIT_UNAVAILABLE", `${fallback}: ${message}`, 503);
+    }
+}
+export function createMagitPackService(cfg) {
+    return new MagitPackService(cfg);
+}
+//# sourceMappingURL=magit-pack-service.js.map