@wpelevator/wp-release 0.12.0 → 0.14.0

package/dist/commands/changeset-version.d.ts

@@ -29,8 +29,14 @@ declare const _default: {
         readonly 'no-dependents': {
             readonly type: "boolean";
         };
+        readonly prerelease: {
+            readonly type: "string";
+        };
+        readonly snapshot: {
+            readonly type: "string";
+        };
     };
-    run({ values, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<{
+    run({ values, cwd, configFile, tagFormat, logger }: import("./command.ts").CommandContext): Promise<{
         exitCode: number;
         result: {
             date: string;

package/dist/commands/changeset-version.js

@@ -3,24 +3,37 @@ import { getChangesetVersionSummary } from "../summary.js";
 import { parseChangesetVersionArgs, changesetVersionArgs, } from "./changeset-args.js";
 export default {
     name: 'changeset-version',
-    usage: 'changeset-version [--dry-run] [--date <YYYY-MM-DD>] [--package <name>] [--no-dependents]',
+    usage: 'changeset-version [--dry-run] [--date <YYYY-MM-DD>] [--package <name>] [--no-dependents] [--prerelease <id> | --snapshot <id>]',
     summary: 'Apply pending version bumps and changelog entries.',
     help: `Options:
   --dry-run              Print the release plan without writing files
   --date <YYYY-MM-DD>    Changelog date (default: today)
-  --package <name>       Version only this package (repeatable)
+  --package <name>       Version only this package, by identifier or path
+                         under the configured root (repeatable)
   --no-dependents        Leave the configured dependents of the selected sources out
+  --prerelease <id>      Release pre-releases like 1.3.0-rc.1, with an identifier
+                         like rc (numbered from the tags) or rc.1
+  --snapshot <id>        Release snapshots like 1.3.0-pr-251.20261012183000,
+                         with an identifier like pr-251 and the UTC time
 
 Updates configured version files, prepends changelog entries and removes the
 applied changeset files. With --package, a changeset that also names other
 packages keeps only their entries, so it still applies to their releases, and
-changesets without packages are left for a run without --package.`,
+changesets without packages are left for a run without --package.
+
+With --prerelease, run it on a branch that isn't merged and tag that branch,
+since the pre-release consumes the changesets that the stable release needs.
+The readme Stable tag keeps the last stable version.
+
+With --snapshot, build and publish the versioned files without committing
+them, for example to test a pull request.`,
     options: changesetVersionArgs,
-    async run({ values, cwd, configFile, logger }) {
+    async run({ values, cwd, configFile, tagFormat, logger }) {
         const args = parseChangesetVersionArgs(values);
         const result = await versionChangesets({
             cwd,
             ...(configFile ? { configFile } : {}),
+            ...(tagFormat ? { tagFormat } : {}),
             ...args,
         });
         result.releases.forEach((release) => logger.info(`${release.package.name}: ${release.currentVersion} → ${release.nextVersion} (${release.bump})`));

package/dist/commands/checksums.js

@@ -1,10 +1,10 @@
 import { basename, resolve } from 'node:path';
 import { CHECKSUMS_EXTENSION, createChecksums, writeChecksums, } from "../checksums.js";
-import { loadFileRules, resolveFileSelection } from "../file-selection.js";
+import { ignoreOwnFile, ignoreOwnSignature, loadFileRules, resolveFileSelection, } from "../file-selection.js";
 import { FILENAME_FORMAT, formatFilename } from "../filename.js";
 import { readPackageMeta } from "../package-meta.js";
 import { getChecksumsSummary } from "../summary.js";
-import { checkDirectory, fileSelectionArgs, getFileSelectionInput, getSourceDirArg, ignoreOwnFile, ignoreOwnSignature, resolveOutput, sourceDirArgs, } from "./args.js";
+import { checkDirectory, fileSelectionArgs, getFileSelectionInput, getSourceDirArg, resolveOutput, sourceDirArgs, } from "./args.js";
 import { getBoolean, getString } from "./command.js";
 export default {
     name: 'checksums',

package/dist/commands/command.d.ts

@@ -1,4 +1,5 @@
 import type { ParseArgsOptionsConfig } from 'node:util';
+import type { PromptTerminal } from '../changeset-prompt.ts';
 import type { Logger } from '../logger.ts';
 /**
  * Parsed option values from node:util parseArgs().
@@ -13,8 +14,12 @@ export interface CommandContext {
     cwd: string;
     /** Explicit JavaScript release config path from --config, if supplied. */
     configFile?: string;
+    /** Tag format from --tag-format, which replaces the tagFormat of the config. */
+    tagFormat?: string;
     /** Logger for the command output. */
     logger: Logger;
+    /** Terminal for interactive prompts, only when the CLI runs in one and prints no JSON. */
+    terminal?: PromptTerminal;
 }
 export interface CommandOutcome<Result = unknown> {
     /** Process exit code. */

package/dist/commands/deploy-git.d.ts

@@ -15,12 +15,22 @@ declare const _default: {
     summary: string;
     help: string;
     options: {
-        message: {
-            type: "string";
-        };
         'dry-run': {
             type: "boolean";
         };
+        'release-ref': {
+            readonly type: "string";
+        };
+        package: {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        list: {
+            readonly type: "boolean";
+        };
+        message: {
+            type: "string";
+        };
         'git-url': {
             type: "string";
         };
@@ -37,7 +47,17 @@ declare const _default: {
             type: "string";
         };
     };
-    run({ values, positionals, cwd, logger }: import("./command.ts").CommandContext): Promise<{
+    run({ values, positionals, cwd, configFile, tagFormat, logger }: import("./command.ts").CommandContext): Promise<{
+        exitCode: number;
+        result: {
+            packages: import("../package-deploy.ts").PackageDeployPlanItem[];
+        };
+    } | {
+        exitCode: number;
+        result: {
+            deploys: import("./package-deploys.ts").PackageDeployOutcome<import("../git-deploy.ts").GitDeployResult>[];
+        };
+    } | {
         exitCode: number;
         result: import("../git-deploy.ts").GitDeployResult;
     }>;

package/dist/commands/deploy-git.js

@@ -1,6 +1,22 @@
 import { GitDeploy, resolveGitDeployOptions } from "../git-deploy.js";
+import { getGitDeploys } from "../package-deploy.js";
 import { fileSelectionArgs, getFileSelectionInput, getSourceDirArg, sourceDirArgs, } from "./args.js";
 import { getBoolean, getString } from "./command.js";
+import { getPackageDeployArgs, listPackageDeploys, packageDeployArgs, runPackageDeploys, } from "./package-deploys.js";
+/** Options of a single deploy target, which --release-ref takes from the config. */
+const TARGET_FLAGS = [
+    'source-dir',
+    'git-url',
+    'branch',
+    'tag',
+    'split-prefix',
+    'source-ref',
+    'distignore',
+    'no-distignore',
+    'exclude',
+    'exclude-gitattributes',
+    'message',
+];
 /**
  * Map the parsed "deploy-git" arguments to resolveGitDeployOptions() input.
  *
@@ -25,7 +41,7 @@ export function getGitDeployInputFromArgs(values, positionals, cwd) {
 }
 export default {
     name: 'deploy-git',
-    usage: 'deploy-git [<source-dir>] --git-url <url> [options]',
+    usage: 'deploy-git [<source-dir>] --git-url <url> [options] | deploy-git --release-ref <ref> [--package <name>] [--list] [--dry-run]',
     summary: 'Deploy the files of a plugin, theme or package to a Git repository as a release commit.',
     help: `Arguments:
   <source-dir>            Directory with the files to release (default: .),
@@ -37,6 +53,17 @@ Writes (none by default):
   --tag <name>            Create this tag for the release, on top of --branch
                           or the default branch of the repository
 
+Configured packages (instead of the options above):
+  --release-ref <ref>     Deploy the packages that this ref releases to the Git
+                          targets in the config: the package of a release tag,
+                          like refs/tags/plugins/alpha/1.2.0, or every package
+                          for a branch, like refs/heads/main
+  --package <name>        Deploy only this package (repeatable), for example
+                          in a CI job for each package or to retry one
+  --list                  List the deploys without running them, with the
+                          deploys of each package as the result for --json
+                          and --github-output, for a CI matrix
+
 Options:
   --git-url <url>         Repository to deploy to
   --split-prefix <dir>    Use the history of this directory of the source
@@ -56,9 +83,21 @@ branch only moves forward, a release without changes isn't pushed again, an
 older build doesn't move a branch that has newer source history, a tag that
 already has the same files is reused, and a tag with other files
 fails with exit code 2 (delete it in the repository to release it again). The source directory must be inside a Git repository.
-Credentials come from git, like a token in the URL or an SSH key.
+Credentials come from git, like a credential helper or an SSH key. For an
+HTTPS repository on github.com, or on the host of GITHUB_SERVER_URL, the
+GITHUB_TOKEN environment variable is sent as an authorization header, so the
+token stays out of the URL.
+
+With --release-ref, each package deploys to every Git target of its
+deploy.git config, with the history of its directory, in one log group for
+each package, and a failed deploy doesn't stop the others but exits with 1. A release tag creates the tag of each target on top
+of its default branch, and a branch releases to the same branch.
 
 Examples:
+  wp-release deploy-git --release-ref "$GITHUB_REF"
+      Deploy the configured packages of a tag or branch push
+  wp-release deploy-git --release-ref refs/heads/main --list
+      Preview what a push to main deploys
   wp-release deploy-git build --git-url git@github.com:me/my-plugin-dist.git --branch main --tag 1.2.0
       Release a build to a distribution repository and tag it
   wp-release deploy-git packages/my-plugin --split-prefix packages/my-plugin --git-url … --branch main
@@ -72,9 +111,24 @@ Examples:
         'source-ref': { type: 'string' },
         ...fileSelectionArgs,
         message: { type: 'string' },
+        ...packageDeployArgs,
         'dry-run': { type: 'boolean' },
     },
-    async run({ values, positionals, cwd, logger }) {
+    async run({ values, positionals, cwd, configFile, tagFormat, logger }) {
+        const { ref, packages, list } = getPackageDeployArgs(values, positionals, TARGET_FLAGS);
+        if (ref) {
+            const deploys = await getGitDeploys({
+                cwd,
+                ref,
+                packages,
+                dryRun: getBoolean(values, 'dry-run'),
+                ...(configFile ? { configFile } : {}),
+                ...(tagFormat ? { tagFormat } : {}),
+            });
+            return list
+                ? listPackageDeploys(deploys, logger, ref)
+                : runPackageDeploys(deploys, (input) => new GitDeploy(resolveGitDeployOptions(input), logger).run(), logger, ref);
+        }
         const options = resolveGitDeployOptions(getGitDeployInputFromArgs(values, positionals, cwd));
         const result = await new GitDeploy(options, logger).run();
         return { exitCode: 0, result };

package/dist/commands/deploy-svn.d.ts

@@ -23,6 +23,19 @@ declare const _default: {
     summary: string;
     help: string;
     options: {
+        'dry-run': {
+            type: "boolean";
+        };
+        'release-ref': {
+            readonly type: "string";
+        };
+        package: {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        list: {
+            readonly type: "boolean";
+        };
         'svn-url': {
             type: "string";
         };
@@ -35,9 +48,6 @@ declare const _default: {
         force: {
             type: "boolean";
         };
-        'dry-run': {
-            type: "boolean";
-        };
         trunk: {
             type: "boolean";
         };
@@ -66,7 +76,17 @@ declare const _default: {
             type: "string";
         };
     };
-    run({ values, positionals, cwd, logger }: import("./command.ts").CommandContext): Promise<{
+    run({ values, positionals, cwd, configFile, tagFormat, logger }: import("./command.ts").CommandContext): Promise<{
+        exitCode: number;
+        result: {
+            packages: import("../package-deploy.ts").PackageDeployPlanItem[];
+        };
+    } | {
+        exitCode: number;
+        result: {
+            deploys: import("./package-deploys.ts").PackageDeployOutcome<import("../svn-deploy.ts").DeployResult>[];
+        };
+    } | {
         exitCode: number;
         result: import("../svn-deploy.ts").DeployResult;
     }>;

package/dist/commands/deploy-svn.js

@@ -1,7 +1,28 @@
 import { resolveDeployOptions } from "../deploy-options.js";
+import { getSvnDeploys } from "../package-deploy.js";
 import { SvnDeploy } from "../svn-deploy.js";
 import { fileSelectionArgs, getFileSelectionInput, getSourceDirArg, sourceDirArgs, } from "./args.js";
 import { getBoolean, getString } from "./command.js";
+import { getPackageDeployArgs, listPackageDeploys, packageDeployArgs, runPackageDeploys, } from "./package-deploys.js";
+/** Options of a single deploy, which --release-ref takes from the config. */
+const TARGET_FLAGS = [
+    'source-dir',
+    'trunk',
+    'readme-only',
+    'svn-tag',
+    'assets-dir',
+    'no-assets',
+    'slug',
+    'version',
+    'readme',
+    'from-zip',
+    'distignore',
+    'no-distignore',
+    'exclude',
+    'exclude-gitattributes',
+    'svn-url',
+    'message',
+];
 /**
  * Map the parsed "deploy-svn" arguments to resolveDeployOptions() input.
  * Flags that aren't passed stay undefined, so that the same defaults apply
@@ -35,7 +56,7 @@ export function getDeployInputFromArgs(input) {
 }
 export default {
     name: 'deploy-svn',
-    usage: 'deploy-svn [<source-dir>] [options]',
+    usage: 'deploy-svn [<source-dir>] [options] | deploy-svn --release-ref <ref> [--package <name>] [--list] [--dry-run]',
     summary: 'Deploy a plugin to the WordPress.org plugin SVN repository.',
     help: `Arguments:
   <source-dir>            Directory with the plugin files (default: .), also
@@ -51,6 +72,15 @@ Writes (none by default, assets only with --assets-dir):
                           screenshots to assets/
   --no-assets             Don't sync --assets-dir for this run
 
+Configured packages (instead of the writes and the source options):
+  --release-ref <ref>     Deploy the package that this release tag releases,
+                          like refs/tags/plugins/alpha/1.2.0, to the SVN
+                          targets in the config. Branches aren't deployed.
+  --package <name>        Deploy only this package (repeatable)
+  --list                  List the deploys without running them, with the
+                          deploys of each package as the result for --json
+                          and --github-output, for a CI matrix
+
 Options:
   --slug <slug>           Plugin slug (default: project directory name)
   --version <version>     Version to check (default: --svn-tag, then the Version header)
@@ -71,7 +101,13 @@ Options:
 Credentials are only needed to commit. Exits with 3 when they're missing
 or rejected.
 
+With --release-ref, a stable release syncs trunk/, creates its tag and syncs
+the assetsDir of each deploy.svn target, while a pre-release only creates its
+tag. A failed deploy doesn't stop the others and exits with 1.
+
 Examples:
+  wp-release deploy-svn --release-ref "$GITHUB_REF"
+      Deploy the configured plugin of a release tag push
   wp-release deploy-svn dist --trunk --svn-tag 1.2.0 --assets-dir .wordpress-org
       Deploy 1.2.0 to trunk and the tag, and update the assets
   wp-release deploy-svn dist --svn-tag 1.2.0-rc.1
@@ -96,9 +132,28 @@ Examples:
         'svn-username': { type: 'string' },
         message: { type: 'string' },
         force: { type: 'boolean' },
+        ...packageDeployArgs,
         'dry-run': { type: 'boolean' },
     },
-    async run({ values, positionals, cwd, logger }) {
+    async run({ values, positionals, cwd, configFile, tagFormat, logger }) {
+        const { ref, packages, list } = getPackageDeployArgs(values, positionals, TARGET_FLAGS);
+        if (ref) {
+            const deploys = await getSvnDeploys({
+                cwd,
+                ref,
+                packages,
+                dryRun: getBoolean(values, 'dry-run'),
+                ...(configFile ? { configFile } : {}),
+                ...(tagFormat ? { tagFormat } : {}),
+            });
+            return list
+                ? listPackageDeploys(deploys, logger, ref)
+                : runPackageDeploys(deploys, (input) => new SvnDeploy(resolveDeployOptions({
+                    ...input,
+                    svnUsername: getString(values, 'svn-username'),
+                    force: getBoolean(values, 'force'),
+                }), logger).run(), logger, ref);
+        }
         const options = resolveDeployOptions(getDeployInputFromArgs({ values, positionals, cwd }));
         const result = await new SvnDeploy(options, logger).run();
         return { exitCode: 0, result };

package/dist/commands/keygen.d.ts

@@ -1,3 +1,4 @@
+import type { SignatureFormat } from '../signing.ts';
 import type { CommandOutcome } from './command.ts';
 /** Generated Ed25519 signing keys. */
 export interface KeygenResult {
@@ -5,6 +6,8 @@ export interface KeygenResult {
     privateKey: string;
     /** Base64 Ed25519 public key for verification. */
     publicKey: string;
+    /** Public key in the form of each signature format. */
+    publicKeys: Record<SignatureFormat, string>;
 }
 declare const _default: {
     name: string;

package/dist/commands/keygen.js

@@ -8,7 +8,10 @@ export default {
     help: `Generate a signing key pair for "wp-release sign" and "wp-release verify".
 
 The private seed is printed once as WP_RELEASE_SIGNING_KEY. Store it securely
-and never commit it or share it. The public key can be distributed to verifiers.`,
+and never commit it or share it. The public key can be distributed to verifiers.
+It's also printed as a minisign public key for "minisign -V -P" and as an
+ssh-ed25519 public key for the allowed_signers file of "ssh-keygen -Y verify",
+since the same key signs every format of "wp-release sign".`,
     options: {},
     async run({ values, logger }) {
         if (getBoolean(values, 'github-output')) {
@@ -17,6 +20,8 @@ and never commit it or share it. The public key can be distributed to verifiers.
         const result = generateSigningKeyPair();
         logger.info(`WP_RELEASE_SIGNING_KEY=${result.privateKey}`);
         logger.info(`Public key: ${result.publicKey}`);
+        logger.info(`Minisign public key: ${result.publicKeys.minisign}`);
+        logger.info(`SSH public key: ${result.publicKeys.ssh}`);
         logger.info('Store the private seed securely; it cannot be recovered from the public key.');
         return { exitCode: 0, result };
     },

package/dist/commands/package-deploys.d.ts

@@ -0,0 +1,86 @@
+import type { Logger } from '../logger.ts';
+import type { PackageDeploy, PackageDeployPlanItem } from '../package-deploy.ts';
+import type { ParsedValues } from './command.ts';
+/**
+ * Options of the deploy commands that deploy the configured packages of a
+ * ref, in node:util parseArgs() format.
+ */
+export declare const packageDeployArgs: {
+    readonly 'release-ref': {
+        readonly type: "string";
+    };
+    readonly package: {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly list: {
+        readonly type: "boolean";
+    };
+};
+/** Result of one deploy of a configured package. */
+export interface PackageDeployOutcome<Result> {
+    package: string;
+    /** Package, target and ref, with credentials redacted. */
+    label: string;
+    /** Repository or WordPress.org plugin of the target, with credentials redacted. */
+    target: string;
+    /** Tag or branch that the deploy writes in the target. */
+    targetRef: string;
+    /** Host of a remote target repository, like github.com. */
+    targetHost?: string;
+    /** Path of a remote target repository on its host, like owner/repo. */
+    targetPath?: string;
+    version?: string;
+    branch?: string;
+    /** Deploy result, unless it failed. */
+    result?: Result;
+    /** Error message of a failed deploy. */
+    error?: string;
+}
+/**
+ * Get the ref and the packages to deploy from the config, failing for the
+ * options that set a single deploy target instead.
+ *
+ * @param  values      Parsed CLI values.
+ * @param  positionals Positional arguments.
+ * @param  targetFlags Options of a single deploy target.
+ * @return The ref and the selected packages.
+ * @throws {ValidationError} For --package without --release-ref, or a single target option with it.
+ */
+export declare function getPackageDeployArgs(values: ParsedValues, positionals: string[], targetFlags: string[]): {
+    ref?: string;
+    packages: string[];
+    list: boolean;
+};
+/**
+ * Run the deploys of the configured packages one at a time, in one log group
+ * for each package, continuing after a failed deploy so that one package or
+ * target doesn't block the others.
+ *
+ * @param deploys Deploys from getGitDeploys() or getSvnDeploys().
+ * @param deploy  Runs one deploy.
+ * @param logger  Logger.
+ * @param ref     Deployed ref, for the log.
+ * @return Exit code 1 when a deploy failed, and the result of each deploy.
+ */
+export declare function runPackageDeploys<Input, Result>(deploys: PackageDeploy<Input>[], deploy: (input: Input) => Promise<Result>, logger: Logger, ref: string): Promise<{
+    exitCode: number;
+    result: {
+        deploys: PackageDeployOutcome<Result>[];
+    };
+}>;
+/**
+ * List the deploys of the configured packages without running them, one line
+ * for each deploy, with the plan as the result for --json and --github-output.
+ *
+ * @param deploys Deploys from getGitDeploys() or getSvnDeploys().
+ * @param logger  Logger.
+ * @param ref     Deployed ref, for the log.
+ * @return Exit code 0 and the deploys of each package.
+ */
+export declare function listPackageDeploys(deploys: PackageDeploy<unknown>[], logger: Logger, ref: string): {
+    exitCode: number;
+    result: {
+        packages: PackageDeployPlanItem[];
+    };
+};

package/dist/commands/package-deploys.js

@@ -0,0 +1,113 @@
+import { ValidationError } from "../errors.js";
+import { getDeployPlan } from "../package-deploy.js";
+import { logError } from "../report.js";
+import { getBoolean, getString, getStrings } from "./command.js";
+/**
+ * Options of the deploy commands that deploy the configured packages of a
+ * ref, in node:util parseArgs() format.
+ */
+export const packageDeployArgs = {
+    'release-ref': { type: 'string' },
+    package: { type: 'string', multiple: true },
+    list: { type: 'boolean' },
+};
+/**
+ * Get the ref and the packages to deploy from the config, failing for the
+ * options that set a single deploy target instead.
+ *
+ * @param  values      Parsed CLI values.
+ * @param  positionals Positional arguments.
+ * @param  targetFlags Options of a single deploy target.
+ * @return The ref and the selected packages.
+ * @throws {ValidationError} For --package without --release-ref, or a single target option with it.
+ */
+export function getPackageDeployArgs(values, positionals, targetFlags) {
+    const ref = getString(values, 'release-ref')?.trim();
+    const packages = getStrings(values, 'package');
+    const list = getBoolean(values, 'list');
+    const conflicts = targetFlags.filter((flag) => undefined !== getString(values, flag) ||
+        getBoolean(values, flag) ||
+        getStrings(values, flag).length);
+    if ('' === ref) {
+        throw new ValidationError('--release-ref <ref> must not be empty.');
+    }
+    if ((packages.length || list) && !ref) {
+        throw new ValidationError(`${list ? '--list' : '--package'} requires --release-ref <ref>.`);
+    }
+    if (ref && (positionals.length || conflicts.length)) {
+        throw new ValidationError(`--release-ref deploys the configured packages and targets, so it can't be combined with ${positionals.length
+            ? 'a source directory'
+            : conflicts.map((flag) => `--${flag}`).join(', ')}.`);
+    }
+    return { ...(ref ? { ref } : {}), packages, list };
+}
+/**
+ * Run the deploys of the configured packages one at a time, in one log group
+ * for each package, continuing after a failed deploy so that one package or
+ * target doesn't block the others.
+ *
+ * @param deploys Deploys from getGitDeploys() or getSvnDeploys().
+ * @param deploy  Runs one deploy.
+ * @param logger  Logger.
+ * @param ref     Deployed ref, for the log.
+ * @return Exit code 1 when a deploy failed, and the result of each deploy.
+ */
+export async function runPackageDeploys(deploys, deploy, logger, ref) {
+    const outcomes = [];
+    const names = [
+        ...new Set(deploys.map((item) => item.package.name)),
+    ];
+    if (!deploys.length) {
+        logger.info(`No configured package deploys ${ref}.`);
+    }
+    for (const name of names) {
+        const items = deploys.filter((item) => item.package.name === name);
+        const release = items[0]?.release ?? {};
+        await logger.group(`${name} ${release.version ?? release.branch ?? ''}`.trim(), async () => {
+            for (const item of items) {
+                outcomes.push(await runDeploy(item, deploy, logger));
+            }
+        });
+    }
+    return {
+        exitCode: outcomes.some((outcome) => outcome.error) ? 1 : 0,
+        result: { deploys: outcomes },
+    };
+}
+async function runDeploy(item, deploy, logger) {
+    const outcome = {
+        package: item.package.name,
+        label: item.label,
+        target: item.target,
+        targetRef: item.targetRef,
+        ...(item.targetHost
+            ? { targetHost: item.targetHost, targetPath: item.targetPath }
+            : {}),
+        ...item.release,
+    };
+    try {
+        outcome.result = await deploy(item.input);
+    }
+    catch (error) {
+        outcome.error =
+            error instanceof Error ? error.message : String(error);
+        logError(logger, error, `Deploy of ${item.label}`);
+    }
+    return outcome;
+}
+/**
+ * List the deploys of the configured packages without running them, one line
+ * for each deploy, with the plan as the result for --json and --github-output.
+ *
+ * @param deploys Deploys from getGitDeploys() or getSvnDeploys().
+ * @param logger  Logger.
+ * @param ref     Deployed ref, for the log.
+ * @return Exit code 0 and the deploys of each package.
+ */
+export function listPackageDeploys(deploys, logger, ref) {
+    if (!deploys.length) {
+        logger.info(`No configured package deploys ${ref}.`);
+    }
+    deploys.forEach((item) => logger.info(item.label));
+    return { exitCode: 0, result: { packages: getDeployPlan(deploys) } };
+}

package/dist/commands/sign.d.ts

@@ -1,17 +1,35 @@
+import type { SignatureFormat } from '../signing.ts';
 import type { CommandOutcome } from './command.ts';
 /** Result of the sign command. */
 export interface SignResult {
-    /** Absolute paths of the written .sig files. */
+    /** Absolute paths of the written signature files. */
     signatures: string[];
+    /** Signature formats that were written. */
+    formats: SignatureFormat[];
     /** Base64 public key of the signing key. */
     publicKey: string;
+    /** Public key of the signing key in the form of each signature format. */
+    publicKeys: Record<SignatureFormat, string>;
 }
+/**
+ * Get the signature formats from the --format values, which can be repeated
+ * or comma-separated.
+ *
+ * @param  values Option values.
+ * @return Unique formats, the default when none are given.
+ * @throws {ValidationError} If a format is unknown.
+ */
+export declare function parseSignatureFormats(values: string[]): SignatureFormat[];
 declare const _default: {
     name: string;
     usage: string;
     summary: string;
     help: string;
     options: {
+        format: {
+            type: "string";
+            multiple: true;
+        };
         force: {
             type: "boolean";
         };