@git.zone/cli 6.0.1 → 6.1.1

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

@@ -0,0 +1,60 @@
+import * as plugins from "./mod.plugins.js";
+import type { IReleaseCapabilitiesResult, IReleaseCleanupResult, IReleaseDestinationEvidence, IReleaseProbeResult, IReleasePromotionContext, IReleasePromotionResult, IReleaseQualificationRequest, IReleaseQualificationResult, IReleaseValidationResult, TReleasePromotionEvidence, TReleaseProtocolCommand } from "./mod.plugins.js";
+export type { IReleaseCapabilitiesResult, IReleaseCleanupResult, IReleaseDestinationEvidence, IReleaseProbeResult, IReleasePromotionContext, IReleasePromotionResult, IReleaseQualificationRequest, IReleaseQualificationResult, IReleaseValidationResult, TReleasePromotionEvidence, TReleaseProtocolCommand, } from "./mod.plugins.js";
+export declare const assertReleaseCleanupResult: (valueArg: unknown, requestArg: Pick<IReleaseQualificationRequest, "candidateId" | "projectId">) => IReleaseCleanupResult;
+export declare const assertReleasePromotionEvidence: (valueArg: unknown, requestArg: IReleaseQualificationRequest, contextArg: IReleasePromotionContext) => TReleasePromotionEvidence;
+export declare const assertReleaseProbeResult: (valueArg: unknown, requestArg: IReleaseQualificationRequest, contextArg: IReleasePromotionContext) => IReleaseProbeResult;
+export declare const assertReleasePromotionResult: (valueArg: unknown, requestArg: IReleaseQualificationRequest, contextArg: IReleasePromotionContext) => IReleasePromotionResult;
+export declare const assertReleaseQualificationRequest: (valueArg: unknown) => IReleaseQualificationRequest;
+export declare const assertReleaseQualificationResult: (valueArg: unknown, requestArg: IReleaseQualificationRequest) => IReleaseQualificationResult;
+export declare const canonicalReleaseJson: (valueArg: unknown) => string;
+export declare const canonicalReleaseJsonDocument: (valueArg: unknown) => string;
+export declare const classifyReleasePromotionEvidence: (evidenceArg: TReleasePromotionEvidence) => "exact" | "pending" | "conflict" | "inconclusive";
+export declare const createReleaseProjectId: (cwdArg: string) => string;
+export declare const createReleasePromotionId: (candidateIdArg: string, imageIdArg: string, destinationArg: Pick<IReleaseDestinationEvidence, "registry" | "repository" | "alias">) => string;
+export declare const createReleaseQualificationRequest: (optionsArg: import("@git.zone/tsdocker/dist_ts/interfaces/index.js").ICreateReleaseQualificationRequestOptions) => IReleaseQualificationRequest;
+export declare const getReleasePromotionContexts: (resultArg: IReleaseQualificationResult) => IReleasePromotionContext[];
+export declare class TsdockerReleaseCommandError extends Error {
+    readonly command: TReleaseProtocolCommand;
+    readonly code: string;
+    constructor(command: TReleaseProtocolCommand, code: string, messageArg: string);
+}
+export declare class TsdockerReleaseRequestCleanupError extends Error {
+    readonly command: TReleaseProtocolCommand;
+    readonly requestPath: string;
+    readonly commandError: unknown | undefined;
+    readonly result: unknown | undefined;
+    readonly cleanupError: unknown;
+    reclamationError: unknown | undefined;
+    constructor(command: TReleaseProtocolCommand, requestPath: string, commandError: unknown | undefined, result: unknown | undefined, cleanupError: unknown);
+}
+export interface ITsdockerReleaseClient {
+    assertCapabilities: () => Promise<IReleaseCapabilitiesResult>;
+    validate: (requestArg: IReleaseQualificationRequest, requestDirectoryArg?: string) => Promise<IReleaseValidationResult>;
+    qualify: (requestArg: IReleaseQualificationRequest, requestDirectoryArg: string, requestOwnerIdArg: string) => Promise<IReleaseQualificationResult>;
+    probe: (requestArg: IReleaseQualificationRequest, contextArg: IReleasePromotionContext, requestDirectoryArg?: string, requestOwnerIdArg?: string) => Promise<IReleaseProbeResult>;
+    promote: (requestArg: IReleaseQualificationRequest, contextArg: IReleasePromotionContext, requestDirectoryArg: string, requestOwnerIdArg: string) => Promise<IReleasePromotionResult>;
+    cleanup: (requestArg: IReleaseQualificationRequest, requestDirectoryArg: string, requestOwnerIdArg: string) => Promise<IReleaseCleanupResult>;
+    reclaimRequestFiles: (requestDirectoryArg: string, retiredOwnerIdsArg: string[]) => Promise<void>;
+}
+export declare class TsdockerReleaseClient implements ITsdockerReleaseClient {
+    private readonly smartshell;
+    private readonly binaryPath;
+    private readonly cwd;
+    private readonly packageJsonPath;
+    constructor(smartshell: plugins.smartshell.Smartshell, cwdArg: string);
+    assertCapabilities(): Promise<IReleaseCapabilitiesResult>;
+    validate(requestArg: IReleaseQualificationRequest, requestDirectoryArg?: string): Promise<IReleaseValidationResult>;
+    qualify(requestArg: IReleaseQualificationRequest, requestDirectoryArg: string, requestOwnerIdArg: string): Promise<IReleaseQualificationResult>;
+    probe(requestArg: IReleaseQualificationRequest, contextArg: IReleasePromotionContext, requestDirectoryArg?: string, requestOwnerIdArg?: string): Promise<IReleaseProbeResult>;
+    promote(requestArg: IReleaseQualificationRequest, contextArg: IReleasePromotionContext, requestDirectoryArg: string, requestOwnerIdArg: string): Promise<IReleasePromotionResult>;
+    cleanup(requestArg: IReleaseQualificationRequest, requestDirectoryArg: string, requestOwnerIdArg: string): Promise<IReleaseCleanupResult>;
+    reclaimRequestFiles(requestDirectoryArg: string, retiredOwnerIdsArg: string[]): Promise<void>;
+    private readInstalledVersion;
+    private assertRequestForProject;
+    private assertPromotionInvocation;
+    private createPromotionRequest;
+    private assertRequestDirectory;
+    private runWithTemporaryRequestDirectory;
+    private run;
+}

package/dist_ts/mod_release/helpers.tsdockerprotocol.js

@@ -0,0 +1,442 @@
+import * as plugins from "./mod.plugins.js";
+import { getProjectTsdockerBinPath } from "../helpers.tsdocker.js";
+import { supportsTsdockerMinimumVersion } from "../helpers.workflow.js";
+export const assertReleaseCleanupResult = plugins.tsdockerReleaseProtocol.assertReleaseCleanupResult;
+export const assertReleasePromotionEvidence = plugins.tsdockerReleaseProtocol.assertReleasePromotionEvidence;
+export const assertReleaseProbeResult = plugins.tsdockerReleaseProtocol.assertReleaseProbeResult;
+export const assertReleasePromotionResult = plugins.tsdockerReleaseProtocol.assertReleasePromotionResult;
+export const assertReleaseQualificationRequest = plugins.tsdockerReleaseProtocol.assertReleaseQualificationRequest;
+export const assertReleaseQualificationResult = plugins.tsdockerReleaseProtocol.assertReleaseQualificationResult;
+export const canonicalReleaseJson = plugins.tsdockerReleaseProtocol.canonicalReleaseJson;
+export const canonicalReleaseJsonDocument = plugins.tsdockerReleaseProtocol.canonicalReleaseJsonDocument;
+export const classifyReleasePromotionEvidence = plugins.tsdockerReleaseProtocol.classifyReleasePromotionEvidence;
+export const createReleaseProjectId = plugins.tsdockerReleaseProtocol.createReleaseProjectId;
+export const createReleasePromotionId = plugins.tsdockerReleaseProtocol.createReleasePromotionId;
+export const createReleaseQualificationRequest = plugins.tsdockerReleaseProtocol.createReleaseQualificationRequest;
+export const getReleasePromotionContexts = plugins.tsdockerReleaseProtocol.getReleasePromotionContexts;
+const responseByteLimit = 1024 * 1024;
+const requestByteLimit = 64 * 1024;
+const packageJsonByteLimit = 64 * 1024;
+const requestOwnerIdPattern = /^[a-f0-9]{32}$/;
+const requestFilePattern = /^\.tsdocker-request\.([a-f0-9]{32})\.(release-(?:validate|qualify|probe|promote|cleanup))\.([a-f0-9]{24})\.json$/;
+const minimumReleaseVersion = [3, 5, 1];
+const commandTimeouts = {
+    "release-capabilities": 30_000,
+    "release-validate": 2 * 60_000,
+    "release-qualify": 6 * 60 * 60_000,
+    "release-probe": 5 * 60_000,
+    "release-promote": 2 * 60 * 60_000,
+    "release-cleanup": 10 * 60_000,
+};
+const isPlainObject = (valueArg) => typeof valueArg === "object" && valueArg !== null && !Array.isArray(valueArg);
+export class TsdockerReleaseCommandError extends Error {
+    command;
+    code;
+    constructor(command, code, messageArg) {
+        super(messageArg);
+        this.command = command;
+        this.code = code;
+        this.name = "TsdockerReleaseCommandError";
+    }
+}
+export class TsdockerReleaseRequestCleanupError extends Error {
+    command;
+    requestPath;
+    commandError;
+    result;
+    cleanupError;
+    reclamationError;
+    constructor(command, requestPath, commandError, result, cleanupError) {
+        super(`tSDocker ${command} request cleanup failed.`);
+        this.command = command;
+        this.requestPath = requestPath;
+        this.commandError = commandError;
+        this.result = result;
+        this.cleanupError = cleanupError;
+        this.name = "TsdockerReleaseRequestCleanupError";
+        this.reclamationError = undefined;
+    }
+}
+const parseProtocolOutput = (resultArg, commandArg) => {
+    if (resultArg.timedOut) {
+        throw new TsdockerReleaseCommandError(commandArg, "COMMAND_TIMEOUT", `tSDocker ${commandArg} timed out with an unresolved outcome.`);
+    }
+    if (resultArg.signal) {
+        throw new TsdockerReleaseCommandError(commandArg, "COMMAND_SIGNALLED", `tSDocker ${commandArg} was terminated with an unresolved outcome.`);
+    }
+    if (resultArg.stderr !== "") {
+        throw new TsdockerReleaseCommandError(commandArg, "INVALID_PROTOCOL_OUTPUT", `tSDocker ${commandArg} wrote non-protocol stderr output.`);
+    }
+    if (Buffer.byteLength(resultArg.stdout) > responseByteLimit ||
+        !resultArg.stdout.endsWith("\n")) {
+        throw new TsdockerReleaseCommandError(commandArg, "INVALID_PROTOCOL_OUTPUT", `tSDocker ${commandArg} returned an invalid response envelope.`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(resultArg.stdout);
+    }
+    catch {
+        throw new TsdockerReleaseCommandError(commandArg, "INVALID_PROTOCOL_OUTPUT", `tSDocker ${commandArg} returned invalid JSON.`);
+    }
+    if (canonicalReleaseJsonDocument(parsed) !== resultArg.stdout) {
+        throw new TsdockerReleaseCommandError(commandArg, "INVALID_PROTOCOL_OUTPUT", `tSDocker ${commandArg} returned noncanonical JSON.`);
+    }
+    if (resultArg.exitCode !== 0) {
+        try {
+            const protocolError = plugins.tsdockerReleaseProtocol.assertReleaseErrorResult(parsed, commandArg);
+            throw new TsdockerReleaseCommandError(commandArg, protocolError.error.code, protocolError.error.message);
+        }
+        catch (error) {
+            if (error instanceof TsdockerReleaseCommandError)
+                throw error;
+            throw new TsdockerReleaseCommandError(commandArg, "INVALID_PROTOCOL_OUTPUT", `tSDocker ${commandArg} failed without a valid protocol error.`);
+        }
+    }
+    if (isPlainObject(parsed) &&
+        parsed.kind === "tsdocker-release-error-result") {
+        throw new TsdockerReleaseCommandError(commandArg, "INVALID_PROTOCOL_OUTPUT", `tSDocker ${commandArg} returned an error result with exit code 0.`);
+    }
+    return parsed;
+};
+export class TsdockerReleaseClient {
+    smartshell;
+    binaryPath;
+    cwd;
+    packageJsonPath;
+    constructor(smartshell, cwdArg) {
+        this.smartshell = smartshell;
+        this.cwd = plugins.path.resolve(cwdArg);
+        this.binaryPath = getProjectTsdockerBinPath(this.cwd);
+        this.packageJsonPath = plugins.path.join(this.cwd, "node_modules", "@git.zone", "tsdocker", "package.json");
+    }
+    async assertCapabilities() {
+        const installedVersion = await this.readInstalledVersion();
+        await plugins.fs.access(this.binaryPath);
+        const versionResult = await this.smartshell.execSpawn(this.binaryPath, ["--version"], {
+            cwd: this.cwd,
+            maxBuffer: 4096,
+            silent: true,
+            timeout: 30_000,
+            timeoutKillGraceMs: 5_000,
+        });
+        if (versionResult.exitCode !== 0 ||
+            versionResult.timedOut ||
+            versionResult.signal ||
+            versionResult.stderr !== "" ||
+            versionResult.stdout.trim() !== installedVersion) {
+            throw new Error("Docker release journal schema 2 requires one matching project-local @git.zone/tsdocker package and binary.");
+        }
+        const parsed = await this.run("release-capabilities");
+        return plugins.tsdockerReleaseProtocol.assertReleaseCapabilitiesResult(parsed, this.cwd, {
+            requiredCommands: [
+                ...plugins.tsdockerReleaseProtocol.releaseProtocolCommands,
+            ],
+            requiredFeatures: [
+                ...plugins.tsdockerReleaseProtocol.releaseProtocolFeatures,
+            ],
+        });
+    }
+    async validate(requestArg, requestDirectoryArg) {
+        const request = this.assertRequestForProject(requestArg);
+        const runValidation = async (requestDirectory, requestOwnerId) => {
+            const parsed = await this.run("release-validate", request, requestDirectory, requestOwnerId);
+            return plugins.tsdockerReleaseProtocol.assertReleaseValidationResult(parsed, request);
+        };
+        if (requestDirectoryArg) {
+            return runValidation(requestDirectoryArg, plugins.crypto.randomBytes(16).toString("hex"));
+        }
+        return this.runWithTemporaryRequestDirectory("release-validate", runValidation, (valueArg) => plugins.tsdockerReleaseProtocol.assertReleaseValidationResult(valueArg, request));
+    }
+    async qualify(requestArg, requestDirectoryArg, requestOwnerIdArg) {
+        const request = this.assertRequestForProject(requestArg);
+        const parsed = await this.run("release-qualify", request, requestDirectoryArg, requestOwnerIdArg, ["--classified-errors"]);
+        return assertReleaseQualificationResult(parsed, request);
+    }
+    async probe(requestArg, contextArg, requestDirectoryArg, requestOwnerIdArg) {
+        const request = this.assertPromotionInvocation(requestArg, contextArg);
+        const runProbe = async (requestDirectory, requestOwnerId) => {
+            const parsed = await this.run("release-probe", this.createPromotionRequest("tsdocker-release-probe-request", request, contextArg.promotionId), requestDirectory, requestOwnerId);
+            return plugins.tsdockerReleaseProtocol.assertReleaseProbeResult(parsed, request, contextArg);
+        };
+        if ((requestDirectoryArg === undefined) !==
+            (requestOwnerIdArg === undefined)) {
+            throw new Error("tSDocker release probes require both request storage and owner, or neither.");
+        }
+        if (requestDirectoryArg && requestOwnerIdArg) {
+            return runProbe(requestDirectoryArg, requestOwnerIdArg);
+        }
+        return this.runWithTemporaryRequestDirectory("release-probe", runProbe, (valueArg) => plugins.tsdockerReleaseProtocol.assertReleaseProbeResult(valueArg, request, contextArg));
+    }
+    async promote(requestArg, contextArg, requestDirectoryArg, requestOwnerIdArg) {
+        const request = this.assertPromotionInvocation(requestArg, contextArg);
+        const parsed = await this.run("release-promote", this.createPromotionRequest("tsdocker-release-promotion-request", request, contextArg.promotionId), requestDirectoryArg, requestOwnerIdArg);
+        return plugins.tsdockerReleaseProtocol.assertReleasePromotionResult(parsed, request, contextArg);
+    }
+    async cleanup(requestArg, requestDirectoryArg, requestOwnerIdArg) {
+        const request = this.assertRequestForProject(requestArg);
+        const parsed = await this.run("release-cleanup", {
+            candidateId: request.candidateId,
+            kind: "tsdocker-release-cleanup-request",
+            projectId: request.projectId,
+            protocolVersion: 1,
+            schemaVersion: 1,
+        }, requestDirectoryArg, requestOwnerIdArg);
+        return assertReleaseCleanupResult(parsed, request);
+    }
+    async reclaimRequestFiles(requestDirectoryArg, retiredOwnerIdsArg) {
+        if (retiredOwnerIdsArg.length === 0 ||
+            new Set(retiredOwnerIdsArg).size !== retiredOwnerIdsArg.length ||
+            retiredOwnerIdsArg.some((ownerIdArg) => !requestOwnerIdPattern.test(ownerIdArg))) {
+            throw new Error("tSDocker request reclamation requires unique exact retired owner IDs.");
+        }
+        const requestDirectory = await this.assertRequestDirectory(requestDirectoryArg);
+        const retiredOwnerIds = new Set(retiredOwnerIdsArg);
+        const callerUid = process.getuid?.();
+        const entries = await plugins.fs.readdir(requestDirectory, {
+            withFileTypes: true,
+        });
+        for (const entry of entries) {
+            const match = entry.name.match(requestFilePattern);
+            if (!match || !retiredOwnerIds.has(match[1]))
+                continue;
+            const requestPath = plugins.path.join(requestDirectory, entry.name);
+            let requestStat;
+            try {
+                requestStat = await plugins.fs.lstat(requestPath);
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            if (!entry.isFile() ||
+                !requestStat.isFile() ||
+                requestStat.isSymbolicLink() ||
+                (callerUid !== undefined && requestStat.uid !== callerUid) ||
+                (requestStat.mode & 0o077) !== 0 ||
+                requestStat.size > requestByteLimit) {
+                throw new Error(`Retired tSDocker request file is unsafe: ${requestPath}`);
+            }
+            await plugins.fs.rm(requestPath);
+        }
+    }
+    async readInstalledVersion() {
+        const packageHandle = await plugins.fs.open(this.packageJsonPath, plugins.fsConstants.O_RDONLY | plugins.fsConstants.O_NOFOLLOW);
+        let packageJson;
+        try {
+            const before = await packageHandle.stat();
+            if (!before.isFile() ||
+                before.size <= 0 ||
+                before.size > packageJsonByteLimit) {
+                throw new Error("Project-local @git.zone/tsdocker package metadata is unavailable or unsafe.");
+            }
+            const bytes = await packageHandle.readFile();
+            const after = await packageHandle.stat();
+            if (before.dev !== after.dev ||
+                before.ino !== after.ino ||
+                before.size !== after.size ||
+                before.mtimeMs !== after.mtimeMs ||
+                before.ctimeMs !== after.ctimeMs ||
+                bytes.byteLength !== before.size) {
+                throw new Error("Project-local @git.zone/tsdocker package metadata changed while being read.");
+            }
+            packageJson = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        }
+        catch (error) {
+            throw new Error("Project-local @git.zone/tsdocker package metadata is invalid.", { cause: error });
+        }
+        finally {
+            await packageHandle.close();
+        }
+        if (!isPlainObject(packageJson) ||
+            packageJson.name !== "@git.zone/tsdocker" ||
+            typeof packageJson.version !== "string" ||
+            !supportsTsdockerMinimumVersion(packageJson.version, minimumReleaseVersion)) {
+            throw new Error("Docker release journal schema 2 requires project-local @git.zone/tsdocker >= 3.5.1.");
+        }
+        return packageJson.version;
+    }
+    assertRequestForProject(requestArg) {
+        return plugins.tsdockerReleaseProtocol.assertReleaseQualificationRequestForProject(requestArg, this.cwd);
+    }
+    assertPromotionInvocation(requestArg, contextArg) {
+        return plugins.tsdockerReleaseProtocol.assertReleasePromotionInvocation({
+            ...contextArg,
+            request: requestArg,
+        });
+    }
+    createPromotionRequest(kindArg, requestArg, promotionIdArg) {
+        return {
+            candidateId: requestArg.candidateId,
+            kind: kindArg,
+            projectId: requestArg.projectId,
+            promotionId: promotionIdArg,
+            protocolVersion: 1,
+            schemaVersion: 1,
+        };
+    }
+    async assertRequestDirectory(requestDirectoryArg) {
+        const requestDirectory = plugins.path.resolve(requestDirectoryArg);
+        const directoryStat = await plugins.fs.lstat(requestDirectory);
+        const callerUid = process.getuid?.();
+        if (!directoryStat.isDirectory() ||
+            directoryStat.isSymbolicLink() ||
+            (callerUid !== undefined && directoryStat.uid !== callerUid) ||
+            (directoryStat.mode & 0o077) !== 0) {
+            throw new Error("tSDocker release request storage must be a private owned directory.");
+        }
+        return requestDirectory;
+    }
+    async runWithTemporaryRequestDirectory(commandArg, operationArg, assertResultArg) {
+        const temporaryRoot = await plugins.fs.realpath(plugins.os.tmpdir());
+        const temporaryDirectory = await plugins.fs.mkdtemp(plugins.path.join(temporaryRoot, `gitzone-tsdocker-${commandArg}-`));
+        let result;
+        let operationError;
+        try {
+            await plugins.fs.chmod(temporaryDirectory, 0o700);
+            result = await operationArg(temporaryDirectory, plugins.crypto.randomBytes(16).toString("hex"));
+        }
+        catch (error) {
+            operationError = error;
+        }
+        let directoryCleanupError;
+        try {
+            await plugins.fs.rm(temporaryDirectory, {
+                recursive: true,
+                force: false,
+            });
+        }
+        catch (error) {
+            directoryCleanupError = error;
+        }
+        if (directoryCleanupError) {
+            if (operationError instanceof TsdockerReleaseRequestCleanupError) {
+                operationError.reclamationError = directoryCleanupError;
+                throw operationError;
+            }
+            throw new TsdockerReleaseRequestCleanupError(commandArg, temporaryDirectory, operationError, result, directoryCleanupError);
+        }
+        if (operationError instanceof TsdockerReleaseRequestCleanupError) {
+            if (operationError.result !== undefined) {
+                return assertResultArg(operationError.result);
+            }
+            if (operationError.commandError !== undefined) {
+                throw operationError.commandError;
+            }
+            throw operationError;
+        }
+        if (operationError)
+            throw operationError;
+        return result;
+    }
+    async run(commandArg, requestArg, requestDirectoryArg, requestOwnerIdArg, extraArgsArg = []) {
+        let requestPath = "";
+        let requestCreated = false;
+        let requestIdentity;
+        let commandError;
+        let result;
+        let hasResult = false;
+        try {
+            const args = [commandArg];
+            if (requestArg !== undefined) {
+                if (!requestDirectoryArg ||
+                    !requestOwnerIdArg ||
+                    !requestOwnerIdPattern.test(requestOwnerIdArg)) {
+                    throw new Error("tSDocker release request storage and exact owner are required.");
+                }
+                const requestDirectory = await this.assertRequestDirectory(requestDirectoryArg);
+                requestPath = plugins.path.join(requestDirectory, `.tsdocker-request.${requestOwnerIdArg}.${commandArg}.${plugins.crypto
+                    .randomBytes(12)
+                    .toString("hex")}.json`);
+                const document = canonicalReleaseJsonDocument(requestArg);
+                if (Buffer.byteLength(document) > requestByteLimit) {
+                    throw new Error("tSDocker release request exceeds 64 KiB.");
+                }
+                const callerUid = process.getuid?.();
+                const handle = await plugins.fs.open(requestPath, plugins.fsConstants.O_WRONLY |
+                    plugins.fsConstants.O_CREAT |
+                    plugins.fsConstants.O_EXCL |
+                    plugins.fsConstants.O_NOFOLLOW, 0o600);
+                requestCreated = true;
+                try {
+                    const openedStat = await handle.stat();
+                    if (!openedStat.isFile() ||
+                        (callerUid !== undefined && openedStat.uid !== callerUid) ||
+                        (openedStat.mode & 0o077) !== 0) {
+                        throw new Error("tSDocker release request file is unsafe.");
+                    }
+                    requestIdentity = {
+                        dev: openedStat.dev,
+                        ino: openedStat.ino,
+                        mode: openedStat.mode,
+                        uid: openedStat.uid,
+                    };
+                    await handle.writeFile(document, "utf8");
+                    await handle.sync();
+                    const requestStat = await handle.stat();
+                    if (!requestStat.isFile() ||
+                        (callerUid !== undefined && requestStat.uid !== callerUid) ||
+                        (requestStat.mode & 0o077) !== 0 ||
+                        requestStat.size !== Buffer.byteLength(document)) {
+                        throw new Error("tSDocker release request file is unsafe.");
+                    }
+                    requestIdentity = {
+                        dev: requestStat.dev,
+                        ino: requestStat.ino,
+                        mode: requestStat.mode,
+                        uid: requestStat.uid,
+                    };
+                }
+                finally {
+                    await handle.close();
+                }
+                args.push(`--request-file=${requestPath}`, ...extraArgsArg);
+            }
+            else if (extraArgsArg.length > 0) {
+                throw new Error("tSDocker request flags require a request payload.");
+            }
+            const commandResult = await this.smartshell.execSpawn(this.binaryPath, args, {
+                cwd: this.cwd,
+                maxBuffer: responseByteLimit + 1,
+                silent: true,
+                timeout: commandTimeouts[commandArg],
+                timeoutKillGraceMs: commandArg === "release-qualify" || commandArg === "release-promote"
+                    ? 3 * 60_000
+                    : 30_000,
+            });
+            result = parseProtocolOutput(commandResult, commandArg);
+            hasResult = true;
+        }
+        catch (error) {
+            commandError = error;
+        }
+        let cleanupError;
+        if (requestCreated) {
+            try {
+                if (!requestIdentity) {
+                    throw new Error("tSDocker release request was created without a cleanup identity.");
+                }
+                const currentStat = await plugins.fs.lstat(requestPath);
+                if (!currentStat.isFile() ||
+                    currentStat.isSymbolicLink() ||
+                    currentStat.dev !== requestIdentity.dev ||
+                    currentStat.ino !== requestIdentity.ino ||
+                    currentStat.mode !== requestIdentity.mode ||
+                    currentStat.uid !== requestIdentity.uid) {
+                    throw new Error("tSDocker release request changed before caller cleanup.");
+                }
+                await plugins.fs.rm(requestPath);
+            }
+            catch (error) {
+                cleanupError = error;
+            }
+        }
+        if (cleanupError) {
+            throw new TsdockerReleaseRequestCleanupError(commandArg, requestPath, commandError, hasResult ? result : undefined, cleanupError);
+        }
+        if (commandError)
+            throw commandError;
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.tsdockerprotocol.js","sourceRoot":"","sources":["../../../ts/mod_release/helpers.tsdockerprotocol.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_release/index.d.ts

@@ -2,6 +2,6 @@ import type { ICliMode } from "../helpers.climode.js";
 import { type IResolvedReleaseWorkflow } from "../helpers.workflow.js";
 export { buildReleaseGitPushArgs } from "./helpers.releasepublication.js";
 export declare const run: (argvArg: any) => Promise<void>;
-type TDockerCommandWorkflow = Pick<IResolvedReleaseWorkflow, "dockerRegistry" | "dockerBuildRegistries" | "dockerTest" | "dockerNoBuild" | "dockerCached" | "dockerParallel" | "dockerContext" | "dockerPatterns">;
+type TDockerCommandWorkflow = Pick<IResolvedReleaseWorkflow, "dockerRegistry" | "dockerBuildRegistries" | "dockerTest" | "dockerCached" | "dockerParallel" | "dockerContext" | "dockerPatterns">;
 export declare function buildTsdockerPushCommand(workflow: TDockerCommandWorkflow): string;
 export declare function showHelp(mode?: ICliMode): void;