@wpelevator/wp-release 0.13.0 → 0.15.0

package/dist/cli.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { appendFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';
 import zip from "./commands/zip.js";
@@ -43,6 +44,7 @@ const globalArgs = {
     json: { type: 'boolean' },
     'github-output': { type: 'boolean' },
     config: { type: 'string' },
+    'tag-format': { type: 'string' },
 };
 const globalOptions = `Global options:
   -h, --help               Show help for the command
@@ -55,7 +57,32 @@ const globalOptions = `Global options:
       --json               Print the result as JSON
       --github-output      Set the result as JSON to the "result" output of
                            the GitHub Actions step
-      --config <path>      Path to a JavaScript release config file`;
+      --config <path>      Path to a JavaScript release config file
+      --tag-format <format>
+                           Tag format with {name}, {path} and {version} that
+                           replaces the tagFormat of the config, like
+                           {path}/{version}`;
+/**
+ * Get the config file and the tag format from the global options.
+ *
+ * @param  values Parsed CLI values.
+ * @return The --config and --tag-format values.
+ * @throws {ValidationError} For an empty --config or --tag-format.
+ */
+function getConfigArgs(values) {
+    const configFile = getString(values, 'config');
+    const tagFormat = getString(values, 'tag-format');
+    if ('' === configFile?.trim()) {
+        throw new ValidationError('--config <path> must not be empty.');
+    }
+    if ('' === tagFormat?.trim()) {
+        throw new ValidationError('--tag-format <format> must not be empty.');
+    }
+    return {
+        ...(configFile ? { configFile } : {}),
+        ...(tagFormat ? { tagFormat } : {}),
+    };
+}
 /**
  * Get the top-level help text listing all commands.
  *
@@ -151,6 +178,28 @@ function createLogWriter(values, streams) {
     }
     return create(streams);
 }
+/**
+ * Format the result of a command as GitHub Actions step outputs: the whole
+ * result as JSON in "result", and each top-level string, number or boolean
+ * as its own output, like "zipPath", so that a workflow reads it without
+ * fromJSON(). Lists and objects are only in "result". Every value but the
+ * compact JSON, which has no line breaks, uses a random delimiter, so that a
+ * value with line breaks can't set other outputs.
+ *
+ * @param result Command result.
+ * @return Lines for the GITHUB_OUTPUT file.
+ */
+export function formatGitHubOutputs(result) {
+    const values = 'object' === typeof result && null !== result
+        ? Object.entries(result).filter(([name, value]) => 'result' !== name &&
+            ['string', 'number', 'boolean'].includes(typeof value))
+        : [];
+    const delimiter = `ghadelimiter_${randomUUID()}`;
+    return [
+        `result=${JSON.stringify(result)}\n`,
+        ...values.map(([name, value]) => `${name}<<${delimiter}\n${String(value)}\n${delimiter}\n`),
+    ].join('');
+}
 /**
  * Get the GitHub Actions step output file for --github-output, checked before
  * the command runs.
@@ -188,10 +237,7 @@ async function runCommand(command, args, io) {
             options: { ...globalArgs, ...command.options },
             allowPositionals: true,
         });
-        const configFile = getString(values, 'config');
-        if ('' === configFile?.trim()) {
-            throw new ValidationError('--config <path> must not be empty.');
-        }
+        const { configFile, tagFormat } = getConfigArgs(values);
         const githubOutputFile = getGitHubOutputFile(values);
         logger = new Logger({
             writer: createLogWriter(values, { stdout, stderr }),
@@ -208,6 +254,7 @@ async function runCommand(command, args, io) {
             positionals,
             cwd,
             ...(configFile ? { configFile } : {}),
+            ...(tagFormat ? { tagFormat } : {}),
             logger,
             ...(interactive
                 ? { terminal: { input: stdin, output: stdout } }
@@ -217,8 +264,7 @@ async function runCommand(command, args, io) {
             stdout.write(JSON.stringify(result, null, '\t') + '\n');
         }
         if (githubOutputFile) {
-            // Compact JSON has no line breaks, so it fits a single output line.
-            appendFileSync(githubOutputFile, `result=${JSON.stringify(result)}\n`);
+            appendFileSync(githubOutputFile, formatGitHubOutputs(result));
         }
         return exitCode;
     }
@@ -238,6 +284,7 @@ async function runCommand(command, args, io) {
  * @param  context.cwd        Working directory that relative paths resolve against.
  * @param  context.configFile Explicit config file path, when supplied by a wrapper.
  * @param  context.logger     Logger for the command output.
+ * @param  context.svnRunner  Optional SVN command runner supplied by a wrapper.
  * @return Exit code and result of the command.
  * @throws {Error} If the command is unknown, the arguments are invalid or the command fails.
  */
@@ -251,16 +298,16 @@ export async function execute(name, args, context) {
         options: { ...globalArgs, ...command.options },
         allowPositionals: true,
     });
-    const configFile = getString(values, 'config') ?? context.configFile;
-    if ('' === configFile?.trim()) {
-        throw new ValidationError('--config <path> must not be empty.');
-    }
+    const configArgs = getConfigArgs(values);
+    const configFile = configArgs.configFile ?? context.configFile;
+    const { tagFormat } = configArgs;
     // The command table is keyed by name, so the result matches CommandResults.
     return command.run({
         values,
         positionals,
         ...context,
         ...(configFile ? { configFile } : {}),
+        ...(tagFormat ? { tagFormat } : {}),
     });
 }
 /**

package/dist/commands/args.d.ts

@@ -1,5 +1,5 @@
 import type { ParseArgsOptionsConfig } from 'node:util';
-import type { FileRules } from '../file-selection.ts';
+import type { SignatureFormat } from '../signing.ts';
 import type { ParsedValues } from './command.ts';
 /**
  * Options shared by the commands that select files with .distignore and
@@ -40,26 +40,6 @@ export declare function checkDirectory(path: string): Promise<void>;
  * @return Whether the path is a directory.
  */
 export declare function isDirectory(path: string): Promise<boolean>;
-/**
- * Ignore a file that the command writes or reads, such as the checksums
- * manifest, when it's inside the selected directory.
- *
- * @param rules     Matcher from loadFileRules().
- * @param sourceDir Selected directory.
- * @param path      Absolute file path.
- * @return The same matcher.
- */
-export declare function ignoreOwnFile(rules: FileRules, sourceDir: string, path: string): FileRules;
-/**
- * Ignore the signature file that "wp-release sign" writes next to a file the
- * command writes, when it's inside the selected directory.
- *
- * @param rules     Matcher from loadFileRules().
- * @param sourceDir Selected directory.
- * @param path      Absolute path of the signed file.
- * @return The same matcher.
- */
-export declare function ignoreOwnSignature(rules: FileRules, sourceDir: string, path: string): FileRules;
 /**
  * Option for the source directory, which can also be the first positional
  * argument.
@@ -90,3 +70,13 @@ export interface ResolveOutputInput {
  * @return Absolute file path.
  */
 export declare function resolveOutput(input: ResolveOutputInput): string;
+/**
+ * Get the signature formats from the --format values of sign or the
+ * --sign-format values of zip, 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[];

package/dist/commands/args.js

@@ -1,7 +1,7 @@
 import { stat } from 'node:fs/promises';
-import { isAbsolute, relative, resolve } from 'node:path';
+import { resolve } from 'node:path';
 import { ValidationError } from "../errors.js";
-import { SIGNATURE_EXTENSION } from "../signing.js";
+import { DEFAULT_SIGNATURE_FORMAT, SIGNATURE_FORMATS, isSignatureFormat, } from "../signing.js";
 import { getBoolean, getString, getStrings } from "./command.js";
 /**
  * Options shared by the commands that select files with .distignore and
@@ -63,39 +63,6 @@ export async function isDirectory(path) {
     const stats = await stat(path).catch(() => null);
     return Boolean(stats?.isDirectory());
 }
-/**
- * Ignore a file that the command writes or reads, such as the checksums
- * manifest, when it's inside the selected directory.
- *
- * @param rules     Matcher from loadFileRules().
- * @param sourceDir Selected directory.
- * @param path      Absolute file path.
- * @return The same matcher.
- */
-export function ignoreOwnFile(rules, sourceDir, path) {
-    const relativePath = relative(sourceDir, path).split('\\').join('/');
-    const isInside = relativePath &&
-        '..' !== relativePath &&
-        !relativePath.startsWith('../') &&
-        !isAbsolute(relativePath);
-    if (isInside) {
-        // Escape the gitignore wildcards so that the pattern matches only this file.
-        rules.add(`/${relativePath.replace(/[\\*?[\]!#]/g, '\\$&')}`);
-    }
-    return rules;
-}
-/**
- * Ignore the signature file that "wp-release sign" writes next to a file the
- * command writes, when it's inside the selected directory.
- *
- * @param rules     Matcher from loadFileRules().
- * @param sourceDir Selected directory.
- * @param path      Absolute path of the signed file.
- * @return The same matcher.
- */
-export function ignoreOwnSignature(rules, sourceDir, path) {
-    return ignoreOwnFile(rules, sourceDir, path + SIGNATURE_EXTENSION);
-}
 /**
  * Option for the source directory, which can also be the first positional
  * argument.
@@ -129,3 +96,25 @@ export function getSourceDirArg(values, positionals) {
 export function resolveOutput(input) {
     return resolve(input.cwd, input.output ?? input.filename);
 }
+/**
+ * Get the signature formats from the --format values of sign or the
+ * --sign-format values of zip, 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 function parseSignatureFormats(values) {
+    const names = values
+        .flatMap((value) => value.split(','))
+        .map((name) => name.trim())
+        .filter(Boolean);
+    const unknown = names.filter((name) => !isSignatureFormat(name));
+    if (unknown.length) {
+        throw new ValidationError(`Unknown signature format ${unknown.join(', ')}, use ${Object.keys(SIGNATURE_FORMATS).join(', ')}.`);
+    }
+    return names.length
+        ? [...new Set(names.filter(isSignatureFormat))]
+        : [DEFAULT_SIGNATURE_FORMAT];
+}

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

@@ -29,7 +29,7 @@ declare const _default: {
             readonly type: "string";
         };
     };
-    run({ values, cwd, configFile, logger, terminal }: import("./command.ts").CommandContext): Promise<{
+    run({ values, cwd, configFile, tagFormat, logger, terminal }: import("./command.ts").CommandContext): Promise<{
         exitCode: number;
         result: {
             file: string;

package/dist/commands/changeset-add.js

@@ -94,7 +94,7 @@ export default {
   --summary <text>       Customer-facing release note
   --empty                Record that this change does not need a release
   --since <ref>          Compare changed files with this git ref (default:
-                         origin/<baseBranch>)
+                         <remote>/<baseBranch>)
   --name <name>          Changeset filename (default: random identifier)
 
 Use --package and --bump pairs for package releases, or --empty for changes
@@ -104,11 +104,12 @@ ref, including uncommitted files, and have no changeset yet. Without
 --package and --bump in a terminal, the command asks for the packages, with
 the changed ones preselected, their bumps and the release note.`,
     options: changesetAddArgs,
-    async run({ values, cwd, configFile, logger, terminal }) {
+    async run({ values, cwd, configFile, tagFormat, logger, terminal }) {
         const input = parseChangesetAddArgs(values);
         const release = new ChangesetRelease({
             cwd,
             ...(configFile ? { configFile } : {}),
+            ...(tagFormat ? { tagFormat } : {}),
         });
         const changeset = await getChangeset(release, input, terminal);
         // Adding resolves the package paths and rejects a package passed twice.

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

@@ -26,7 +26,7 @@ declare const _default: {
             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: {
             releases: {

package/dist/commands/changeset-status.js

@@ -10,11 +10,12 @@ export default {
 Exit status is 2 when a changed package has no changeset added since the comparison base.
 An empty changeset added since the comparison base counts as an explicit no-release decision.`,
     options: changesetStatusArgs,
-    async run({ values, cwd, configFile, logger }) {
+    async run({ values, cwd, configFile, tagFormat, logger }) {
         const { since } = parseChangesetStatusArgs(values);
         const result = await getChangesetStatus({
             cwd,
             ...(configFile ? { configFile } : {}),
+            ...(tagFormat ? { tagFormat } : {}),
             ...(since ? { since } : {}),
         });
         logger.summary(() => {

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

@@ -24,7 +24,7 @@ declare const _default: {
             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: import("../changeset-release.ts").ChangesetTagResult;
     }>;

package/dist/commands/changeset-tag.js

@@ -14,7 +14,8 @@ export default {
                          the configured root (repeatable)
   --version <version>    Fail unless the single --package is at this version;
                          the version to tag for packages versioned by git tags
-  --push                 Push newly created tags to origin, one at a time
+  --push                 Push newly created tags to the configured remote
+                         (default: origin), one at a time
 
 Tags are created only when absent, so rerunning after a partial failure is
 safe. Before a tag is created, every configured version target must match the
@@ -23,11 +24,12 @@ and pre-release flag of its release, for a workflow step that creates the
 GitHub Release. --untagged lists only the releases that still need a tag, for
 example to release each of them with a separate workflow.`,
     options: changesetTagArgs,
-    async run({ values, cwd, configFile, logger }) {
+    async run({ values, cwd, configFile, tagFormat, logger }) {
         const args = parseChangesetTagArgs(values);
         const result = await tagChangesets({
             cwd,
             ...(configFile ? { configFile } : {}),
+            ...(tagFormat ? { tagFormat } : {}),
             ...args,
         });
         result.tags.forEach((item) => {

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

@@ -36,7 +36,7 @@ declare const _default: {
             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

@@ -28,11 +28,12 @@ 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,6 +1,7 @@
 import type { ParseArgsOptionsConfig } from 'node:util';
 import type { PromptTerminal } from '../changeset-prompt.ts';
 import type { Logger } from '../logger.ts';
+import type { SvnRunner } from '../svn.ts';
 /**
  * Parsed option values from node:util parseArgs().
  */
@@ -14,8 +15,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;
+    /** SVN command runner supplied by a wrapper, instead of spawning svn directly. */
+    svnRunner?: SvnRunner;
     /** Terminal for interactive prompts, only when the CLI runs in one and prints no JSON. */
     terminal?: PromptTerminal;
 }

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

@@ -47,7 +47,7 @@ declare const _default: {
             type: "string";
         };
     };
-    run({ values, positionals, cwd, configFile, 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[];

package/dist/commands/deploy-git.js

@@ -114,7 +114,7 @@ Examples:
         ...packageDeployArgs,
         'dry-run': { type: 'boolean' },
     },
-    async run({ values, positionals, cwd, configFile, logger }) {
+    async run({ values, positionals, cwd, configFile, tagFormat, logger }) {
         const { ref, packages, list } = getPackageDeployArgs(values, positionals, TARGET_FLAGS);
         if (ref) {
             const deploys = await getGitDeploys({
@@ -123,6 +123,7 @@ Examples:
                 packages,
                 dryRun: getBoolean(values, 'dry-run'),
                 ...(configFile ? { configFile } : {}),
+                ...(tagFormat ? { tagFormat } : {}),
             });
             return list
                 ? listPackageDeploys(deploys, logger, ref)

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

@@ -1,5 +1,14 @@
 import type { DeployInput } from '../deploy-options.ts';
-import type { ParsedValues } from './command.ts';
+import type { DeployResult } from '../svn-deploy.ts';
+import type { PackageDeployPlanItem } from '../package-deploy.ts';
+import type { CommandOutcome, ParsedValues } from './command.ts';
+import type { PackageDeployOutcome } from './package-deploys.ts';
+/** Results of a single deploy, a configured plan or configured deploys. */
+export type DeploySvnResult = DeployResult | {
+    packages: PackageDeployPlanItem[];
+} | {
+    deploys: PackageDeployOutcome<DeployResult>[];
+};
 export interface DeployArgsInput {
     /** Parsed CLI values. */
     values: ParsedValues;
@@ -76,19 +85,6 @@ declare const _default: {
             type: "string";
         };
     };
-    run({ values, positionals, cwd, configFile, 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;
-    }>;
+    run({ values, positionals, cwd, configFile, tagFormat, logger, svnRunner, }: import("./command.ts").CommandContext): Promise<CommandOutcome<DeploySvnResult>>;
 };
 export default _default;

package/dist/commands/deploy-svn.js

@@ -1,6 +1,7 @@
 import { resolveDeployOptions } from "../deploy-options.js";
 import { getSvnDeploys } from "../package-deploy.js";
 import { SvnDeploy } from "../svn-deploy.js";
+import { Svn } from "../svn.js";
 import { fileSelectionArgs, getFileSelectionInput, getSourceDirArg, sourceDirArgs, } from "./args.js";
 import { getBoolean, getString } from "./command.js";
 import { getPackageDeployArgs, listPackageDeploys, packageDeployArgs, runPackageDeploys, } from "./package-deploys.js";
@@ -23,6 +24,26 @@ const TARGET_FLAGS = [
     'svn-url',
     'message',
 ];
+/**
+ * Run an SVN deploy with the optional command runner supplied by a wrapper.
+ *
+ * @param input  Deploy input.
+ * @param logger Logger for the deploy.
+ * @param runner Optional SVN command runner.
+ * @return Deploy result.
+ */
+async function runDeploy(input, logger, runner) {
+    const options = resolveDeployOptions(input);
+    const svn = runner
+        ? new Svn({
+            runner,
+            username: options.svnUsername,
+            password: options.svnPassword,
+            logger,
+        })
+        : undefined;
+    return new SvnDeploy(options, logger, svn).run();
+}
 /**
  * Map the parsed "deploy-svn" arguments to resolveDeployOptions() input.
  * Flags that aren't passed stay undefined, so that the same defaults apply
@@ -135,7 +156,7 @@ Examples:
         ...packageDeployArgs,
         'dry-run': { type: 'boolean' },
     },
-    async run({ values, positionals, cwd, configFile, logger }) {
+    async run({ values, positionals, cwd, configFile, tagFormat, logger, svnRunner, }) {
         const { ref, packages, list } = getPackageDeployArgs(values, positionals, TARGET_FLAGS);
         if (ref) {
             const deploys = await getSvnDeploys({
@@ -144,17 +165,17 @@ Examples:
                 packages,
                 dryRun: getBoolean(values, 'dry-run'),
                 ...(configFile ? { configFile } : {}),
+                ...(tagFormat ? { tagFormat } : {}),
             });
             return list
                 ? listPackageDeploys(deploys, logger, ref)
-                : runPackageDeploys(deploys, (input) => new SvnDeploy(resolveDeployOptions({
+                : runPackageDeploys(deploys, (input) => runDeploy({
                     ...input,
                     svnUsername: getString(values, 'svn-username'),
                     force: getBoolean(values, 'force'),
-                }), logger).run(), logger, ref);
+                }, logger, svnRunner), logger, ref);
         }
-        const options = resolveDeployOptions(getDeployInputFromArgs({ values, positionals, cwd }));
-        const result = await new SvnDeploy(options, logger).run();
+        const result = await runDeploy(getDeployInputFromArgs({ values, positionals, cwd }), logger, svnRunner);
         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

@@ -22,6 +22,14 @@ 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. */

package/dist/commands/package-deploys.js

@@ -78,6 +78,11 @@ 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 {

package/dist/commands/sign.d.ts

@@ -1,10 +1,15 @@
+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>;
 }
 declare const _default: {
     name: string;
@@ -12,6 +17,10 @@ declare const _default: {
     summary: string;
     help: string;
     options: {
+        format: {
+            type: "string";
+            multiple: true;
+        };
         force: {
             type: "boolean";
         };