@git.zone/cli 4.0.0 → 6.0.0

package/dist_ts/mod_release/helpers.npmartifact.d.ts

@@ -0,0 +1,32 @@
+import * as plugins from "./mod.plugins.js";
+import { type IReleaseArtifact } from "./classes.releasejournal.js";
+declare const supportedPnpmVersion = "11.21.0";
+export interface IPnpmReleaseCapability {
+    version: typeof supportedPnpmVersion;
+}
+export type TNpmArtifactProbeStatus = "absent" | "exact" | "conflict" | "inconclusive";
+export interface INpmArtifactProbeResult {
+    status: TNpmArtifactProbeStatus;
+    code: "absent" | "exact" | "metadata-conflict" | "tarball-conflict" | "tag-conflict" | "registry-response" | "network-error";
+}
+export interface INpmArtifactProbeOptions {
+    fetchImplementation?: typeof fetch;
+    timeoutMs?: number;
+    attempts?: number;
+    delayMs?: number;
+}
+export declare const assertPnpmReleaseCapability: (smartshellArg: plugins.smartshell.Smartshell, cwdArg: string) => Promise<IPnpmReleaseCapability>;
+export declare const assertNoLegacyNpmPublisher: (cwdArg: string) => Promise<void>;
+export declare const normalizeNpmRegistryUrl: (valueArg: string) => string;
+export declare const hashReleaseDestination: (valueArg: string) => string;
+export declare const calculateNpmArtifact: (artifactPathArg: string, packageNameArg: string, versionArg: string) => Promise<IReleaseArtifact>;
+export declare const packNpmArtifact: (smartshellArg: plugins.smartshell.Smartshell, cwdArg: string, destinationDirectoryArg: string, expectedVersionArg: string) => Promise<IReleaseArtifact>;
+export declare const verifyStoredNpmArtifact: (artifactPathArg: string, expectedArtifactArg: IReleaseArtifact) => Promise<void>;
+export declare const buildPnpmPublishArgs: (artifactPathArg: string, registryArg: string) => string[];
+export declare const publishNpmArtifact: (smartshellArg: plugins.smartshell.Smartshell, cwdArg: string, artifactPathArg: string, registryArg: string) => Promise<{
+    exitCode: number;
+    output: string;
+}>;
+export declare const probeAnonymousNpmArtifact: (registryArg: string, artifactArg: IReleaseArtifact, tagArg?: string, optionsArg?: INpmArtifactProbeOptions) => Promise<INpmArtifactProbeResult>;
+export declare const waitForAnonymousNpmArtifact: (registryArg: string, artifactArg: IReleaseArtifact, tagArg?: string, optionsArg?: INpmArtifactProbeOptions) => Promise<INpmArtifactProbeResult>;
+export {};

package/dist_ts/mod_release/helpers.npmartifact.js

@@ -0,0 +1,358 @@
+import * as plugins from "./mod.plugins.js";
+import { releaseArtifactFileName, } from "./classes.releasejournal.js";
+import { assertCredentialFreeGitPushDestination } from "./helpers.releasebranch.js";
+const supportedPnpmVersion = "11.21.0";
+const maximumMetadataResponseBytes = 8 * 1024 * 1024;
+const capabilityCommandTimeoutMs = 30_000;
+const packCommandTimeoutMs = 10 * 60_000;
+const publishCommandTimeoutMs = 5 * 60_000;
+const packageNameRegex = /^(?:@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*|[a-z0-9][a-z0-9._-]*)$/;
+const readPackageIdentity = async (cwdArg) => {
+    let packageJson;
+    try {
+        packageJson = JSON.parse(await plugins.fs.readFile(plugins.path.join(cwdArg, "package.json"), "utf8"));
+    }
+    catch (error) {
+        throw new Error("Unable to read package.json for npm release packaging.", {
+            cause: error,
+        });
+    }
+    if (typeof packageJson !== "object" ||
+        packageJson === null ||
+        Array.isArray(packageJson) ||
+        typeof packageJson.name !== "string" ||
+        !packageNameRegex.test(packageJson.name) ||
+        typeof packageJson.version !== "string") {
+        throw new Error("package.json requires a canonical npm name and version.");
+    }
+    return {
+        packageName: packageJson.name,
+        version: packageJson.version,
+    };
+};
+const requireHelpFragments = (outputArg, fragmentsArg, commandArg) => {
+    const missing = fragmentsArg.filter((fragmentArg) => !outputArg.includes(fragmentArg));
+    if (missing.length > 0) {
+        throw new Error(`pnpm ${commandArg} is missing required exact-release capabilities: ${missing.join(", ")}.`);
+    }
+};
+export const assertPnpmReleaseCapability = async (smartshellArg, cwdArg) => {
+    const versionResult = await smartshellArg.execSpawn("pnpm", ["--version"], {
+        cwd: cwdArg,
+        silent: true,
+        timeout: capabilityCommandTimeoutMs,
+        timeoutKillGraceMs: 5_000,
+    });
+    const version = versionResult.stdout.trim();
+    if (versionResult.exitCode !== 0 || version !== supportedPnpmVersion) {
+        throw new Error(`Exact release packaging requires the verified pnpm ${supportedPnpmVersion}; resolved ${version || "unknown"}.`);
+    }
+    const packHelp = await smartshellArg.execSpawn("pnpm", ["pack", "--help"], {
+        cwd: cwdArg,
+        silent: true,
+        timeout: capabilityCommandTimeoutMs,
+        timeoutKillGraceMs: 5_000,
+    });
+    if (packHelp.exitCode !== 0) {
+        throw new Error("Unable to inspect pnpm pack capabilities.");
+    }
+    requireHelpFragments(packHelp.combinedOutput, ["--out <path>", "--json"], "pack");
+    const publishHelp = await smartshellArg.execSpawn("pnpm", ["publish", "--help"], {
+        cwd: cwdArg,
+        silent: true,
+        timeout: capabilityCommandTimeoutMs,
+        timeoutKillGraceMs: 5_000,
+    });
+    if (publishHelp.exitCode !== 0) {
+        throw new Error("Unable to inspect pnpm publish capabilities.");
+    }
+    requireHelpFragments(publishHelp.combinedOutput, [
+        "publish [<tarball>|<dir>]",
+        "--no-git-checks",
+        "--ignore-scripts",
+        "--json",
+        "--tag <tag>",
+        "--access <public|restricted>",
+    ], "publish");
+    return { version: supportedPnpmVersion };
+};
+const legacyPublishWorkflowPaths = [
+    ".gitea/workflows/default_tags.yaml",
+    ".gitlab-ci.yml",
+];
+export const assertNoLegacyNpmPublisher = async (cwdArg) => {
+    for (const relativePath of legacyPublishWorkflowPaths) {
+        const filePath = plugins.path.join(cwdArg, relativePath);
+        let content;
+        try {
+            content = await plugins.fs.readFile(filePath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                continue;
+            }
+            throw new Error(`Unable to inspect ${relativePath} for legacy npm publication.`, {
+                cause: error,
+            });
+        }
+        const activeContent = content
+            .split("\n")
+            .filter((lineArg) => !/^\s*#/.test(lineArg))
+            .join("\n");
+        if (/\bnpmci\s+npm\s+publish\b/.test(activeContent)) {
+            throw new Error(`${relativePath} still contains the legacy independent npm publisher. ` +
+                "Remove it or apply the Gitzone v6 Gitea workflow template, then commit the workflow change before releasing.");
+        }
+    }
+};
+export const normalizeNpmRegistryUrl = (valueArg) => {
+    if (typeof valueArg !== "string" || !valueArg.trim()) {
+        throw new Error("npm registry URLs must be non-empty strings.");
+    }
+    let url;
+    try {
+        url = new URL(valueArg.trim());
+    }
+    catch (error) {
+        throw new Error("Invalid npm registry URL.", { cause: error });
+    }
+    if ((url.protocol !== "https:" && url.protocol !== "http:") ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash) {
+        throw new Error("npm registry URLs must use credential-free http(s) without query strings or fragments.");
+    }
+    const pathname = url.pathname.replace(/\/+$/, "");
+    return `${url.origin}${pathname}`;
+};
+export const hashReleaseDestination = (valueArg) => {
+    assertCredentialFreeGitPushDestination(valueArg);
+    return plugins.crypto.createHash("sha256").update(valueArg).digest("hex");
+};
+export const calculateNpmArtifact = async (artifactPathArg, packageNameArg, versionArg) => {
+    const stat = await plugins.fs.lstat(artifactPathArg);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size <= 0) {
+        throw new Error("Release npm artifact must be a non-empty regular file.");
+    }
+    const bytes = await plugins.fs.readFile(artifactPathArg);
+    return {
+        kind: "npm-tarball",
+        file: releaseArtifactFileName,
+        packageName: packageNameArg,
+        version: versionArg,
+        size: bytes.byteLength,
+        sha1: plugins.crypto.createHash("sha1").update(bytes).digest("hex"),
+        sha256: plugins.crypto.createHash("sha256").update(bytes).digest("hex"),
+        integrity: `sha512-${plugins.crypto.createHash("sha512").update(bytes).digest("base64")}`,
+    };
+};
+const syncFile = async (filePathArg) => {
+    const handle = await plugins.fs.open(filePathArg, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+};
+export const packNpmArtifact = async (smartshellArg, cwdArg, destinationDirectoryArg, expectedVersionArg) => {
+    const identity = await readPackageIdentity(cwdArg);
+    if (identity.version !== expectedVersionArg) {
+        throw new Error(`package.json version ${identity.version} does not match release ${expectedVersionArg}.`);
+    }
+    const artifactPath = plugins.path.join(destinationDirectoryArg, releaseArtifactFileName);
+    const result = await smartshellArg.execSpawn("pnpm", ["pack", "--out", artifactPath, "--json"], {
+        cwd: cwdArg,
+        timeout: packCommandTimeoutMs,
+        timeoutKillGraceMs: 5_000,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error("pnpm pack failed while creating the exact release artifact.");
+    }
+    let report;
+    try {
+        report = JSON.parse(result.stdout.trim());
+    }
+    catch (error) {
+        throw new Error("pnpm pack did not return its required JSON report.", {
+            cause: error,
+        });
+    }
+    if (typeof report !== "object" ||
+        report === null ||
+        Array.isArray(report) ||
+        report.name !== identity.packageName ||
+        report.version !== identity.version) {
+        throw new Error("pnpm pack reported a different package identity.");
+    }
+    await syncFile(artifactPath);
+    return calculateNpmArtifact(artifactPath, identity.packageName, identity.version);
+};
+export const verifyStoredNpmArtifact = async (artifactPathArg, expectedArtifactArg) => {
+    const actual = await calculateNpmArtifact(artifactPathArg, expectedArtifactArg.packageName, expectedArtifactArg.version);
+    if (actual.size !== expectedArtifactArg.size ||
+        actual.sha1 !== expectedArtifactArg.sha1 ||
+        actual.sha256 !== expectedArtifactArg.sha256 ||
+        actual.integrity !== expectedArtifactArg.integrity) {
+        throw new Error("Stored npm artifact no longer matches its release journal identity.");
+    }
+};
+export const buildPnpmPublishArgs = (artifactPathArg, registryArg) => [
+    "publish",
+    artifactPathArg,
+    `--registry=${normalizeNpmRegistryUrl(registryArg)}`,
+    "--access=public",
+    "--tag=latest",
+    "--no-git-checks",
+    "--ignore-scripts",
+    "--json",
+];
+export const publishNpmArtifact = async (smartshellArg, cwdArg, artifactPathArg, registryArg) => {
+    const result = await smartshellArg.execSpawn("pnpm", buildPnpmPublishArgs(artifactPathArg, registryArg), {
+        cwd: cwdArg,
+        timeout: publishCommandTimeoutMs,
+        timeoutKillGraceMs: 5_000,
+    });
+    return { exitCode: result.exitCode, output: result.combinedOutput };
+};
+const getFetch = (optionsArg) => optionsArg.fetchImplementation || globalThis.fetch;
+const fetchWithoutRedirects = async (urlArg, acceptArg, optionsArg) => {
+    const timeoutMs = optionsArg.timeoutMs ?? 10_000;
+    return getFetch(optionsArg)(urlArg, {
+        method: "GET",
+        headers: { accept: acceptArg },
+        redirect: "manual",
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+};
+const cancelResponseBody = (responseArg) => {
+    if (responseArg.body && !responseArg.body.locked) {
+        void responseArg.body.cancel().catch(() => { });
+    }
+};
+const readBoundedResponse = async (responseArg, maximumSizeArg, contextArg) => {
+    const contentLength = responseArg.headers.get("content-length");
+    if (contentLength &&
+        (!/^\d+$/.test(contentLength) || Number(contentLength) > maximumSizeArg)) {
+        cancelResponseBody(responseArg);
+        throw new Error(`${contextArg} exceeds its maximum response size.`);
+    }
+    if (!responseArg.body) {
+        throw new Error(`${contextArg} response has no body.`);
+    }
+    const chunks = [];
+    let size = 0;
+    const reader = responseArg.body.getReader();
+    let complete = false;
+    try {
+        while (true) {
+            const item = await reader.read();
+            if (item.done) {
+                complete = true;
+                break;
+            }
+            size += item.value.byteLength;
+            if (size > maximumSizeArg) {
+                throw new Error(`${contextArg} exceeds its maximum response size.`);
+            }
+            chunks.push(item.value);
+        }
+    }
+    finally {
+        if (!complete) {
+            void reader.cancel().catch(() => { });
+        }
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks.map((chunkArg) => Buffer.from(chunkArg)), size);
+};
+const readBoundedJsonResponse = async (responseArg) => JSON.parse((await readBoundedResponse(responseArg, maximumMetadataResponseBytes, "Registry metadata")).toString("utf8"));
+const getMetadataUrl = (registryArg, packageNameArg, versionArg) => {
+    const encodedPackage = encodeURIComponent(packageNameArg);
+    return new URL(versionArg
+        ? `${normalizeNpmRegistryUrl(registryArg)}/${encodedPackage}/${encodeURIComponent(versionArg)}`
+        : `${normalizeNpmRegistryUrl(registryArg)}/${encodedPackage}`);
+};
+export const probeAnonymousNpmArtifact = async (registryArg, artifactArg, tagArg = "latest", optionsArg = {}) => {
+    const registry = normalizeNpmRegistryUrl(registryArg);
+    try {
+        const versionResponse = await fetchWithoutRedirects(getMetadataUrl(registry, artifactArg.packageName, artifactArg.version), "application/json", optionsArg);
+        if (versionResponse.status === 404) {
+            cancelResponseBody(versionResponse);
+            return { status: "absent", code: "absent" };
+        }
+        if (versionResponse.status !== 200) {
+            cancelResponseBody(versionResponse);
+            return { status: "inconclusive", code: "registry-response" };
+        }
+        const metadata = (await readBoundedJsonResponse(versionResponse));
+        if (metadata.name !== artifactArg.packageName ||
+            metadata.version !== artifactArg.version ||
+            metadata.dist?.integrity !== artifactArg.integrity ||
+            metadata.dist?.shasum !== artifactArg.sha1 ||
+            typeof metadata.dist?.tarball !== "string") {
+            return { status: "conflict", code: "metadata-conflict" };
+        }
+        const tarballUrl = new URL(metadata.dist.tarball);
+        const registryUrl = new URL(registry);
+        if (tarballUrl.origin !== registryUrl.origin ||
+            (tarballUrl.protocol !== "https:" && tarballUrl.protocol !== "http:") ||
+            tarballUrl.username ||
+            tarballUrl.password ||
+            tarballUrl.search ||
+            tarballUrl.hash) {
+            return { status: "conflict", code: "metadata-conflict" };
+        }
+        const tarballResponse = await fetchWithoutRedirects(tarballUrl, "application/octet-stream", optionsArg);
+        if (tarballResponse.status !== 200) {
+            cancelResponseBody(tarballResponse);
+            return { status: "inconclusive", code: "registry-response" };
+        }
+        const bytes = await readBoundedResponse(tarballResponse, artifactArg.size, "Registry tarball");
+        if (bytes.byteLength !== artifactArg.size ||
+            plugins.crypto.createHash("sha1").update(bytes).digest("hex") !==
+                artifactArg.sha1 ||
+            plugins.crypto.createHash("sha256").update(bytes).digest("hex") !==
+                artifactArg.sha256 ||
+            `sha512-${plugins.crypto.createHash("sha512").update(bytes).digest("base64")}` !==
+                artifactArg.integrity) {
+            return { status: "conflict", code: "tarball-conflict" };
+        }
+        const packageResponse = await fetchWithoutRedirects(getMetadataUrl(registry, artifactArg.packageName), "application/json", optionsArg);
+        if (packageResponse.status !== 200) {
+            cancelResponseBody(packageResponse);
+            return { status: "inconclusive", code: "registry-response" };
+        }
+        const packageMetadata = (await readBoundedJsonResponse(packageResponse));
+        if (packageMetadata["dist-tags"]?.[tagArg] !== artifactArg.version) {
+            return { status: "inconclusive", code: "tag-conflict" };
+        }
+        return { status: "exact", code: "exact" };
+    }
+    catch {
+        return { status: "inconclusive", code: "network-error" };
+    }
+};
+export const waitForAnonymousNpmArtifact = async (registryArg, artifactArg, tagArg = "latest", optionsArg = {}) => {
+    const attempts = optionsArg.attempts ?? 10;
+    const delayMs = optionsArg.delayMs ?? 1_000;
+    if (!Number.isSafeInteger(attempts) || attempts < 1) {
+        throw new Error("npm verification attempts must be a positive safe integer.");
+    }
+    let lastResult = {
+        status: "inconclusive",
+        code: "network-error",
+    };
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        lastResult = await probeAnonymousNpmArtifact(registryArg, artifactArg, tagArg, optionsArg);
+        if (lastResult.status === "exact" || lastResult.status === "conflict") {
+            return lastResult;
+        }
+        if (attempt + 1 < attempts) {
+            await plugins.smartdelay.delayFor(delayMs);
+        }
+    }
+    return lastResult;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.npmartifact.js","sourceRoot":"","sources":["../../../ts/mod_release/helpers.npmartifact.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_release/helpers.releasebranch.d.ts

@@ -0,0 +1,47 @@
+import * as plugins from "./mod.plugins.js";
+interface IGitWorktree {
+    path: string;
+    head?: string;
+    branch?: string;
+    prunable: boolean;
+}
+export interface IReleaseBranchContext {
+    sourceCwd: string;
+    sourceBranch: string;
+    sourceRef: string;
+    sourceOid: string;
+    gitRemote: string;
+    localMainOid?: string;
+    remoteMainOid?: string;
+    mainWorktreePath?: string;
+    mainWorktreeGitDir?: string;
+    pushUrl?: string;
+    mergeRequested: boolean;
+    planAncestryVerified: boolean;
+}
+export interface IIntegratedReleaseBranch {
+    releaseCwd: string;
+    pushUrl: string;
+    expectedRemoteMainOid: string;
+}
+export interface IInspectReleaseBranchOptions {
+    smartshell: TSmartshell;
+    cwd: string;
+    gitRemote: string;
+    gitTargetActive: boolean;
+    pushBranch: boolean;
+    pushTags?: boolean;
+    mergeRequested: boolean;
+    planMode: boolean;
+}
+type TSmartshell = plugins.smartshell.Smartshell;
+export declare const releaseGitEnv: NodeJS.ProcessEnv;
+export declare const assertCredentialFreeGitPushDestination: (valueArg: string) => void;
+export declare function resolveReleaseMergeFlag(argvArg: Record<string, unknown>): boolean;
+export declare function parseGitWorktreePorcelain(outputArg: string): IGitWorktree[];
+export declare function inspectReleaseBranch(optionsArg: IInspectReleaseBranchOptions): Promise<IReleaseBranchContext>;
+export declare function prepareReleaseIntegration(smartshellArg: TSmartshell, contextArg: IReleaseBranchContext): Promise<IReleaseBranchContext>;
+export declare function revalidatePreparedReleaseBranch(smartshellArg: TSmartshell, contextArg: IReleaseBranchContext): Promise<void>;
+export declare function revalidateReleasePublicationState(smartshellArg: TSmartshell, contextArg: IReleaseBranchContext, expectedMainOidArg: string, expectedRemoteMainOidArg?: string): Promise<void>;
+export declare function integrateReleaseBranch(smartshellArg: TSmartshell, contextArg: IReleaseBranchContext): Promise<IIntegratedReleaseBranch>;
+export {};