@red-hat-developer-hub/e2e-test-utils 2.1.14 → 2.1.16

package/dist/secrets/bitwarden.js

@@ -1,25 +1,27 @@
 import { runCommand } from "./command.js";
+import { rm } from "node:fs/promises";
+import path from "node:path";
 import { getCollectionMapping, } from "./config.js";
+import { createTemporarySecretFile } from "./temporary-secret.js";
 export class BitwardenClient {
     command;
     env;
     runner;
+    removeTemporaryDirectory;
+    sessionCheck;
+    collections = new Map();
+    itemCollections = new Map();
     constructor(options = {}) {
         this.command = options.command ?? "bw";
         this.env = { ...process.env, ...options.env };
         this.runner = options.runner ?? runCommand;
+        this.removeTemporaryDirectory =
+            options.removeTemporaryDirectory ??
+                ((directory) => rm(directory, { recursive: true, force: true }));
     }
     async read(collectionId, selectors) {
         const mapping = getCollectionMapping(collectionId);
-        if (!this.env.BW_SESSION?.trim()) {
-            throw new Error("BW_SESSION is required and must contain an unlocked Bitwarden session");
-        }
-        await this.runOrThrow(["--version"], "Bitwarden CLI is unavailable");
-        const status = await this.runOrThrow(["status"], "Bitwarden session status could not be checked");
-        const statusJson = parseJson(status, "Bitwarden status");
-        if (!isRecord(statusJson) || statusJson.status !== "unlocked") {
-            throw new Error("BW_SESSION is missing or Bitwarden is not unlocked");
-        }
+        await this.ensureSession();
         await this.runOrThrow(["sync"], "Bitwarden sync failed");
         const collection = await this.resolveCollection(mapping.bitwardenCollection);
         const result = [];
@@ -39,7 +41,133 @@ export class BitwardenClient {
         }
         return result;
     }
+    async readItem(collectionId, name) {
+        const item = await this.findItem(collectionId, name);
+        if (!item)
+            throw new Error(`Bitwarden item not found: ${name}`);
+        return item;
+    }
+    async findItem(collectionId, name) {
+        const mapping = getCollectionMapping(collectionId);
+        await this.ensureSession();
+        await this.runOrThrow(["sync"], "Bitwarden sync failed");
+        const collection = await this.resolveCollection(mapping.bitwardenCollection);
+        const listed = await this.runOrThrow(["list", "items", "--collectionid", collection.id, "--search", name], `Bitwarden item listing failed for ${name}`);
+        const values = parseJson(listed, `Bitwarden item list for ${name}`);
+        if (!Array.isArray(values)) {
+            throw new Error(`Bitwarden returned an invalid item list for ${name}`);
+        }
+        const matches = [];
+        for (const value of values) {
+            if (isRecord(value) &&
+                typeof value.name === "string" &&
+                value.name !== name)
+                continue;
+            if (!isRecord(value) || typeof value.id !== "string" || !value.id) {
+                throw new Error(`Bitwarden returned an item without an id for ${name}`);
+            }
+            const item = isCompleteItem(value, true)
+                ? await this.parseItem(value, value.id, collection, name, true)
+                : await this.readItemById(value.id, collection, name);
+            if (item.name === name)
+                matches.push(item);
+        }
+        if (matches.length === 0)
+            return undefined;
+        if (matches.length > 1)
+            throw new Error(`Bitwarden item name is ambiguous: ${name}`);
+        return matches[0];
+    }
+    async createItem(collectionId, name, value, storage) {
+        const mapping = getCollectionMapping(collectionId);
+        await this.ensureSession();
+        await this.runOrThrow(["sync"], "Bitwarden sync failed");
+        const collection = await this.resolveCollection(mapping.bitwardenCollection);
+        const payload = this.itemPayload({
+            name,
+            collection,
+            notes: storage === "note" ? value : null,
+            attachments: [],
+        });
+        const encoded = this.encodeItem(payload);
+        const created = await this.runOrThrow(["create", "item"], `Bitwarden item creation failed for ${name}`, encoded);
+        const createdValue = parseJson(created, `Bitwarden item creation for ${name}`);
+        const createdId = isRecord(createdValue) && typeof createdValue.id === "string"
+            ? createdValue.id
+            : undefined;
+        if (!createdId) {
+            throw new Error(`Bitwarden item creation returned no id: ${name}`);
+        }
+        try {
+            if (storage === "attachment") {
+                await this.createAttachment(createdId, attachmentFileName(name), value, name);
+            }
+            const verified = storage === "note" &&
+                isRecord(createdValue) &&
+                isCompleteItem(createdValue, true)
+                ? await this.parseItem(createdValue, createdId, collection, name, true)
+                : await this.refreshItemById(createdId, collection, name);
+            if (verified.value !== value || verified.storage !== storage) {
+                throw new Error(`Bitwarden read-back verification failed: ${name}`);
+            }
+            return verified;
+        }
+        catch (error) {
+            try {
+                await this.deleteItemById(createdId, name);
+            }
+            catch {
+                throw new Error(`Bitwarden item creation failed and cleanup failed: ${name}`, { cause: error });
+            }
+            throw error;
+        }
+    }
+    async deleteItem(item) {
+        await this.ensureSession();
+        const collection = this.collectionForItem(item);
+        await this.deleteItemById(item.id, item.name);
+        await this.runOrThrow(["sync"], "Bitwarden sync failed");
+        if (await this.findItemInCollection(collection, item.name)) {
+            throw new Error(`Bitwarden item deletion could not be verified: ${item.name}`);
+        }
+    }
+    async updateItem(item, value, storage = item.storage) {
+        const current = await this.refreshItem(item);
+        if (current.revisionDate !== item.revisionDate) {
+            throw new Error(`Bitwarden item changed before update: ${item.name}`);
+        }
+        item = current;
+        if (item.value === value && item.storage === storage)
+            return item;
+        if (item.storage === storage && item.storage === "note") {
+            const edited = await this.editItem(item.id, this.updatedItemPayload(item, value, "note"), item.name);
+            const updatedValue = parseJson(edited, `Bitwarden update for ${item.name}`);
+            const updated = await this.parseItem(updatedValue, item.id, this.collectionForItem(item), item.name, true);
+            if (updated.value !== value || updated.storage !== "note") {
+                throw new Error(`Bitwarden read-back verification failed: ${item.name}`);
+            }
+            return updated;
+        }
+        if (item.storage === storage && item.storage === "attachment") {
+            return this.updateAttachment(item, value);
+        }
+        if (storage === "attachment") {
+            return this.convertNoteToAttachment(item, value);
+        }
+        return this.convertAttachmentToNote(item, value);
+    }
     async resolveCollection(collectionName) {
+        const cached = this.collections.get(collectionName);
+        if (cached)
+            return cached;
+        const pending = this.loadCollection(collectionName).catch((error) => {
+            this.collections.delete(collectionName);
+            throw error;
+        });
+        this.collections.set(collectionName, pending);
+        return pending;
+    }
+    async loadCollection(collectionName) {
         const result = await this.runOrThrow(["list", "collections"], "Bitwarden collection listing failed");
         const values = parseJson(result, "Bitwarden collection list");
         if (!Array.isArray(values)) {
@@ -77,7 +205,7 @@ export class BitwardenClient {
         if (!Array.isArray(values)) {
             throw new Error(`Bitwarden returned an invalid item list for ${selector.prefix}`);
         }
-        const ids = values.flatMap((value) => {
+        const listedItems = values.flatMap((value) => {
             if (!isRecord(value) ||
                 typeof value.id !== "string" ||
                 value.id.length === 0) {
@@ -87,64 +215,339 @@ export class BitwardenClient {
                 !value.name.startsWith(selector.prefix)) {
                 return [];
             }
-            return [value.id];
+            return [{ id: value.id, value }];
         });
-        if (new Set(ids).size !== ids.length) {
+        if (new Set(listedItems.map(({ id }) => id)).size !== listedItems.length) {
             throw new Error(`Duplicate Bitwarden item id for ${selector.prefix}`);
         }
         const items = [];
-        for (const id of ids) {
-            const itemResult = await this.runOrThrow(["get", "item", id], `Bitwarden item read failed for ${selector.prefix}`);
-            const value = parseJson(itemResult, `Bitwarden item ${id}`);
-            if (!isRecord(value)) {
-                throw new Error(`Bitwarden returned an invalid item for ${selector.prefix}`);
-            }
-            if (typeof value.name !== "string" ||
-                !value.name.startsWith(selector.prefix)) {
+        for (const listed of listedItems) {
+            const item = isCompleteItem(listed.value, false)
+                ? await this.parseItem(listed.value, listed.id, collection, selector.prefix, false)
+                : await this.readItemById(listed.id, collection, selector.prefix, false);
+            if (!item.name.startsWith(selector.prefix))
                 continue;
+            items.push({
+                id: item.id,
+                name: item.name,
+                value: item.value,
+                selector,
+            });
+        }
+        return items;
+    }
+    async ensureSession() {
+        if (!this.env.BW_SESSION?.trim()) {
+            throw new Error("BW_SESSION is required and must contain an unlocked Bitwarden session");
+        }
+        if (!this.sessionCheck) {
+            this.sessionCheck = this.checkSession().catch((error) => {
+                this.sessionCheck = undefined;
+                throw error;
+            });
+        }
+        await this.sessionCheck;
+    }
+    async checkSession() {
+        await this.runOrThrow(["--version"], "Bitwarden CLI is unavailable");
+        const status = await this.runOrThrow(["status"], "Bitwarden session status could not be checked");
+        const statusJson = parseJson(status, "Bitwarden status");
+        if (!isRecord(statusJson) || statusJson.status !== "unlocked") {
+            throw new Error("BW_SESSION is missing or Bitwarden is not unlocked");
+        }
+    }
+    async readItemById(id, collection, label, requireRevision = true) {
+        const result = await this.runOrThrow(["get", "item", id], `Bitwarden item read failed for ${label}`);
+        return this.parseItem(parseJson(result, `Bitwarden item ${id}`), id, collection, label, requireRevision);
+    }
+    async parseItem(input, id, collection, label, requireRevision) {
+        const value = input;
+        if (!isRecord(value)) {
+            throw new Error(`Bitwarden returned an invalid item for ${label}`);
+        }
+        if (value.id !== id ||
+            typeof value.name !== "string" ||
+            value.type !== 2 ||
+            !Array.isArray(value.collectionIds) ||
+            value.collectionIds.length !== 1 ||
+            value.collectionIds[0] !== collection.id ||
+            value.organizationId !== collection.organizationId ||
+            (requireRevision &&
+                (typeof value.revisionDate !== "string" ||
+                    value.revisionDate.length === 0))) {
+            throw new Error(`Bitwarden item ${typeof value.name === "string" ? value.name : id} is not a valid secure note in the selected collection`);
+        }
+        const attachment = parseAttachment(value.attachments, label);
+        if (attachment === undefined) {
+            if (typeof value.notes !== "string") {
+                throw new Error(`Bitwarden secure note has no value: ${value.name}`);
             }
-            if (value.id !== id ||
-                value.type !== 2 ||
-                !Array.isArray(value.collectionIds) ||
-                value.collectionIds.length !== 1 ||
-                value.collectionIds[0] !== collection.id ||
-                value.organizationId !== collection.organizationId) {
-                throw new Error(`Bitwarden item ${typeof value.name === "string" ? value.name : id} is not a secure note in the selected collection`);
-            }
-            const attachment = parseAttachment(value.attachments, selector.prefix);
-            if (attachment === undefined) {
-                if (typeof value.notes !== "string") {
-                    throw new Error(`Bitwarden item ${value.name} is not a secure note in the selected collection`);
-                }
-                items.push({
-                    id,
-                    name: value.name,
-                    value: value.notes,
-                    selector,
-                });
+            const item = {
+                id,
+                name: value.name,
+                value: value.notes,
+                storage: "note",
+                revisionDate: typeof value.revisionDate === "string" ? value.revisionDate : "",
+                raw: value,
+                attachments: [],
+            };
+            this.itemCollections.set(id, collection);
+            return item;
+        }
+        if (value.notes !== null &&
+            (typeof value.notes !== "string" || value.notes.length > 0)) {
+            throw new Error(requireRevision
+                ? `Bitwarden item notes must be empty with an attachment: ${value.name}`
+                : `Bitwarden item notes must be null or empty when an attachment is present for ${label}`);
+        }
+        if (attachment.fileName !== attachmentFileName(value.name)) {
+            throw new Error(`Bitwarden attachment filename does not match the item basename: ${value.name}`);
+        }
+        const attachmentResult = await this.runOrThrow(["get", "attachment", attachment.fileName, "--itemid", id, "--raw"], `Bitwarden attachment read failed for ${label}`);
+        const item = {
+            id,
+            name: value.name,
+            value: attachmentResult.stdout,
+            storage: "attachment",
+            revisionDate: typeof value.revisionDate === "string" ? value.revisionDate : "",
+            raw: value,
+            attachments: [attachment],
+            attachment,
+        };
+        this.itemCollections.set(id, collection);
+        return item;
+    }
+    async refreshItem(item) {
+        await this.runOrThrow(["sync"], "Bitwarden sync failed");
+        return this.readItemById(item.id, this.collectionForItem(item), item.name);
+    }
+    async refreshItemById(id, collection, name) {
+        await this.runOrThrow(["sync"], "Bitwarden sync failed");
+        return this.readItemById(id, collection, name);
+    }
+    async findItemInCollection(collection, name) {
+        const listed = await this.runOrThrow(["list", "items", "--collectionid", collection.id, "--search", name], `Bitwarden item listing failed for ${name}`);
+        const values = parseJson(listed, `Bitwarden item list for ${name}`);
+        if (!Array.isArray(values)) {
+            throw new Error(`Bitwarden returned an invalid item list for ${name}`);
+        }
+        for (const value of values) {
+            if (isRecord(value) &&
+                typeof value.name === "string" &&
+                value.name !== name)
                 continue;
+            if (!isRecord(value) || typeof value.id !== "string" || !value.id) {
+                throw new Error(`Bitwarden returned an item without an id for ${name}`);
             }
-            if (value.notes !== null &&
-                (typeof value.notes !== "string" || value.notes.length > 0)) {
-                throw new Error(`Bitwarden item notes must be null or empty when an attachment is present for ${selector.prefix}`);
+            const item = isCompleteItem(value, true)
+                ? await this.parseItem(value, value.id, collection, name, true)
+                : await this.readItemById(value.id, collection, name);
+            if (item.name === name)
+                return item;
+        }
+        return undefined;
+    }
+    collectionForItem(item) {
+        const collection = this.itemCollections.get(item.id);
+        if (!collection) {
+            throw new Error("Bitwarden collection must be loaded before changing an item");
+        }
+        return collection;
+    }
+    async deleteItemById(id, name) {
+        await this.runOrThrow(["delete", "item", id], `Bitwarden item deletion failed for ${name}`);
+    }
+    itemPayload(options) {
+        return {
+            type: 2,
+            name: options.name,
+            notes: options.notes,
+            attachments: options.attachments,
+            collectionIds: [options.collection.id],
+            organizationId: options.collection.organizationId,
+            secureNote: { type: 0 },
+            login: null,
+            card: null,
+            identity: null,
+        };
+    }
+    updatedItemPayload(item, value, storage) {
+        return {
+            ...item.raw,
+            name: item.name,
+            notes: storage === "note" ? value : null,
+            attachments: [],
+            type: 2,
+            collectionIds: item.raw.collectionIds,
+            organizationId: item.raw.organizationId,
+            secureNote: { type: 0 },
+            login: null,
+            card: null,
+            identity: null,
+        };
+    }
+    encodeItem(payload) {
+        return Buffer.from(JSON.stringify(payload), "utf8").toString("base64");
+    }
+    async updateAttachment(item, value) {
+        if (!item.attachment) {
+            throw new Error(`Bitwarden attachment metadata missing: ${item.name}`);
+        }
+        try {
+            await this.runOrThrow(["delete", "attachment", item.attachment.id], `Bitwarden attachment update failed for ${item.name}`);
+            await this.createAttachment(item.id, item.attachment.fileName, value, item.name);
+            const updated = await this.refreshItem(item);
+            if (updated.value !== value) {
+                throw new Error(`Bitwarden read-back verification failed: ${item.name}`);
             }
-            if (attachment.fileName !== attachmentFileName(value.name)) {
-                throw new Error(`Bitwarden attachment filename does not match the item basename for ${selector.prefix}`);
+            return updated;
+        }
+        catch (error) {
+            await this.restoreAttachment(item);
+            if (error instanceof Error &&
+                /read-back verification failed/.test(error.message)) {
+                throw error;
             }
-            const attachmentResult = await this.runOrThrow(["get", "attachment", attachment.fileName, "--itemid", id, "--raw"], `Bitwarden attachment read failed for ${selector.prefix}`);
-            items.push({
-                id,
-                name: value.name,
-                value: attachmentResult.stdout,
-                selector,
+            throw new Error(`Bitwarden attachment update failed: ${item.name}`, {
+                cause: error,
             });
         }
-        return items;
     }
-    async runOrThrow(args, message) {
+    async convertNoteToAttachment(item, value) {
+        let attachmentUploaded = false;
+        try {
+            await this.editItem(item.id, this.updatedItemPayload(item, value, "attachment"), item.name);
+            await this.createAttachment(item.id, attachmentFileName(item.name), value, item.name);
+            attachmentUploaded = true;
+            const updated = await this.refreshItem(item);
+            if (updated.storage !== "attachment" || updated.value !== value) {
+                throw new Error(`Bitwarden read-back verification failed: ${item.name}`);
+            }
+            return updated;
+        }
+        catch (error) {
+            let attachmentCleanupError;
+            if (attachmentUploaded) {
+                try {
+                    await this.removeUploadedAttachment(item);
+                }
+                catch (cleanupError) {
+                    attachmentCleanupError = cleanupError;
+                }
+            }
+            try {
+                await this.restoreNote(item);
+            }
+            catch {
+                throw new Error(`Bitwarden update failed and note rollback failed: ${item.name}`, { cause: error });
+            }
+            if (attachmentCleanupError !== undefined) {
+                throw new Error(`Bitwarden update failed and attachment rollback failed: ${item.name}`, { cause: error });
+            }
+            throw error;
+        }
+    }
+    async removeUploadedAttachment(item) {
+        const attachment = (await this.readAttachmentMetadata(item)).find(({ fileName }) => fileName === attachmentFileName(item.name));
+        if (!attachment)
+            return;
+        await this.runOrThrow(["delete", "attachment", attachment.id], `Bitwarden attachment rollback failed for ${item.name}`);
+    }
+    async convertAttachmentToNote(item, value) {
+        if (!item.attachment) {
+            throw new Error(`Bitwarden attachment metadata missing: ${item.name}`);
+        }
+        try {
+            await this.runOrThrow(["delete", "attachment", item.attachment.id], `Bitwarden attachment update failed for ${item.name}`);
+            await this.editItem(item.id, this.updatedItemPayload(item, value, "note"), item.name);
+            const updated = await this.refreshItem(item);
+            if (updated.storage !== "note" || updated.value !== value) {
+                throw new Error(`Bitwarden read-back verification failed: ${item.name}`);
+            }
+            return updated;
+        }
+        catch (error) {
+            await this.restoreAttachment(item);
+            throw error;
+        }
+    }
+    async restoreNote(item) {
+        try {
+            await this.editItem(item.id, this.updatedItemPayload(item, item.value, "note"), item.name);
+        }
+        catch {
+            throw new Error(`Bitwarden update failed and note rollback failed: ${item.name}`);
+        }
+    }
+    async restoreAttachment(item) {
+        if (!item.attachment) {
+            throw new Error(`Bitwarden attachment metadata missing: ${item.name}`);
+        }
+        try {
+            await this.editItem(item.id, this.updatedItemPayload(item, item.value, "attachment"), item.name);
+            const attachments = await this.readAttachmentMetadata(item);
+            for (const attachment of attachments) {
+                if (attachment.fileName === item.attachment.fileName) {
+                    await this.runOrThrow(["delete", "attachment", attachment.id], `Bitwarden attachment rollback failed for ${item.name}`);
+                }
+            }
+            await this.createAttachment(item.id, item.attachment.fileName, item.value, item.name);
+        }
+        catch {
+            throw new Error(`Bitwarden update failed and attachment rollback failed: ${item.name}`);
+        }
+    }
+    async readAttachmentMetadata(item) {
+        const result = await this.runOrThrow(["get", "item", item.id], `Bitwarden item read failed for ${item.name}`);
+        const value = parseJson(result, `Bitwarden item ${item.id}`);
+        if (!isRecord(value) || value.id !== item.id) {
+            throw new Error(`Bitwarden item read-back failed: ${item.name}`);
+        }
+        const attachment = parseAttachment(value.attachments, item.name);
+        return attachment === undefined ? [] : [attachment];
+    }
+    async editItem(id, payload, name) {
+        const encoded = this.encodeItem(payload);
+        return this.runOrThrow(["edit", "item", id], `Bitwarden update failed for ${name}`, encoded);
+    }
+    async createAttachment(itemId, fileName, value, name) {
+        if (path.basename(fileName) !== fileName) {
+            throw new Error(`Bitwarden attachment filename is unsafe: ${name}`);
+        }
+        const temporary = await createTemporarySecretFile(value, fileName, {
+            removeDirectory: this.removeTemporaryDirectory,
+        });
+        let operationError;
+        try {
+            await this.runOrThrow(["create", "attachment", "--file", temporary.path, "--itemid", itemId], `Bitwarden attachment update failed for ${name}`);
+        }
+        catch (error) {
+            operationError = error;
+        }
+        let cleanupError;
+        try {
+            await temporary.remove();
+        }
+        catch (error) {
+            cleanupError = error;
+        }
+        if (operationError !== undefined) {
+            if (cleanupError !== undefined) {
+                throw new Error(`Bitwarden attachment operation failed and temporary cleanup failed: ${name}`, { cause: new AggregateError([operationError, cleanupError]) });
+            }
+            throw operationError;
+        }
+        if (cleanupError !== undefined) {
+            throw new Error(`Bitwarden attachment operation may have succeeded but temporary cleanup failed: ${name}`, { cause: cleanupError });
+        }
+    }
+    async runOrThrow(args, message, input) {
         let result;
         try {
-            result = await this.runner(this.command, args, { env: this.env });
+            result = await this.runner(this.command, args, {
+                env: this.env,
+                ...(input === undefined ? {} : { input }),
+            });
         }
         catch {
             throw new Error(message);
@@ -165,6 +568,15 @@ function parseJson(result, label) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isCompleteItem(value, requireRevision) {
+    return (typeof value.id === "string" &&
+        "name" in value &&
+        "type" in value &&
+        "collectionIds" in value &&
+        "organizationId" in value &&
+        "notes" in value &&
+        (!requireRevision || "revisionDate" in value));
+}
 function parseAttachment(value, prefix) {
     if (value === undefined || value === null)
         return undefined;

package/dist/secrets/cli.d.ts

@@ -1,11 +1,58 @@
 #!/usr/bin/env node
+import { type MutationPlan } from "./mutation.js";
 export interface ExecCliArguments {
     command: "exec";
     profilePath: string;
     workspaces: string[];
     executable: string;
     args: string[];
+    streamSecrets?: boolean;
 }
-export declare function parseCliArguments(argv: readonly string[]): ExecCliArguments;
+export type HelpTopic = "root" | "exec" | "create" | "update" | "delete" | "describe" | "list" | "gsm-login" | "gsm-clean";
+export interface HelpCliArguments {
+    command: "help";
+    topic: HelpTopic;
+}
+interface MutationCliBase {
+    collection: string;
+    bitwardenPath: string;
+    dryRun: boolean;
+    gsmTimeoutMs?: number;
+}
+export interface CreateCliArguments extends MutationCliBase {
+    command: "create";
+    fromFile?: string;
+    fromStdin: boolean;
+    allowEmpty: boolean;
+    force: boolean;
+}
+export interface UpdateCliArguments extends MutationCliBase {
+    command: "update";
+    fromFile?: string;
+    fromStdin: boolean;
+    allowEmpty: boolean;
+}
+export interface DeleteCliArguments extends MutationCliBase {
+    command: "delete";
+    force: boolean;
+}
+export interface DescribeCliArguments {
+    command: "describe";
+    collection: string;
+    bitwardenPath: string;
+    output: "text" | "json";
+}
+export interface ListCliArguments {
+    command: "list";
+    collection?: string;
+    output: "text" | "json";
+}
+export type CliArguments = HelpCliArguments | ExecCliArguments | CreateCliArguments | UpdateCliArguments | DeleteCliArguments | DescribeCliArguments | ListCliArguments | {
+    command: "gsm-login" | "gsm-clean";
+};
+export declare function parseCliArguments(argv: readonly string[]): CliArguments;
+export declare function getHelpText(topic: HelpTopic): string;
 export declare function main(argv?: readonly string[]): Promise<number>;
+export declare function formatMutationResult(state: "dry-run" | "applied", plan: MutationPlan): string;
+export {};
 //# sourceMappingURL=cli.d.ts.map

package/dist/secrets/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/secrets/cli.ts"],"names":[],"mappings":";AASA,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAUD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,gBAAgB,CAkD3E;AAED,wBAAsB,IAAI,CACxB,IAAI,GAAE,SAAS,MAAM,EAA0B,GAC9C,OAAO,CAAC,MAAM,CAAC,CAwBjB"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/secrets/cli.ts"],"names":[],"mappings":";AAeA,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAIvB,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,MAAM,GACN,WAAW,GACX,WAAW,CAAC;AAEhB,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC;CAClB;AAED,UAAU,eAAe;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD,OAAO,EAAE,QAAQ,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD,OAAO,EAAE,QAAQ,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD,OAAO,EAAE,QAAQ,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,UAAU,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,YAAY,GACpB,gBAAgB,GAChB,gBAAgB,GAChB,kBAAkB,GAClB,kBAAkB,GAClB,kBAAkB,GAClB,oBAAoB,GACpB,gBAAgB,GAChB;IAAE,OAAO,EAAE,WAAW,GAAG,WAAW,CAAA;CAAE,CAAC;AA6F3C,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAgBvE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAEpD;AA2SD,wBAAsB,IAAI,CACxB,IAAI,GAAE,SAAS,MAAM,EAA0B,GAC9C,OAAO,CAAC,MAAM,CAAC,CAoFjB;AAoBD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,IAAI,EAAE,YAAY,GACjB,MAAM,CASR"}