@lesliechan721/aw 0.1.0-beta.5 → 0.1.0-beta.51

package/dist/src/commands/catalog-publication-inspection.js

@@ -1,11 +1,15 @@
+import { realpath } from 'node:fs/promises';
 import crypto from 'node:crypto';
 import { execFile } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import fs from 'fs-extra';
-import { preparePublishedCatalogWorkspace, readCatalogWorkspace, validatePublishedCatalogSnapshot, } from '@lesliechan721/aw-plugin-core';
+import { CATALOG_MANIFEST_FILENAME, GENERATED_OUTPUT_MARKER_FILENAME, preparePublishedCatalogWorkspace, readCatalogWorkspaceMarker, readCatalogWorkspace, validatePublishedCatalogSnapshot, validatePublishedCatalogSnapshotMetadata, } from '@lesliechan721/aw-plugin-core';
+import { readGitBlobsBatch } from '../../authoring/scripts/lib/plugin-version-check.mjs';
 import { bundleLocalPlugin, createCatalogRuntimeImportResolver } from '../../scripts/plugin-staging.js';
+import { redactString } from '../output/redact.js';
+import { sanitizeCatalogSourceErrorMessage } from '../utils/catalog-public-error.js';
 import { CLI_RESERVED_IMPORTS } from '../utils/manifest.js';
 import { resolveCliPackageRoot } from '../utils/paths.js';
 const execFileAsync = promisify(execFile);
@@ -37,7 +41,8 @@ function directRemoteGitEnvironment(source) {
     return {
         ...sanitizedGitEnvironment(source),
         GIT_CONFIG_NOSYSTEM: '1',
-        GIT_CONFIG_GLOBAL: os.devNull,
+        // Git for Windows maps /dev/null itself; Node's device path is not a Git path.
+        GIT_CONFIG_GLOBAL: '/dev/null',
         GIT_ATTR_NOSYSTEM: '1',
         GIT_TERMINAL_PROMPT: '0',
     };
@@ -61,21 +66,83 @@ export function safeRemoteIdentity(value) {
         .replace(/^([^/@\s:]+):([^/@\s]+)@/u, '')
         .replace(/^[^@\s]+@(?=[^:/\s]+[/:])/u, '');
 }
-function assertSafeRemoteUrl(value) {
-    if (value.trim() === '' || value !== value.trim() || /\s/u.test(value) || value.startsWith('-')) {
+function sanitizeCatalogPublicationMessage(message, env, sensitiveRoots, sensitiveValues = []) {
+    const normalized = redactString(message.replace(/[\p{Cc}\p{Cf}]+/gu, ' '));
+    const withoutSensitiveValues = [...sensitiveValues]
+        .filter((value) => value.length >= 4)
+        .sort((left, right) => right.length - left.length)
+        .reduce((output, value) => output.replaceAll(value, '[remote]'), normalized);
+    const withoutRemotes = withoutSensitiveValues
+        .replace(/[a-z][a-z\d+.-]*:\/\/[^\s"'<>]+/giu, '[remote]')
+        .replace(/[^\s"'<>@]+@[^\s"'<>:/]+[:/][^\s"'<>]+/gu, '[remote]');
+    const withoutKnownRoots = sanitizeCatalogSourceErrorMessage(withoutRemotes, env, sensitiveRoots);
+    return redactString(withoutKnownRoots).replace(/(?<![A-Za-z0-9._-])(?:[A-Za-z]:[\\/]|\/)(?:[^\s"'<>:]+[\\/])*[^\s"'<>:]*/gu, '[private-path]');
+}
+function remoteSensitiveValues(value) {
+    const values = new Set([value]);
+    if (/^[a-z][a-z\d+.-]*:\/\//iu.test(value)) {
+        try {
+            const url = new URL(value);
+            for (const part of [url.username, url.password, url.hostname, url.pathname, url.pathname.slice(1)]) {
+                if (part.length >= 4)
+                    values.add(part);
+            }
+        }
+        catch {
+            // The remote value is validated separately.
+        }
+    }
+    else {
+        const match = /^(?:([^@:/]+)@)?([^:/]+)[:/](.+)$/u.exec(value);
+        for (const part of match?.slice(1) ?? []) {
+            if (part && part.length >= 4)
+                values.add(part);
+        }
+    }
+    return [...values];
+}
+export function catalogPublicationFailure(options) {
+    const original = options.error instanceof Error
+        ? options.error.message
+        : String(options.error);
+    const message = sanitizeCatalogPublicationMessage(original, options.env, options.sensitiveRoots);
+    return {
+        ok: false,
+        code: options.error instanceof CatalogPublicationInspectionError
+            ? options.error.code
+            : 'catalogPublicationFailed',
+        message,
+    };
+}
+function assertSafeRemoteUrl(value, options = {}) {
+    if (value.trim() === '' || value !== value.trim() || /[\s\p{Cc}]/u.test(value) || value.startsWith('-')) {
         throw new CatalogPublicationInspectionError('remoteInvalid', 'Catalog remote URL is unsafe.');
     }
-    if (/^[a-z][a-z\d+.-]*:\/\/[^/\s?#]*@/iu.test(value)) {
+    if (!options.allowCredentials && /^[a-z][a-z\d+.-]*:\/\/[^/\s?#]*@/iu.test(value)) {
         throw new CatalogPublicationInspectionError('remoteInvalid', 'Catalog remote URL must not contain embedded credentials.');
     }
     return value;
 }
-export function catalogAttemptPath(catalogWorkspaceRoot, catalogVersion) {
-    return path.join(catalogWorkspaceRoot, '.aw', 'publish', 'attempts', `${catalogVersion}.json`);
+function assertSafeRemoteName(value) {
+    if (value === '' || value !== value.trim() || value.startsWith('-') || /[\s\p{Cc}]/u.test(value)) {
+        throw new CatalogPublicationInspectionError('remoteInvalid', 'Catalog remote name is unsafe.');
+    }
+    return value;
+}
+function assertSafeBranchValue(value) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/u.test(value)) {
+        throw new CatalogPublicationInspectionError('branchInvalid', 'Invalid Catalog publication branch name.');
+    }
+    return value;
 }
-export async function publicationGit(cwd, args, env, code, label) {
+export async function publicationGit(cwd, args, env, code, label, sensitiveValues = []) {
     try {
-        const result = await execFileAsync('git', [...args], {
+        // Keep maintenance in the foreground before callers remove temporary repositories.
+        // Pending repositories and verification trees can exceed Windows MAX_PATH.
+        const result = await execFileAsync('git', [
+            '-c', 'core.hooksPath=/dev/null', '-c', 'core.longpaths=true',
+            '-c', 'gc.autoDetach=false', '-c', 'maintenance.autoDetach=false', ...args,
+        ], {
             cwd,
             env,
             encoding: 'utf8',
@@ -84,12 +151,33 @@ export async function publicationGit(cwd, args, env, code, label) {
         return result.stdout.trim();
     }
     catch (error) {
-        throw new CatalogPublicationInspectionError(code, label, { cause: error });
+        const failure = error;
+        const status = typeof failure.code === 'number' && Number.isSafeInteger(failure.code)
+            ? `exited with code ${failure.code}`
+            : typeof failure.code === 'string' && /^[A-Z0-9_]+$/u.test(failure.code)
+                ? `failed with code ${failure.code}`
+                : 'failed';
+        const rawDetails = typeof failure.stderr === 'string' && failure.stderr.trim() !== ''
+            ? failure.stderr
+            : typeof failure.message === 'string'
+                ? failure.message
+                : '';
+        const details = sanitizeCatalogPublicationMessage(rawDetails, env, [cwd], sensitiveValues)
+            .replace(/\s+/gu, ' ')
+            .trim();
+        throw new CatalogPublicationInspectionError(code, `${label} Git ${status}${details ? `: ${details.slice(0, 2_000)}` : '.'}`, { cause: error });
     }
 }
 export async function publicationGitExit(cwd, args, env) {
     try {
-        await execFileAsync('git', [...args], { cwd, env, encoding: 'utf8' });
+        await execFileAsync('git', [
+            '-c', 'core.hooksPath=/dev/null', '-c', 'core.longpaths=true',
+            '-c', 'gc.autoDetach=false', '-c', 'maintenance.autoDetach=false', ...args,
+        ], {
+            cwd,
+            env,
+            encoding: 'utf8',
+        });
         return true;
     }
     catch {
@@ -106,12 +194,17 @@ export async function materializeSourceHead(options) {
     const archivePath = path.join(options.temporaryRoot, 'source-head.tar');
     await fs.ensureDir(options.outputRoot);
     await publicationGit(options.repoRoot, [
+        '-c', 'core.autocrlf=false', '-c', 'core.eol=lf',
         'archive', '--format=tar', `--output=${archivePath}`, options.sourceHead,
     ], options.env, 'sourceArchiveFailed', 'Could not archive the committed source HEAD.');
     const tarEnv = { ...options.env };
     delete tarEnv.TAR_OPTIONS;
     try {
-        await execFileAsync('tar', ['-xf', archivePath, '-C', options.outputRoot], {
+        await execFileAsync('tar', [
+            '-xf', path.relative(options.temporaryRoot, archivePath),
+            '-C', path.relative(options.temporaryRoot, options.outputRoot),
+        ], {
+            cwd: options.temporaryRoot,
             env: tarEnv,
             encoding: 'utf8',
             maxBuffer: 16 * 1024 * 1024,
@@ -173,12 +266,108 @@ function inspectionError(code, error) {
         cause: error,
     });
 }
+async function validatePublishedCatalogSnapshotForWorkspace(snapshotRoot, workspaceIdentity) {
+    try {
+        const validation = await validatePublishedCatalogSnapshot(snapshotRoot);
+        const markerPath = path.join(snapshotRoot, GENERATED_OUTPUT_MARKER_FILENAME);
+        const markerStats = await fs.lstat(markerPath).catch((error) => {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        });
+        if (!markerStats?.isFile() || markerStats.isSymbolicLink()) {
+            throw new Error('Published Catalog snapshot marker must be a regular local file.');
+        }
+        const marker = await fs.readJson(markerPath);
+        if (marker.workspaceIdentity !== workspaceIdentity) {
+            throw new Error('Published Catalog snapshot belongs to a different Workspace identity.');
+        }
+        return validation;
+    }
+    catch (error) {
+        throw inspectionError('remoteSnapshotInvalid', error);
+    }
+}
+async function materializePublishedCatalogMetadata(options) {
+    await fs.remove(options.outputRoot);
+    await fs.ensureDir(options.outputRoot);
+    const metadataPaths = [GENERATED_OUTPUT_MARKER_FILENAME, CATALOG_MANIFEST_FILENAME];
+    const records = (await publicationGit(options.repositoryRoot, [
+        'ls-tree', options.commit, '--', ...metadataPaths,
+    ], options.env, 'remoteBranchInvalid', 'Could not inspect published Catalog history.')).split('\n');
+    const metadata = metadataPaths.map((relative) => {
+        const record = records.find((value) => value.endsWith(`\t${relative}`)) ?? '';
+        const match = /^(100644|100755) blob ([0-9a-f]+)\t(.+)$/u.exec(record);
+        if (records.length !== metadataPaths.length || !match || match[3] !== relative) {
+            throw new CatalogPublicationInspectionError('remoteSnapshotInvalid', 'Published Catalog history metadata must contain regular files.');
+        }
+        return { relative, objectId: match[2] };
+    });
+    let contents;
+    try {
+        contents = await readGitBlobsBatch(options.repositoryRoot, metadata.map((entry) => entry.objectId), {
+            env: options.env,
+            argsPrefix: ['-c', 'core.hooksPath=/dev/null', '-c', 'core.longpaths=true'],
+        });
+    }
+    catch (error) {
+        const details = sanitizeCatalogPublicationMessage(error instanceof Error ? error.message : String(error), options.env, [options.repositoryRoot]).replace(/\s+/gu, ' ').trim();
+        throw new CatalogPublicationInspectionError('remoteBranchInvalid', `Could not read published Catalog history.${details ? ` ${details.slice(0, 2_000)}` : ''}`, { cause: error });
+    }
+    for (const { relative, objectId } of metadata) {
+        await fs.writeFile(path.join(options.outputRoot, relative), contents.get(objectId));
+    }
+}
+async function findPreviousPluginEntriesInFirstParentHistory(options) {
+    const missing = new Set(options.pluginNames);
+    const found = new Map();
+    const historyRoot = path.join(options.temporaryRoot, 'history-metadata');
+    let commit = options.tipCommit;
+    while (missing.size > 0) {
+        const parents = (await publicationGit(options.repositoryRoot, [
+            'show', '-s', '--format=%P', commit,
+        ], options.env, 'remoteBranchInvalid', 'Could not inspect published Catalog history.'))
+            .split(/\s+/u)
+            .filter(Boolean);
+        const firstParent = parents[0];
+        if (!firstParent)
+            break;
+        commit = firstParent;
+        await materializePublishedCatalogMetadata({
+            repositoryRoot: options.repositoryRoot,
+            commit,
+            outputRoot: historyRoot,
+            env: options.env,
+        });
+        let metadata;
+        try {
+            metadata = await validatePublishedCatalogSnapshotMetadata(historyRoot);
+            if (metadata.workspaceIdentity !== options.workspaceIdentity) {
+                throw new Error('Published Catalog snapshot belongs to a different Workspace identity.');
+            }
+        }
+        catch (error) {
+            throw inspectionError('remoteSnapshotInvalid', error);
+        }
+        for (const entry of metadata.manifest.entries) {
+            if (!missing.delete(entry.name))
+                continue;
+            found.set(entry.name, entry);
+        }
+    }
+    return options.pluginNames.flatMap((name) => {
+        const entry = found.get(name);
+        return entry ? [entry] : [];
+    });
+}
 export async function prepareCatalogPublicationInspection(options) {
     if (options.remote !== undefined && options.remoteUrl !== undefined) {
         throw new CatalogPublicationInspectionError('remoteInvalid', 'Catalog publication accepts a configured remote name or a direct remote URL, not both.');
     }
-    const remote = options.remote ?? (options.remoteUrl === undefined ? 'origin' : 'direct');
-    const branch = options.branch ?? 'catalog';
+    const remote = options.remoteUrl === undefined
+        ? assertSafeRemoteName(options.remote ?? 'origin')
+        : 'direct';
+    const branch = assertSafeBranchValue(options.branch ?? 'catalog');
     const env = options.remoteUrl === undefined
         ? sanitizedGitEnvironment(options.env)
         : directRemoteGitEnvironment(options.env);
@@ -188,8 +377,23 @@ export async function prepareCatalogPublicationInspection(options) {
     let safeFetchUrl = '';
     let safePushUrl = '';
     try {
-        const catalogWorkspaceRoot = await fs.realpath(path.resolve(options.workspaceRoot));
-        const repoRoot = await publicationGit(catalogWorkspaceRoot, ['rev-parse', '--show-toplevel'], env, 'gitWorkspaceInvalid', 'Catalog Workspace must be inside a real Git worktree.');
+        const catalogWorkspaceRoot = await realpath(path.resolve(options.workspaceRoot));
+        const repoRoot = await realpath(await publicationGit(catalogWorkspaceRoot, ['rev-parse', '--show-toplevel'], env, 'gitWorkspaceInvalid', 'Catalog Workspace must be inside a real Git worktree.'));
+        await publicationGit(repoRoot, ['check-ref-format', '--branch', branch], env, 'branchInvalid', 'Invalid Catalog publication branch name.');
+        if (options.remoteUrl !== undefined) {
+            fetchUrl = assertSafeRemoteUrl(options.remoteUrl);
+            pushUrl = fetchUrl;
+        }
+        else {
+            const configuredRemotes = (await publicationGit(repoRoot, ['remote'], env, 'remoteMissing', 'Could not inspect configured Git remotes.')).split('\n').filter(Boolean);
+            if (!configuredRemotes.includes(remote)) {
+                throw new CatalogPublicationInspectionError('remoteInvalid', `Git remote ${JSON.stringify(remote)} is not configured.`);
+            }
+            fetchUrl = assertSafeRemoteUrl(await publicationGit(repoRoot, ['remote', 'get-url', remote], env, 'remoteMissing', `Git remote ${JSON.stringify(remote)} is not configured.`), { allowCredentials: true });
+            pushUrl = assertSafeRemoteUrl(await publicationGit(repoRoot, ['remote', 'get-url', '--push', remote], env, 'remoteMissing', `Git remote ${JSON.stringify(remote)} has no push URL.`), { allowCredentials: true });
+        }
+        safeFetchUrl = safeRemoteIdentity(fetchUrl);
+        safePushUrl = safeRemoteIdentity(pushUrl);
         const sourceHead = await publicationGit(repoRoot, ['rev-parse', '--verify', 'HEAD'], env, 'sourceHeadMissing', 'Catalog Workspace Git HEAD must be committed and not unborn.');
         const status = await publicationGit(repoRoot, [
             'status', '--porcelain=v1', '--untracked-files=all', '--ignore-submodules=none',
@@ -207,7 +411,6 @@ export async function prepareCatalogPublicationInspection(options) {
             throw new CatalogPublicationInspectionError('workspaceOutsideRepository', 'Catalog Workspace must stay inside its Git worktree root.');
         }
         const archivedCatalogWorkspaceRoot = path.join(sourceRoot, catalogWorkspaceRelative);
-        await publicationGit(repoRoot, ['check-ref-format', '--branch', branch], env, 'branchInvalid', 'Invalid Catalog publication branch name.');
         let catalogWorkspace;
         try {
             catalogWorkspace = await readCatalogWorkspace(archivedCatalogWorkspaceRoot, { reservedImports: CLI_RESERVED_IMPORTS });
@@ -215,44 +418,30 @@ export async function prepareCatalogPublicationInspection(options) {
         catch (error) {
             throw inspectionError('workspaceInvalid', error);
         }
+        const ownerUrl = catalogWorkspace.metadata.owner.url;
+        if (URL.canParse(ownerUrl) && new URL(ownerUrl).hostname === 'example.invalid') {
+            throw new CatalogPublicationInspectionError('catalogMetadataIncomplete', 'Catalog owner URL still uses the example.invalid placeholder. Set plugins/marketplace-source.json owner.url before publication.');
+        }
         await validateCatalogPublicationPlugins(catalogWorkspace, env);
         const catalogVersion = catalogWorkspace.metadata.catalog.version;
         const tag = `catalog-v${catalogVersion}`;
         await publicationGit(repoRoot, ['check-ref-format', `refs/tags/${tag}`], env, 'tagInvalid', 'Invalid Catalog publication tag.');
-        const attemptPath = catalogAttemptPath(catalogWorkspaceRoot, catalogVersion);
-        const attemptAvailable = !(await fs.pathExists(attemptPath));
-        if (!attemptAvailable && options.failOnUnavailable) {
-            throw new CatalogPublicationInspectionError('attemptUnavailable', `Catalog ${catalogVersion} already has an attempted publication record. Run aw catalog version <higher> before publishing again.`);
-        }
-        if (options.remoteUrl !== undefined) {
-            fetchUrl = assertSafeRemoteUrl(options.remoteUrl);
-            pushUrl = fetchUrl;
-        }
-        else {
-            fetchUrl = await publicationGit(repoRoot, ['remote', 'get-url', remote], env, 'remoteMissing', `Git remote ${JSON.stringify(remote)} is not configured.`);
-            pushUrl = await publicationGit(repoRoot, ['remote', 'get-url', '--push', remote], env, 'remoteMissing', `Git remote ${JSON.stringify(remote)} has no push URL.`);
-        }
-        safeFetchUrl = safeRemoteIdentity(fetchUrl);
-        safePushUrl = safeRemoteIdentity(pushUrl);
         const remoteIdentityDigest = digest(JSON.stringify({ fetchUrl, pushUrl }));
         const branchRef = `refs/heads/${branch}`;
         const tagRef = `refs/tags/${tag}`;
         const repositoryRoot = path.join(temporaryRoot, 'repository');
         await fs.ensureDir(repositoryRoot);
         await publicationGit(repositoryRoot, ['init', '--quiet'], env, 'temporaryRepositoryFailed', 'Could not create the isolated publication repository.');
-        await publicationGit(repositoryRoot, ['config', 'core.hooksPath', path.join(temporaryRoot, 'disabled-hooks')], env, 'temporaryRepositoryFailed', 'Could not disable publication hooks.');
+        await publicationGit(repositoryRoot, ['config', 'core.hooksPath', '/dev/null'], env, 'temporaryRepositoryFailed', 'Could not disable publication hooks.');
         await publicationGit(repositoryRoot, ['config', 'core.symlinks', 'true'], env, 'temporaryRepositoryFailed', 'Could not configure the isolated publication repository.');
         await publicationGit(repositoryRoot, ['remote', 'add', 'publish', pushUrl], env, 'temporaryRepositoryFailed', 'Could not configure the publication remote.');
         const initialRefs = parseRemoteRefs(await publicationGit(repositoryRoot, [
             'ls-remote', 'publish', branchRef, tagRef, `${tagRef}^{}`,
         ], env, 'remoteReadFailed', 'Could not inspect the Catalog publication remote.'));
         const tagAvailable = !initialRefs.has(tagRef) && !initialRefs.has(`${tagRef}^{}`);
-        if (!tagAvailable && options.failOnUnavailable) {
-            throw new CatalogPublicationInspectionError('tagUnavailable', `Remote Catalog tag ${tag} already exists. Increase the Catalog version.`);
-        }
         const parent = initialRefs.get(branchRef) ?? null;
         let previousSnapshotRoot;
-        let publishedVersion = null;
+        let historicalPluginEntries = [];
         if (parent) {
             await publicationGit(repositoryRoot, [
                 'fetch', '--quiet', '--no-tags', 'publish', `${branchRef}:refs/aw/catalog-parent`,
@@ -260,14 +449,23 @@ export async function prepareCatalogPublicationInspection(options) {
             previousSnapshotRoot = path.join(temporaryRoot, 'previous');
             await fs.ensureDir(previousSnapshotRoot);
             await publicationGit(repositoryRoot, [
+                '-c', 'core.autocrlf=false', '-c', 'core.eol=lf',
                 '--work-tree', previousSnapshotRoot, 'checkout', '--quiet', 'refs/aw/catalog-parent', '--', '.',
             ], env, 'remoteBranchInvalid', 'Could not read the published Catalog snapshot.');
-            try {
-                const previous = await validatePublishedCatalogSnapshot(previousSnapshotRoot);
-                publishedVersion = previous.manifest.catalogVersion;
-            }
-            catch (error) {
-                throw inspectionError('remoteSnapshotInvalid', error);
+            const previous = await validatePublishedCatalogSnapshotForWorkspace(previousSnapshotRoot, catalogWorkspace.workspaceIdentity);
+            const previousPluginNames = new Set(previous.manifest.entries.map((entry) => entry.name));
+            const missingPluginNames = catalogWorkspace.plugins
+                .map((plugin) => plugin.manifest.name)
+                .filter((name) => !previousPluginNames.has(name));
+            if (missingPluginNames.length > 0) {
+                historicalPluginEntries = await findPreviousPluginEntriesInFirstParentHistory({
+                    repositoryRoot,
+                    tipCommit: parent,
+                    pluginNames: missingPluginNames,
+                    workspaceIdentity: catalogWorkspace.workspaceIdentity,
+                    temporaryRoot,
+                    env,
+                });
             }
         }
         let prepared;
@@ -276,6 +474,9 @@ export async function prepareCatalogPublicationInspection(options) {
                 workspaceRoot: archivedCatalogWorkspaceRoot,
                 sourceHead,
                 previousSnapshotRoot,
+                historicalPluginEntries,
+                officialPluginHistory: options.officialPluginHistory,
+                sourcePluginVersionsAtBaseline: options.sourcePluginVersionsAtBaseline,
                 adapter: publicationBuildAdapter,
                 reservedImports: CLI_RESERVED_IMPORTS,
             });
@@ -298,16 +499,10 @@ export async function prepareCatalogPublicationInspection(options) {
             || finalRefs.has(`${tagRef}^{}`) !== initialRefs.has(`${tagRef}^{}`)) {
             throw new CatalogPublicationInspectionError('remoteDrift', 'Catalog remote changed during preparation. Increase the Catalog version before publishing again.');
         }
-        const [preparedValidation, ledgerBytes] = await Promise.all([
-            validatePublishedCatalogSnapshot(prepared.outputRoot),
-            fs.readFile(path.join(prepared.outputRoot, 'plugin-release-ledger.json')),
-        ]);
-        const ledgerDigest = digest(ledgerBytes);
+        await validatePublishedCatalogSnapshot(prepared.outputRoot);
         const descriptor = {
             schemaVersion: 1,
             workspaceIdentity: catalogWorkspace.workspaceIdentity,
-            catalogVersion: prepared.catalogVersion,
-            channel: prepared.channel,
             sourceHead,
             remote: {
                 name: options.remoteUrl === undefined ? remote : null,
@@ -317,11 +512,6 @@ export async function prepareCatalogPublicationInspection(options) {
             parent,
             tag,
             snapshotDigest: prepared.snapshotDigest,
-            contentDigest: prepared.contentDigest,
-            planId: prepared.planId,
-            ledgerDigest,
-            minCliVersion: preparedValidation.manifest.compatibility.aw.minVersion,
-            pluginNames: [...prepared.pluginNames],
         };
         return {
             temporaryRoot,
@@ -341,9 +531,6 @@ export async function prepareCatalogPublicationInspection(options) {
             safePushUrl,
             remoteIdentityDigest,
             parent,
-            publishedVersion,
-            attemptPath,
-            attemptAvailable,
             tagAvailable,
             catalogWorkspace,
             prepared,
@@ -367,6 +554,162 @@ export async function prepareCatalogPublicationInspection(options) {
         throw new CatalogPublicationInspectionError('catalogPreflightFailed', safeMessage, { cause: error });
     }
 }
+export async function inspectCatalogPublicationLiveContext(options) {
+    if (options.remote !== undefined && options.remoteUrl !== undefined) {
+        throw new CatalogPublicationInspectionError('remoteInvalid', 'Catalog publication accepts a configured remote name or a direct remote URL, not both.');
+    }
+    const remote = options.remoteUrl === undefined
+        ? assertSafeRemoteName(options.remote ?? 'origin')
+        : 'direct';
+    const remoteName = options.remoteUrl === undefined ? remote : null;
+    const branch = assertSafeBranchValue(options.branch ?? 'catalog');
+    const env = options.remoteUrl === undefined
+        ? sanitizedGitEnvironment(options.env)
+        : directRemoteGitEnvironment(options.env);
+    let fetchUrl = '';
+    let pushUrl = '';
+    let safeFetchUrl = '';
+    let safePushUrl = '';
+    try {
+        const catalogWorkspaceRoot = await realpath(path.resolve(options.workspaceRoot));
+        const repoRoot = await realpath(await publicationGit(catalogWorkspaceRoot, ['rev-parse', '--show-toplevel'], env, 'gitWorkspaceInvalid', 'Catalog Workspace must be inside a real Git worktree.'));
+        await publicationGit(repoRoot, ['check-ref-format', '--branch', branch], env, 'branchInvalid', 'Invalid Catalog publication branch name.');
+        const sourceHead = await publicationGit(repoRoot, ['rev-parse', '--verify', 'HEAD'], env, 'sourceHeadMissing', 'Catalog Workspace Git HEAD must be committed and not unborn.');
+        const status = await publicationGit(repoRoot, [
+            'status', '--porcelain=v1', '--untracked-files=all', '--ignore-submodules=none',
+        ], env, 'sourceStatusFailed', 'Could not inspect the source worktree.');
+        if (status !== '') {
+            throw new CatalogPublicationInspectionError('sourceDirty', 'Catalog publish requires the complete source Git worktree to be clean.');
+        }
+        const catalogWorkspaceRelative = path.relative(repoRoot, catalogWorkspaceRoot);
+        if (catalogWorkspaceRelative === '..'
+            || catalogWorkspaceRelative.startsWith(`..${path.sep}`)
+            || path.isAbsolute(catalogWorkspaceRelative)) {
+            throw new CatalogPublicationInspectionError('workspaceOutsideRepository', 'Catalog Workspace must stay inside its Git worktree root.');
+        }
+        const catalogWorkspace = await readCatalogWorkspace(catalogWorkspaceRoot, {
+            reservedImports: CLI_RESERVED_IMPORTS,
+        });
+        const ownerUrl = catalogWorkspace.metadata.owner.url;
+        if (URL.canParse(ownerUrl) && new URL(ownerUrl).hostname === 'example.invalid') {
+            throw new CatalogPublicationInspectionError('catalogMetadataIncomplete', 'Catalog owner URL still uses the example.invalid placeholder. Set plugins/marketplace-source.json owner.url before publication.');
+        }
+        if (options.remoteUrl !== undefined) {
+            fetchUrl = assertSafeRemoteUrl(options.remoteUrl);
+            pushUrl = fetchUrl;
+        }
+        else {
+            const configuredRemotes = (await publicationGit(repoRoot, ['remote'], env, 'remoteMissing', 'Could not inspect configured Git remotes.')).split('\n').filter(Boolean);
+            if (!configuredRemotes.includes(remote)) {
+                throw new CatalogPublicationInspectionError('remoteInvalid', `Git remote ${JSON.stringify(remote)} is not configured.`);
+            }
+            fetchUrl = assertSafeRemoteUrl(await publicationGit(repoRoot, ['remote', 'get-url', remote], env, 'remoteMissing', `Git remote ${JSON.stringify(remote)} is not configured.`), { allowCredentials: true });
+            pushUrl = assertSafeRemoteUrl(await publicationGit(repoRoot, ['remote', 'get-url', '--push', remote], env, 'remoteMissing', `Git remote ${JSON.stringify(remote)} has no push URL.`), { allowCredentials: true });
+        }
+        safeFetchUrl = safeRemoteIdentity(fetchUrl);
+        safePushUrl = safeRemoteIdentity(pushUrl);
+        const catalogVersion = catalogWorkspace.metadata.catalog.version;
+        const tag = `catalog-v${catalogVersion}`;
+        await publicationGit(repoRoot, ['check-ref-format', `refs/tags/${tag}`], env, 'tagInvalid', 'Invalid Catalog publication tag.');
+        return {
+            catalogWorkspaceRoot,
+            repoRoot,
+            workspaceIdentity: catalogWorkspace.workspaceIdentity,
+            catalogVersion,
+            sourceHead,
+            remote,
+            remoteName,
+            branch,
+            branchRef: `refs/heads/${branch}`,
+            tag,
+            tagRef: `refs/tags/${tag}`,
+            fetchUrl,
+            pushUrl,
+            safeFetchUrl,
+            safePushUrl,
+            remoteIdentityDigest: digest(JSON.stringify({ fetchUrl, pushUrl })),
+            env,
+        };
+    }
+    catch (error) {
+        let safeMessage = error instanceof Error ? error.message : String(error);
+        if (fetchUrl)
+            safeMessage = safeMessage.replaceAll(fetchUrl, safeFetchUrl);
+        if (pushUrl)
+            safeMessage = safeMessage.replaceAll(pushUrl, safePushUrl);
+        if (error instanceof CatalogPublicationInspectionError) {
+            throw new CatalogPublicationInspectionError(error.code, safeMessage, { cause: error.cause });
+        }
+        throw new CatalogPublicationInspectionError('catalogInspectionFailed', safeMessage, { cause: error });
+    }
+}
+export async function inspectCatalogPublicationApplyContext(options) {
+    if (options.remote !== undefined && options.remoteUrl !== undefined) {
+        throw new CatalogPublicationInspectionError('remoteInvalid', 'Catalog publication accepts a configured remote name or a direct remote URL, not both.');
+    }
+    const remote = options.remoteUrl === undefined
+        ? assertSafeRemoteName(options.remote ?? 'origin')
+        : 'direct';
+    const branch = assertSafeBranchValue(options.branch ?? 'catalog');
+    const env = options.remoteUrl === undefined
+        ? sanitizedGitEnvironment(options.env)
+        : directRemoteGitEnvironment(options.env);
+    let fetchUrl = '';
+    let pushUrl = '';
+    let safeFetchUrl = '';
+    let safePushUrl = '';
+    try {
+        const catalogWorkspaceRoot = await realpath(path.resolve(options.workspaceRoot));
+        const marker = await readCatalogWorkspaceMarker(catalogWorkspaceRoot);
+        const repoRoot = await realpath(await publicationGit(catalogWorkspaceRoot, ['rev-parse', '--show-toplevel'], env, 'gitWorkspaceInvalid', 'Catalog Workspace must be inside a real Git worktree.'));
+        const catalogWorkspaceRelative = path.relative(repoRoot, catalogWorkspaceRoot);
+        if (catalogWorkspaceRelative === '..'
+            || catalogWorkspaceRelative.startsWith(`..${path.sep}`)
+            || path.isAbsolute(catalogWorkspaceRelative)) {
+            throw new CatalogPublicationInspectionError('workspaceOutsideRepository', 'Catalog Workspace must stay inside its Git worktree root.');
+        }
+        await publicationGit(repoRoot, ['check-ref-format', '--branch', branch], env, 'branchInvalid', 'Invalid Catalog publication branch name.');
+        if (options.remoteUrl !== undefined) {
+            fetchUrl = assertSafeRemoteUrl(options.remoteUrl);
+            pushUrl = fetchUrl;
+        }
+        else {
+            const configuredRemotes = (await publicationGit(repoRoot, ['remote'], env, 'remoteMissing', 'Could not inspect configured Git remotes.')).split('\n').filter(Boolean);
+            if (!configuredRemotes.includes(remote)) {
+                throw new CatalogPublicationInspectionError('remoteInvalid', `Git remote ${JSON.stringify(remote)} is not configured.`);
+            }
+            fetchUrl = assertSafeRemoteUrl(await publicationGit(repoRoot, ['remote', 'get-url', remote], env, 'remoteMissing', `Git remote ${JSON.stringify(remote)} is not configured.`), { allowCredentials: true });
+            pushUrl = assertSafeRemoteUrl(await publicationGit(repoRoot, ['remote', 'get-url', '--push', remote], env, 'remoteMissing', `Git remote ${JSON.stringify(remote)} has no push URL.`), { allowCredentials: true });
+        }
+        safeFetchUrl = safeRemoteIdentity(fetchUrl);
+        safePushUrl = safeRemoteIdentity(pushUrl);
+        return {
+            catalogWorkspaceRoot,
+            repoRoot,
+            workspaceIdentity: marker.workspaceIdentity,
+            remote,
+            branch,
+            branchRef: `refs/heads/${branch}`,
+            fetchUrl,
+            pushUrl,
+            safeFetchUrl,
+            safePushUrl,
+            remoteIdentityDigest: digest(JSON.stringify({ fetchUrl, pushUrl })),
+            env,
+        };
+    }
+    catch (error) {
+        let safeMessage = error instanceof Error ? error.message : String(error);
+        if (fetchUrl)
+            safeMessage = safeMessage.replaceAll(fetchUrl, safeFetchUrl);
+        if (pushUrl)
+            safeMessage = safeMessage.replaceAll(pushUrl, safePushUrl);
+        if (error instanceof CatalogPublicationInspectionError) {
+            throw new CatalogPublicationInspectionError(error.code, safeMessage, { cause: error.cause });
+        }
+        throw new CatalogPublicationInspectionError('catalogInspectionFailed', safeMessage, { cause: error });
+    }
+}
 async function resolveRemoteUrlForInspection(options) {
     if (options.remote !== undefined && options.remoteUrl !== undefined) {
         throw new CatalogPublicationInspectionError('remoteInvalid', 'Catalog publication accepts a configured remote name or a direct remote URL, not both.');
@@ -377,21 +720,22 @@ async function resolveRemoteUrlForInspection(options) {
     if (options.remoteUrl !== undefined) {
         return { remoteUrl: assertSafeRemoteUrl(options.remoteUrl), env };
     }
-    const remote = options.remote ?? 'origin';
+    const remote = assertSafeRemoteName(options.remote ?? 'origin');
     return {
-        remoteUrl: await publicationGit(options.workspaceRoot, ['remote', 'get-url', '--push', remote], env, 'remoteMissing', `Git remote ${JSON.stringify(remote)} has no push URL.`),
+        remoteUrl: assertSafeRemoteUrl(await publicationGit(options.workspaceRoot, ['remote', 'get-url', '--push', remote], env, 'remoteMissing', `Git remote ${JSON.stringify(remote)} has no push URL.`), { allowCredentials: true }),
         env,
     };
 }
 export async function listCatalogPublicationVersions(options) {
     const resolved = await resolveRemoteUrlForInspection(options);
+    const sensitiveValues = remoteSensitiveValues(resolved.remoteUrl);
     const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aw-catalog-remote-read-'));
     try {
         await publicationGit(temporaryRoot, ['init', '--quiet'], resolved.env, 'temporaryRepositoryFailed', 'Could not create the Catalog inspection repository.');
         await publicationGit(temporaryRoot, ['remote', 'add', 'publish', resolved.remoteUrl], resolved.env, 'temporaryRepositoryFailed', 'Could not configure the Catalog inspection remote.');
         const refs = parseRemoteRefs(await publicationGit(temporaryRoot, [
             'ls-remote', '--refs', 'publish', 'refs/tags/catalog-v*',
-        ], resolved.env, 'remoteReadFailed', 'Could not inspect Catalog publication versions.'));
+        ], resolved.env, 'remoteReadFailed', 'Could not inspect Catalog publication versions.', sensitiveValues));
         return [...refs.keys()]
             .filter((ref) => ref.startsWith('refs/tags/catalog-v'))
             .map((ref) => ref.slice('refs/tags/catalog-v'.length));
@@ -400,7 +744,75 @@ export async function listCatalogPublicationVersions(options) {
         await fs.remove(temporaryRoot);
     }
 }
+export async function readCatalogPublicationPluginHistory(options) {
+    const marker = await readCatalogWorkspaceMarker(options.workspaceRoot);
+    const resolved = await resolveRemoteUrlForInspection(options);
+    const branchRefs = [...new Set(options.branches.map((branch) => `refs/heads/${assertSafeBranchValue(branch)}`))];
+    if (branchRefs.length === 0)
+        throw new Error('Catalog Plugin history requires at least one branch.');
+    const sensitiveValues = remoteSensitiveValues(resolved.remoteUrl);
+    const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aw-catalog-plugin-history-'));
+    try {
+        await publicationGit(temporaryRoot, ['init', '--quiet'], resolved.env, 'temporaryRepositoryFailed', 'Could not create the Catalog history repository.');
+        await publicationGit(temporaryRoot, ['remote', 'add', 'publish', resolved.remoteUrl], resolved.env, 'temporaryRepositoryFailed', 'Could not configure the Catalog history remote.');
+        const refs = parseRemoteRefs(await publicationGit(temporaryRoot, [
+            'ls-remote', 'publish', ...branchRefs,
+        ], resolved.env, 'remoteReadFailed', 'Could not inspect published Catalog history.', sensitiveValues));
+        const visited = new Set();
+        const entries = [];
+        const metadataRoot = path.join(temporaryRoot, 'history-metadata');
+        for (const [index, branchRef] of branchRefs.entries()) {
+            const tip = refs.get(branchRef);
+            if (!tip)
+                continue;
+            const localRef = `refs/aw/catalog-history-${index}`;
+            await publicationGit(temporaryRoot, [
+                'fetch', '--quiet', '--no-tags', 'publish', `${branchRef}:${localRef}`,
+            ], resolved.env, 'remoteBranchInvalid', 'Could not fetch published Catalog history.', sensitiveValues);
+            const fetchedTip = await publicationGit(temporaryRoot, ['rev-parse', localRef], resolved.env, 'remoteBranchInvalid', 'Could not inspect published Catalog history.');
+            if (fetchedTip !== tip) {
+                throw new CatalogPublicationInspectionError('remoteDrift', 'Catalog history changed during inspection. Retry preparation.');
+            }
+            const commits = (await publicationGit(temporaryRoot, [
+                'rev-list', '--first-parent', tip,
+            ], resolved.env, 'remoteBranchInvalid', 'Could not inspect published Catalog history.')).split('\n').filter(Boolean);
+            for (const commit of commits) {
+                if (visited.has(commit))
+                    continue;
+                visited.add(commit);
+                await materializePublishedCatalogMetadata({
+                    repositoryRoot: temporaryRoot,
+                    commit,
+                    outputRoot: metadataRoot,
+                    env: resolved.env,
+                });
+                try {
+                    const metadata = await validatePublishedCatalogSnapshotMetadata(metadataRoot);
+                    if (metadata.workspaceIdentity !== marker.workspaceIdentity) {
+                        throw new Error('Published Catalog snapshot belongs to a different Workspace identity.');
+                    }
+                    entries.push(...metadata.manifest.entries);
+                }
+                catch (error) {
+                    throw inspectionError('remoteSnapshotInvalid', error);
+                }
+            }
+        }
+        const finalRefs = parseRemoteRefs(await publicationGit(temporaryRoot, [
+            'ls-remote', 'publish', ...branchRefs,
+        ], resolved.env, 'remoteReadFailed', 'Could not recheck published Catalog history.', sensitiveValues));
+        if (branchRefs.some((ref) => refs.get(ref) !== finalRefs.get(ref))) {
+            throw new CatalogPublicationInspectionError('remoteDrift', 'Catalog history changed during inspection. Retry preparation.');
+        }
+        return entries;
+    }
+    finally {
+        await fs.remove(temporaryRoot);
+    }
+}
 export async function readCatalogPublicationBranchState(options) {
+    assertSafeBranchValue(options.branch);
+    const marker = await readCatalogWorkspaceMarker(options.workspaceRoot);
     const resolved = await resolveRemoteUrlForInspection(options);
     const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aw-catalog-remote-read-'));
     try {
@@ -423,14 +835,14 @@ export async function readCatalogPublicationBranchState(options) {
         const snapshotRoot = path.join(temporaryRoot, 'snapshot');
         await fs.ensureDir(snapshotRoot);
         await publicationGit(temporaryRoot, [
+            '-c', 'core.autocrlf=false', '-c', 'core.eol=lf',
             '--work-tree', snapshotRoot, 'checkout', '--quiet', 'refs/aw/catalog-parent', '--', '.',
         ], resolved.env, 'remoteBranchInvalid', 'Could not read the published Catalog snapshot.');
-        const validation = await validatePublishedCatalogSnapshot(snapshotRoot);
+        const validation = await validatePublishedCatalogSnapshotForWorkspace(snapshotRoot, marker.workspaceIdentity);
         return {
             commit,
             version: validation.manifest.catalogVersion,
             manifest: validation.manifest,
-            ledger: validation.ledger,
             snapshotDigest: validation.snapshotDigest,
         };
     }