@salesforce/packaging 4.12.0 → 4.13.0

package/lib/exported.d.ts

@@ -2,3 +2,6 @@ export * from './interfaces';
 export * from './package';
 export * from './package1';
 export * from './utils';
+export * from './package/packageBundle';
+export * from './package/packageBundleVersionCreate';
+export * from './package/packageBundleInstall';

package/lib/exported.js

@@ -24,4 +24,7 @@ __exportStar(require("./interfaces"), exports);
 __exportStar(require("./package"), exports);
 __exportStar(require("./package1"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./package/packageBundle"), exports);
+__exportStar(require("./package/packageBundleVersionCreate"), exports);
+__exportStar(require("./package/packageBundleInstall"), exports);
 //# sourceMappingURL=exported.js.map

package/lib/interfaces/bundleInterfacesAndType.d.ts

@@ -0,0 +1,33 @@
+import { Nullable } from '@salesforce/ts-types';
+import { Connection, SfProject } from '@salesforce/core';
+import { Duration } from '@salesforce/kit';
+import { SaveResult } from '@jsforce/jsforce-node';
+export type BundleCreateOptions = {
+    BundleName: string;
+    Description: string;
+};
+export type BundleVersionCreateOptions = {
+    connection: Connection;
+    project: SfProject;
+    PackageBundle: string;
+    MajorVersion: string;
+    MinorVersion: string;
+    Ancestor: Nullable<string>;
+    BundleVersionComponentsPath: string;
+    Description?: string;
+    polling?: {
+        timeout: Duration;
+        frequency: Duration;
+    };
+};
+export type BundleInstallOptions = {
+    connection: Connection;
+    project: SfProject;
+    PackageBundleVersion: string;
+    DevelopmentOrganization: string;
+    polling?: {
+        timeout: Duration;
+        frequency: Duration;
+    };
+};
+export type BundleSaveResult = SaveResult;

package/lib/interfaces/bundleInterfacesAndType.js

@@ -0,0 +1,9 @@
+"use strict";
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=bundleInterfacesAndType.js.map

package/lib/interfaces/bundleSObjects.d.ts

@@ -0,0 +1,146 @@
+import { Nullable } from '@salesforce/ts-types';
+import { BundleEntry } from '@salesforce/schemas';
+import type { Schema } from '@jsforce/jsforce-node';
+export { BundleEntry };
+export type QueryRecord = Schema & {
+    Id: string;
+    PackageBundle?: {
+        Id: string;
+        BundleName: string;
+        Description?: string;
+        IsDeleted: boolean;
+        CreatedDate: string;
+        CreatedById: string;
+        LastModifiedDate: string;
+        LastModifiedById: string;
+        SystemModstamp: string;
+    };
+    VersionName: string;
+    MajorVersion: string;
+    MinorVersion: string;
+    IsReleased: boolean;
+    Ancestor?: {
+        Id: string;
+        PackageBundle?: {
+            Id: string;
+            BundleName: string;
+            Description?: string;
+            IsDeleted: boolean;
+            CreatedDate: string;
+            CreatedById: string;
+            LastModifiedDate: string;
+            LastModifiedById: string;
+            SystemModstamp: string;
+        };
+        VersionName: string;
+        MajorVersion: string;
+        MinorVersion: string;
+        IsReleased: boolean;
+    };
+};
+export type AncestorRecord = {
+    Id: string;
+    PackageBundle?: {
+        Id: string;
+        BundleName: string;
+        Description?: string;
+        IsDeleted: boolean;
+        CreatedDate: string;
+        CreatedById: string;
+        LastModifiedDate: string;
+        LastModifiedById: string;
+        SystemModstamp: string;
+    };
+    VersionName: string;
+    MajorVersion: string;
+    MinorVersion: string;
+    IsReleased: boolean;
+};
+export declare namespace BundleSObjects {
+    type Bundle = {
+        BundleName: string;
+        Description?: string;
+        Id: string;
+        IsDeleted: boolean;
+        CreatedDate: string;
+        CreatedById: string;
+        LastModifiedDate: string;
+        LastModifiedById: string;
+        SystemModstamp: string;
+    };
+    type BundleVersion = {
+        Id: string;
+        PackageBundle: Bundle;
+        VersionName: string;
+        MajorVersion: string;
+        MinorVersion: string;
+        Ancestor: Nullable<BundleVersion>;
+        IsReleased: boolean;
+        CreatedDate: string;
+        CreatedById: string;
+        LastModifiedDate: string;
+        LastModifiedById: string;
+    };
+    type PkgBundleVersionCreateReq = {
+        PackageBundleId: string;
+        VersionName: string;
+        MajorVersion: string;
+        MinorVersion: string;
+        BundleVersionComponents: string;
+        Ancestor?: string | null;
+    };
+    type PackageBundleVersionCreateRequestResult = PkgBundleVersionCreateReq & {
+        Id: string;
+        PackageBundleVersionId: string;
+        RequestStatus: PkgBundleVersionCreateReqStatus;
+        CreatedDate: string;
+        CreatedById: string;
+        Error?: string[];
+    };
+    enum PkgBundleVersionCreateReqStatus {
+        queued = "Queued",
+        success = "Success",
+        error = "Error"
+    }
+    enum PkgBundleVersionInstallReqStatus {
+        queued = "Queued",
+        success = "Success",
+        error = "Error"
+    }
+    type PkgBundleVersionQueryRecord = {
+        Id: string;
+        RequestStatus: BundleSObjects.PkgBundleVersionCreateReqStatus;
+        PackageBundle: Bundle;
+        PackageBundleVersion: BundleVersion;
+        VersionName: string;
+        MajorVersion: string;
+        MinorVersion: string;
+        Ancestor: BundleVersion;
+        BundleVersionComponents: string;
+        CreatedDate: string;
+        CreatedById: string;
+        Error?: string[];
+    } & Schema;
+    type PkgBundleVersionInstallReq = {
+        PackageBundleVersionID: string;
+        DevelopmentOrganization: string;
+    };
+    type PkgBundleVersionInstallReqResult = PkgBundleVersionInstallReq & {
+        Id: string;
+        InstallStatus: PkgBundleVersionInstallReqStatus;
+        ValidationError: string;
+        CreatedDate: string;
+        CreatedById: string;
+        Error?: string[];
+    };
+    type PkgBundleVersionInstallQueryRecord = {
+        Id: string;
+        InstallStatus: BundleSObjects.PkgBundleVersionInstallReqStatus;
+        PackageBundleVersionID: string;
+        DevelopmentOrganization: string;
+        ValidationError: string;
+        CreatedDate: string;
+        CreatedById: string;
+        Error?: string[];
+    } & Schema;
+}

package/lib/interfaces/bundleSObjects.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleSObjects = void 0;
+var BundleSObjects;
+(function (BundleSObjects) {
+    let PkgBundleVersionCreateReqStatus;
+    (function (PkgBundleVersionCreateReqStatus) {
+        PkgBundleVersionCreateReqStatus["queued"] = "Queued";
+        PkgBundleVersionCreateReqStatus["success"] = "Success";
+        PkgBundleVersionCreateReqStatus["error"] = "Error";
+    })(PkgBundleVersionCreateReqStatus = BundleSObjects.PkgBundleVersionCreateReqStatus || (BundleSObjects.PkgBundleVersionCreateReqStatus = {}));
+    let PkgBundleVersionInstallReqStatus;
+    (function (PkgBundleVersionInstallReqStatus) {
+        PkgBundleVersionInstallReqStatus["queued"] = "Queued";
+        PkgBundleVersionInstallReqStatus["success"] = "Success";
+        PkgBundleVersionInstallReqStatus["error"] = "Error";
+    })(PkgBundleVersionInstallReqStatus = BundleSObjects.PkgBundleVersionInstallReqStatus || (BundleSObjects.PkgBundleVersionInstallReqStatus = {}));
+})(BundleSObjects || (exports.BundleSObjects = BundleSObjects = {}));
+//# sourceMappingURL=bundleSObjects.js.map

package/lib/interfaces/index.d.ts

@@ -1,2 +1,4 @@
 export * from './packagingInterfacesAndType';
 export * from './packagingSObjects';
+export * from './bundleInterfacesAndType';
+export * from './bundleSObjects';

package/lib/interfaces/index.js

@@ -22,4 +22,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 __exportStar(require("./packagingInterfacesAndType"), exports);
 __exportStar(require("./packagingSObjects"), exports);
+__exportStar(require("./bundleInterfacesAndType"), exports);
+__exportStar(require("./bundleSObjects"), exports);
 //# sourceMappingURL=index.js.map

package/lib/package/index.d.ts

@@ -3,3 +3,6 @@ export * from './packageVersion';
 export * from './subscriberPackageVersion';
 export * from './packagePushUpgrade';
 export { VersionNumber } from './versionNumber';
+export * from './packageBundle';
+export * from './packageBundleVersion';
+export * from './packageBundleInstall';

package/lib/package/index.js

@@ -27,4 +27,7 @@ __exportStar(require("./subscriberPackageVersion"), exports);
 __exportStar(require("./packagePushUpgrade"), exports);
 var versionNumber_1 = require("./versionNumber");
 Object.defineProperty(exports, "VersionNumber", { enumerable: true, get: function () { return versionNumber_1.VersionNumber; } });
+__exportStar(require("./packageBundle"), exports);
+__exportStar(require("./packageBundleVersion"), exports);
+__exportStar(require("./packageBundleInstall"), exports);
 //# sourceMappingURL=index.js.map

package/lib/package/packageBundle.d.ts

@@ -0,0 +1,37 @@
+import { Connection, SfProject } from '@salesforce/core';
+import { SaveResult } from '@jsforce/jsforce-node';
+import { Duration } from '@salesforce/kit';
+import { BundleCreateOptions, BundleSObjects, BundleVersionCreateOptions } from '../interfaces';
+export declare class PackageBundle {
+    /**
+     * Create a new package bundle.
+     *
+     * @param connection - instance of Connection
+     * @param project - instance of SfProject
+     * @param options - options for creating a bundle - see BundleCreateOptions
+     * @returns PackageBundle
+     */
+    static create(connection: Connection, project: SfProject, options: BundleCreateOptions): Promise<{
+        Id: string;
+    }>;
+    /**
+     * Create a new package bundle version.
+     *
+     * @param connection - instance of Connection
+     * @param project - instance of SfProject
+     * @param options - options for creating a bundle version - see BundleVersionCreateOptions
+     * @returns PackageBundle
+     */
+    static createVersion(options: BundleVersionCreateOptions, polling?: {
+        frequency: Duration;
+        timeout: Duration;
+    }): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    static delete(connection: Connection, project: SfProject, idOrAlias: string): Promise<SaveResult>;
+    /**
+     * Returns all the package bundles that are available in the org, up to 10,000. If more records are
+     * needed use the `SF_ORG_MAX_QUERY_LIMIT` env var.
+     *
+     * @param connection
+     */
+    static list(connection: Connection): Promise<BundleSObjects.Bundle[]>;
+}

package/lib/package/packageBundle.js

@@ -0,0 +1,76 @@
+"use strict";
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundle = void 0;
+const core_1 = require("@salesforce/core");
+const kit_1 = require("@salesforce/kit");
+const packageBundleCreate_1 = require("./packageBundleCreate");
+const packageBundleVersion_1 = require("./packageBundleVersion");
+const BundleFields = [
+    'BundleName',
+    'Description',
+    'Id',
+    'IsDeleted',
+    'CreatedDate',
+    'CreatedById',
+    'LastModifiedDate',
+    'LastModifiedById',
+    'SystemModstamp',
+];
+class PackageBundle {
+    /**
+     * Create a new package bundle.
+     *
+     * @param connection - instance of Connection
+     * @param project - instance of SfProject
+     * @param options - options for creating a bundle - see BundleCreateOptions
+     * @returns PackageBundle
+     */
+    static async create(connection, project, options) {
+        return (0, packageBundleCreate_1.createBundle)(connection, project, options);
+    }
+    /**
+     * Create a new package bundle version.
+     *
+     * @param connection - instance of Connection
+     * @param project - instance of SfProject
+     * @param options - options for creating a bundle version - see BundleVersionCreateOptions
+     * @returns PackageBundle
+     */
+    static async createVersion(options, polling = {
+        frequency: kit_1.Duration.seconds(0),
+        timeout: kit_1.Duration.seconds(0),
+    }) {
+        return packageBundleVersion_1.PackageBundleVersion.create(options, polling);
+    }
+    static async delete(connection, project, idOrAlias) {
+        // Check if it's already an ID (1Fl followed by 15 characters)
+        if (/^1Fl.{15}$/.test(idOrAlias)) {
+            return connection.tooling.sobject('PackageBundle').delete(idOrAlias);
+        }
+        // Validate that project is provided when using aliases
+        if (!project) {
+            throw new core_1.SfError('Project instance is required when deleting package bundle by alias');
+        }
+        // eslint-disable-next-line no-param-reassign
+        idOrAlias = project.getPackageBundleIdFromAlias(idOrAlias) ?? idOrAlias;
+        return connection.tooling.sobject('PackageBundle').delete(idOrAlias);
+    }
+    /**
+     * Returns all the package bundles that are available in the org, up to 10,000. If more records are
+     * needed use the `SF_ORG_MAX_QUERY_LIMIT` env var.
+     *
+     * @param connection
+     */
+    static async list(connection) {
+        const query = `select ${BundleFields.join(', ')} from PackageBundle ORDER BY BundleName`;
+        return (await connection.autoFetchQuery(query, { tooling: true }))?.records;
+    }
+}
+exports.PackageBundle = PackageBundle;
+//# sourceMappingURL=packageBundle.js.map

package/lib/package/packageBundleCreate.d.ts

@@ -0,0 +1,7 @@
+import { Connection, SfProject } from '@salesforce/core';
+import { BundleEntry } from '@salesforce/schemas';
+import { BundleCreateOptions } from '../interfaces';
+export declare function createPackageDirEntry(project: SfProject, options: BundleCreateOptions): BundleEntry;
+export declare function createBundle(connection: Connection, project: SfProject, options: BundleCreateOptions): Promise<{
+    Id: string;
+}>;

package/lib/package/packageBundleCreate.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageDirEntry = createPackageDirEntry;
+exports.createBundle = createBundle;
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const core_1 = require("@salesforce/core");
+const bundleUtils_1 = require("../utils/bundleUtils");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_create');
+function createPackageDirEntry(project, options) {
+    return {
+        versionName: 'ver 0.1',
+        versionNumber: '0.1',
+        name: options.BundleName,
+        versionDescription: options.Description,
+    };
+}
+async function createBundle(connection, project, options) {
+    const request = { BundleName: options.BundleName, Description: options.Description };
+    let createResult;
+    try {
+        createResult = await connection.tooling.sobject('PackageBundle').create(request);
+    }
+    catch (err) {
+        const error = err instanceof Error
+            ? err
+            : new Error(typeof err === 'string' ? err : messages.getMessage('failedToCreatePackageBundle'));
+        throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+    }
+    if (!createResult?.success) {
+        throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(new Error(messages.getMessage('failedToCreatePackageBundle'))));
+    }
+    const bundleEntry = createPackageDirEntry(project, options);
+    project.getSfProjectJson().addPackageBundle(bundleEntry);
+    project.getSfProjectJson().addPackageBundleAlias(bundleEntry.name, createResult.id);
+    await project.getSfProjectJson().write();
+    return { Id: createResult.id };
+}
+//# sourceMappingURL=packageBundleCreate.js.map

package/lib/package/packageBundleInstall.d.ts

@@ -0,0 +1,9 @@
+import { Connection, SfProject } from '@salesforce/core';
+import { BundleSObjects, BundleInstallOptions } from '../interfaces';
+export declare class PackageBundleInstall {
+    static getInstallStatus(installRequestId: string, connection: Connection): Promise<BundleSObjects.PkgBundleVersionInstallReqResult>;
+    static getInstallStatuses(connection: Connection, status?: BundleSObjects.PkgBundleVersionInstallReqStatus, createdLastDays?: number): Promise<BundleSObjects.PkgBundleVersionInstallReqResult[]>;
+    static installBundle(connection: Connection, project: SfProject, options: BundleInstallOptions): Promise<BundleSObjects.PkgBundleVersionInstallReqResult>;
+    private static parsePackageBundleVersionId;
+    private static pollInstallStatus;
+}

package/lib/package/packageBundleInstall.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundleInstall = void 0;
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const core_1 = require("@salesforce/core");
+const interfaces_1 = require("../interfaces");
+const bundleUtils_1 = require("../utils/bundleUtils");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_install');
+class PackageBundleInstall {
+    static async getInstallStatus(installRequestId, connection) {
+        try {
+            const result = await connection.tooling.sobject('PkgBundleVersionInstallReq').retrieve(installRequestId);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(messages.getMessage('failedToGetPackageBundleInstallStatus'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+    }
+    static async getInstallStatuses(connection, status, createdLastDays) {
+        let query = 'SELECT Id, InstallStatus, PackageBundleVersionID, DevelopmentOrganization, ValidationError, ' +
+            'CreatedDate, CreatedById ' +
+            'FROM PkgBundleVersionInstallReq';
+        if (status && createdLastDays) {
+            query += ` WHERE InstallStatus = '${status}' AND CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        else if (status) {
+            query += ` WHERE InstallStatus = '${status}'`;
+        }
+        else if (createdLastDays) {
+            query += ` WHERE CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        const queryResult = await connection.autoFetchQuery(query, {
+            tooling: true,
+        });
+        return queryResult.records.map((record) => ({
+            Id: record.Id,
+            InstallStatus: record.InstallStatus,
+            PackageBundleVersionID: record.PackageBundleVersionID ?? '',
+            DevelopmentOrganization: record.DevelopmentOrganization ?? '',
+            ValidationError: record.ValidationError ?? '',
+            CreatedDate: record.CreatedDate ?? '',
+            CreatedById: record.CreatedById ?? '',
+        }));
+    }
+    static async installBundle(connection, project, options) {
+        const packageBundleVersionId = PackageBundleInstall.parsePackageBundleVersionId(options.PackageBundleVersion, project);
+        const request = {
+            PackageBundleVersionID: packageBundleVersionId,
+            DevelopmentOrganization: options.DevelopmentOrganization,
+        };
+        let installResult;
+        try {
+            installResult = await connection.tooling.sobject('PkgBundleVersionInstallReq').create(request);
+        }
+        catch (err) {
+            const error = err instanceof Error
+                ? err
+                : new Error(typeof err === 'string' ? err : messages.getMessage('failedToInstallPackageBundle'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+        if (!installResult?.success) {
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(new Error(messages.getMessage('failedToInstallPackageBundle'))));
+        }
+        if (options.polling) {
+            return PackageBundleInstall.pollInstallStatus(installResult.id, connection, options.polling);
+        }
+        return {
+            Id: installResult.id,
+            PackageBundleVersionID: packageBundleVersionId,
+            DevelopmentOrganization: options.DevelopmentOrganization,
+            InstallStatus: interfaces_1.BundleSObjects.PkgBundleVersionInstallReqStatus.queued,
+            ValidationError: '',
+            CreatedDate: new Date().toISOString(),
+            CreatedById: connection.getUsername() ?? 'unknown',
+        };
+    }
+    static parsePackageBundleVersionId(packageBundleVersion, project) {
+        // Check if it's already an ID (starts with appropriate prefix)
+        if (/^1Q8.{15}$/.test(packageBundleVersion)) {
+            return packageBundleVersion;
+        }
+        // Otherwise, treat it as an alias and resolve it from sfdx-project.json
+        const packageBundleVersionId = project.getPackageBundleIdFromAlias(packageBundleVersion);
+        if (!packageBundleVersionId) {
+            throw new core_1.SfError(messages.getMessage('noPackageBundleVersionFoundWithAlias', [packageBundleVersion]));
+        }
+        return packageBundleVersionId;
+    }
+    static async pollInstallStatus(installRequestId, connection, polling) {
+        if (polling.timeout?.milliseconds <= 0) {
+            return PackageBundleInstall.getInstallStatus(installRequestId, connection);
+        }
+        const pollingClient = await core_1.PollingClient.create({
+            poll: async () => {
+                const status = await PackageBundleInstall.getInstallStatus(installRequestId, connection);
+                if (status.InstallStatus === interfaces_1.BundleSObjects.PkgBundleVersionInstallReqStatus.success) {
+                    return { completed: true, payload: status };
+                }
+                return { completed: false, payload: status };
+            },
+            frequency: polling.frequency,
+            timeout: polling.timeout,
+        });
+        try {
+            return await pollingClient.subscribe();
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                throw new Error('Install request timed out');
+            }
+            throw err;
+        }
+    }
+}
+exports.PackageBundleInstall = PackageBundleInstall;
+//# sourceMappingURL=packageBundleInstall.js.map

package/lib/package/packageBundleVersion.d.ts

@@ -0,0 +1,21 @@
+import { Connection } from '@salesforce/core';
+import { SfProject } from '@salesforce/core';
+import { Duration } from '@salesforce/kit';
+import { BundleVersionCreateOptions, BundleSObjects, PackagingSObjects } from '../interfaces';
+export declare class PackageBundleVersion {
+    static create(options: BundleVersionCreateOptions, polling?: {
+        frequency: Duration;
+        timeout: Duration;
+    }): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    static pollCreateStatus(createPackageVersionRequestId: string, connection: Connection, project: SfProject, polling: {
+        frequency: Duration;
+        timeout: Duration;
+    }): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    static report(connection: Connection, id: string): Promise<BundleSObjects.BundleVersion | null>;
+    static list(connection: Connection): Promise<BundleSObjects.BundleVersion[]>;
+    static getComponentPackages(connection: Connection, id: string): Promise<PackagingSObjects.SubscriberPackageVersion[]>;
+    private static mapRecordToBundleVersion;
+    private static mapPackageBundle;
+    private static mapAncestor;
+    private static mapAncestorPackageBundle;
+}

package/lib/package/packageBundleVersion.js

@@ -0,0 +1,216 @@
+"use strict";
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundleVersion = void 0;
+const core_1 = require("@salesforce/core");
+const kit_1 = require("@salesforce/kit");
+const interfaces_1 = require("../interfaces");
+const bundleUtils_1 = require("../utils/bundleUtils");
+const packageUtils_1 = require("../utils/packageUtils");
+const packageBundleVersionCreate_1 = require("./packageBundleVersionCreate");
+core_1.Messages.importMessagesDirectory(__dirname);
+const bundleVersionMessages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_version');
+class PackageBundleVersion {
+    static async create(options, polling) {
+        const createResult = await packageBundleVersionCreate_1.PackageBundleVersionCreate.createBundleVersion(options.connection, options.project, options);
+        if (polling) {
+            return PackageBundleVersion.pollCreateStatus(createResult.Id, options.connection, options.project, polling).catch((error) => {
+                if (error.name === 'PollingClientTimeout') {
+                    const modifiedError = new core_1.SfError(error.message);
+                    modifiedError.setData({ VersionCreateRequestId: createResult.Id });
+                    modifiedError.message += ` Run 'sf package bundle version create report -i ${createResult.Id}' to check the status.`;
+                    throw (0, packageUtils_1.applyErrorAction)((0, bundleUtils_1.massageErrorMessage)(modifiedError));
+                }
+                throw (0, packageUtils_1.applyErrorAction)((0, bundleUtils_1.massageErrorMessage)(error));
+            });
+        }
+        return createResult;
+    }
+    static async pollCreateStatus(createPackageVersionRequestId, connection, project, polling) {
+        if (polling.timeout?.milliseconds <= 0) {
+            return packageBundleVersionCreate_1.PackageBundleVersionCreate.getCreateStatus(createPackageVersionRequestId, connection);
+        }
+        let remainingWaitTime = polling.timeout;
+        const pollingClient = await core_1.PollingClient.create({
+            poll: async () => {
+                const report = await packageBundleVersionCreate_1.PackageBundleVersionCreate.getCreateStatus(createPackageVersionRequestId, connection);
+                switch (report.RequestStatus) {
+                    case interfaces_1.BundleSObjects.PkgBundleVersionCreateReqStatus.queued:
+                        await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create.enqueued, { ...report, remainingWaitTime });
+                        remainingWaitTime = kit_1.Duration.seconds(remainingWaitTime.seconds - polling.frequency.seconds);
+                        return {
+                            completed: false,
+                            payload: report,
+                        };
+                    case interfaces_1.BundleSObjects.PkgBundleVersionCreateReqStatus.success: {
+                        await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create.success, report);
+                        return { completed: true, payload: report };
+                    }
+                    case interfaces_1.BundleSObjects.PkgBundleVersionCreateReqStatus.error:
+                        await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create.error, report);
+                        return { completed: true, payload: report };
+                }
+            },
+            frequency: polling.frequency,
+            timeout: polling.timeout,
+        });
+        try {
+            return await pollingClient.subscribe();
+        }
+        catch (err) {
+            const report = await packageBundleVersionCreate_1.PackageBundleVersionCreate.getCreateStatus(createPackageVersionRequestId, connection);
+            await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create['timed-out'], report);
+            if (err instanceof Error) {
+                throw (0, packageUtils_1.applyErrorAction)(err);
+            }
+            throw err;
+        }
+    }
+    static async report(connection, id) {
+        const query = `SELECT Id, PackageBundle.Id, PackageBundle.BundleName, VersionName, MajorVersion, MinorVersion, IsReleased, PackageBundle.Description, PackageBundle.IsDeleted, PackageBundle.CreatedDate, PackageBundle.CreatedById, PackageBundle.LastModifiedDate, PackageBundle.LastModifiedById, PackageBundle.SystemModstamp, Ancestor.Id, Ancestor.PackageBundle.Id, Ancestor.PackageBundle.BundleName, Ancestor.VersionName, Ancestor.MajorVersion, Ancestor.MinorVersion, Ancestor.IsReleased, Ancestor.PackageBundle.Description, Ancestor.PackageBundle.IsDeleted, Ancestor.PackageBundle.CreatedDate, Ancestor.PackageBundle.CreatedById, Ancestor.PackageBundle.LastModifiedDate, Ancestor.PackageBundle.LastModifiedById, Ancestor.PackageBundle.SystemModstamp FROM PackageBundleVersion WHERE Id = '${id}'`;
+        const queryResult = await connection.autoFetchQuery(query, { tooling: true });
+        return queryResult.records.length > 0
+            ? PackageBundleVersion.mapRecordToBundleVersion(queryResult.records[0])
+            : null;
+    }
+    static async list(connection) {
+        const query = 'SELECT Id, PackageBundle.Id, PackageBundle.BundleName, VersionName, MajorVersion, MinorVersion, IsReleased, PackageBundle.Description, PackageBundle.IsDeleted, PackageBundle.CreatedDate, PackageBundle.CreatedById, PackageBundle.LastModifiedDate, PackageBundle.LastModifiedById, PackageBundle.SystemModstamp, Ancestor.Id, Ancestor.PackageBundle.Id, Ancestor.PackageBundle.BundleName, Ancestor.VersionName, Ancestor.MajorVersion, Ancestor.MinorVersion, Ancestor.IsReleased, Ancestor.PackageBundle.Description, Ancestor.PackageBundle.IsDeleted, Ancestor.PackageBundle.CreatedDate, Ancestor.PackageBundle.CreatedById, Ancestor.PackageBundle.LastModifiedDate, Ancestor.PackageBundle.LastModifiedById, Ancestor.PackageBundle.SystemModstamp FROM PackageBundleVersion';
+        const queryResult = await connection.autoFetchQuery(query, { tooling: true });
+        return queryResult.records.map((record) => PackageBundleVersion.mapRecordToBundleVersion(record));
+    }
+    static async getComponentPackages(connection, id) {
+        const query = `SELECT Component.Id, Component.Description, Component.PublisherName, Component.MajorVersion, Component.MinorVersion, Component.PatchVersion, Component.BuildNumber, Component.ReleaseState, Component.IsManaged, Component.IsDeprecated, Component.IsPasswordProtected, Component.IsBeta, Component.Package2ContainerOptions, Component.IsSecurityReviewed, Component.IsOrgDependent, Component.AppExchangePackageName, Component.AppExchangeDescription, Component.AppExchangePublisherName, Component.AppExchangeLogoUrl, Component.ReleaseNotesUrl, Component.PostInstallUrl, Component.RemoteSiteSettings, Component.CspTrustedSites, Component.Profiles, Component.Dependencies, Component.InstallValidationStatus, Component.SubscriberPackageId FROM PkgBundleVersionComponent WHERE PackageBundleVersion.Id = '${id}' ORDER BY CreatedDate`;
+        const queryResult = await connection.autoFetchQuery(query, { tooling: true });
+        // Get unique SubscriberPackageIds to query for Names
+        const subscriberPackageIds = [
+            ...new Set(queryResult.records
+                .map((record) => record.Component?.SubscriberPackageId)
+                .filter((packageId) => !!packageId)),
+        ];
+        // Query SubscriberPackage to get Names (one by one due to implementation restriction)
+        const subscriberPackageNames = new Map();
+        const packageQueries = subscriberPackageIds.map(async (packageId) => {
+            try {
+                const packageQuery = `SELECT Id, Name FROM SubscriberPackage WHERE Id='${packageId}'`;
+                const packageQueryResult = await connection.autoFetchQuery(packageQuery, { tooling: true });
+                return {
+                    packageId,
+                    name: packageQueryResult.records.length > 0 ? packageQueryResult.records[0].Name : '',
+                };
+            }
+            catch (error) {
+                // If individual query fails, return empty name for this package
+                return {
+                    packageId,
+                    name: '',
+                };
+            }
+        });
+        const packageResults = await Promise.allSettled(packageQueries);
+        packageResults.forEach((result) => {
+            if (result.status === 'fulfilled') {
+                subscriberPackageNames.set(result.value.packageId, result.value.name);
+            }
+        });
+        return queryResult.records.map((record) => {
+            const component = record.Component;
+            if (!component) {
+                throw new core_1.SfError(bundleVersionMessages.getMessage('componentRecordMissing'));
+            }
+            const packageName = subscriberPackageNames.get(component.SubscriberPackageId) ?? '';
+            return {
+                Id: component.Id,
+                SubscriberPackageId: component.SubscriberPackageId,
+                Name: packageName,
+                Description: component.Description,
+                PublisherName: component.PublisherName,
+                MajorVersion: component.MajorVersion,
+                MinorVersion: component.MinorVersion,
+                PatchVersion: component.PatchVersion,
+                BuildNumber: component.BuildNumber,
+                ReleaseState: component.ReleaseState,
+                IsManaged: component.IsManaged,
+                IsDeprecated: component.IsDeprecated,
+                IsPasswordProtected: component.IsPasswordProtected,
+                IsBeta: component.IsBeta,
+                Package2ContainerOptions: component.Package2ContainerOptions,
+                IsSecurityReviewed: component.IsSecurityReviewed,
+                IsOrgDependent: component.IsOrgDependent,
+                AppExchangePackageName: component.AppExchangePackageName,
+                AppExchangeDescription: component.AppExchangeDescription,
+                AppExchangePublisherName: component.AppExchangePublisherName,
+                AppExchangeLogoUrl: component.AppExchangeLogoUrl,
+                ReleaseNotesUrl: component.ReleaseNotesUrl,
+                PostInstallUrl: component.PostInstallUrl,
+                RemoteSiteSettings: component.RemoteSiteSettings,
+                CspTrustedSites: component.CspTrustedSites,
+                Profiles: component.Profiles,
+                Dependencies: component.Dependencies,
+                InstallValidationStatus: component.InstallValidationStatus,
+            };
+        });
+    }
+    static mapRecordToBundleVersion(record) {
+        return {
+            Id: record.Id,
+            PackageBundle: PackageBundleVersion.mapPackageBundle(record.PackageBundle),
+            VersionName: record.VersionName ?? '',
+            MajorVersion: record.MajorVersion ?? '',
+            MinorVersion: record.MinorVersion ?? '',
+            CreatedDate: record.PackageBundle?.CreatedDate ?? '',
+            CreatedById: record.PackageBundle?.CreatedById ?? '',
+            LastModifiedDate: record.PackageBundle?.LastModifiedDate ?? '',
+            LastModifiedById: record.PackageBundle?.LastModifiedById ?? '',
+            Ancestor: record.Ancestor?.Id ? PackageBundleVersion.mapAncestor(record.Ancestor) : null,
+            IsReleased: record.IsReleased ?? false,
+        };
+    }
+    static mapPackageBundle(packageBundle) {
+        return {
+            Id: packageBundle?.Id ?? '',
+            BundleName: packageBundle?.BundleName ?? '',
+            Description: packageBundle?.Description,
+            IsDeleted: packageBundle?.IsDeleted ?? false,
+            CreatedDate: packageBundle?.CreatedDate ?? '',
+            CreatedById: packageBundle?.CreatedById ?? '',
+            LastModifiedDate: packageBundle?.LastModifiedDate ?? '',
+            LastModifiedById: packageBundle?.LastModifiedById ?? '',
+            SystemModstamp: packageBundle?.SystemModstamp ?? '',
+        };
+    }
+    static mapAncestor(ancestor) {
+        return {
+            Id: ancestor.Id,
+            PackageBundle: PackageBundleVersion.mapAncestorPackageBundle(ancestor.PackageBundle),
+            VersionName: ancestor?.VersionName ?? '',
+            MajorVersion: ancestor?.MajorVersion ?? '',
+            MinorVersion: ancestor?.MinorVersion ?? '',
+            CreatedDate: ancestor.PackageBundle?.CreatedDate ?? '',
+            CreatedById: ancestor.PackageBundle?.CreatedById ?? '',
+            LastModifiedDate: ancestor.PackageBundle?.LastModifiedDate ?? '',
+            LastModifiedById: ancestor.PackageBundle?.LastModifiedById ?? '',
+            Ancestor: null,
+            IsReleased: ancestor.IsReleased ?? false,
+        };
+    }
+    static mapAncestorPackageBundle(packageBundle) {
+        return {
+            Id: packageBundle?.Id ?? '',
+            BundleName: packageBundle?.BundleName ?? '',
+            Description: packageBundle?.Description,
+            IsDeleted: packageBundle?.IsDeleted ?? false,
+            CreatedDate: packageBundle?.CreatedDate ?? '',
+            CreatedById: packageBundle?.CreatedById ?? '',
+            LastModifiedDate: packageBundle?.LastModifiedDate ?? '',
+            LastModifiedById: packageBundle?.LastModifiedById ?? '',
+            SystemModstamp: packageBundle?.SystemModstamp ?? '',
+        };
+    }
+}
+exports.PackageBundleVersion = PackageBundleVersion;
+//# sourceMappingURL=packageBundleVersion.js.map

package/lib/package/packageBundleVersionCreate.d.ts

@@ -0,0 +1,11 @@
+import { Connection, SfProject } from '@salesforce/core';
+import { BundleSObjects, BundleVersionCreateOptions } from '../interfaces';
+export declare class PackageBundleVersionCreate {
+    static getCreateStatus(createPackageVersionRequestId: string, connection: Connection): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    static getCreateStatuses(connection: Connection, status?: BundleSObjects.PkgBundleVersionCreateReqStatus, createdLastDays?: number): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult[]>;
+    static createBundleVersion(connection: Connection, project: SfProject, options: BundleVersionCreateOptions): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    private static readBundleVersionComponents;
+    private static getVersionName;
+    private static parsePackageBundleId;
+    private static getPackageVersion;
+}

package/lib/package/packageBundleVersionCreate.js

@@ -0,0 +1,239 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundleVersionCreate = void 0;
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const fs = __importStar(require("node:fs"));
+const core_1 = require("@salesforce/core");
+const interfaces_1 = require("../interfaces");
+const bundleUtils_1 = require("../utils/bundleUtils");
+const packageBundleVersion_1 = require("./packageBundleVersion");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_version_create');
+class PackageBundleVersionCreate {
+    static async getCreateStatus(createPackageVersionRequestId, connection) {
+        try {
+            const result = await connection.tooling
+                .sobject('PkgBundleVersionCreateReq')
+                .retrieve(createPackageVersionRequestId);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(messages.getMessage('failedToGetPackageBundleVersionCreateStatus'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+    }
+    static async getCreateStatuses(connection, status, createdLastDays) {
+        let query = 'SELECT Id, RequestStatus, PackageBundle.Id, PackageBundle.BundleName, PackageBundleVersion.Id, ' +
+            'VersionName, MajorVersion, MinorVersion, Ancestor.Id, BundleVersionComponents, ' +
+            'CreatedDate, CreatedById ' +
+            'FROM PkgBundleVersionCreateReq';
+        if (status && createdLastDays) {
+            query += ` WHERE RequestStatus = '${status}' AND CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        else if (status) {
+            query += ` WHERE RequestStatus = '${status}'`;
+        }
+        else if (createdLastDays) {
+            query += ` WHERE CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        const queryResult = await connection.autoFetchQuery(query, {
+            tooling: true,
+        });
+        return queryResult.records.map((record) => ({
+            Id: record.Id,
+            RequestStatus: record.RequestStatus,
+            PackageBundleId: record.PackageBundle?.Id ?? '',
+            PackageBundleVersionId: record.PackageBundleVersion?.Id ?? '',
+            VersionName: record.VersionName ?? '',
+            MajorVersion: record.MajorVersion ?? '',
+            MinorVersion: record.MinorVersion ?? '',
+            Ancestor: record.Ancestor?.Id ?? '',
+            BundleVersionComponents: record.BundleVersionComponents ?? '',
+            CreatedDate: record.CreatedDate ?? '',
+            CreatedById: record.CreatedById ?? '',
+        }));
+    }
+    static async createBundleVersion(connection, project, options) {
+        const bundleVersionComponents = PackageBundleVersionCreate.readBundleVersionComponents(options.BundleVersionComponentsPath, project);
+        const packageBundleId = PackageBundleVersionCreate.parsePackageBundleId(options.PackageBundle, project);
+        // Use provided MajorVersion and MinorVersion if they are not empty strings, otherwise get from bundle configuration
+        const version = options.MajorVersion && options.MinorVersion
+            ? { MajorVersion: options.MajorVersion, MinorVersion: options.MinorVersion }
+            : await PackageBundleVersionCreate.getPackageVersion(options, project, connection);
+        const request = {
+            PackageBundleId: packageBundleId,
+            VersionName: PackageBundleVersionCreate.getVersionName(options.PackageBundle, version.MajorVersion, version.MinorVersion),
+            MajorVersion: version.MajorVersion,
+            MinorVersion: version.MinorVersion,
+            BundleVersionComponents: JSON.stringify(bundleVersionComponents),
+            ...(options.Ancestor ? { Ancestor: options.Ancestor } : {}),
+        };
+        let createResult;
+        try {
+            createResult = await connection.tooling.sobject('PkgBundleVersionCreateReq').create(request);
+        }
+        catch (err) {
+            const error = err instanceof Error
+                ? err
+                : new Error(typeof err === 'string' ? err : messages.getMessage('failedToCreatePackageBundleVersion'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+        if (!createResult?.success) {
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(new Error(messages.getMessage('failedToCreatePackageBundleVersion'))));
+        }
+        if (options.polling) {
+            return packageBundleVersion_1.PackageBundleVersion.pollCreateStatus(createResult.id, connection, project, options.polling);
+        }
+        return {
+            Id: createResult.id,
+            PackageBundleVersionId: createResult.id,
+            PackageBundleId: packageBundleId,
+            VersionName: PackageBundleVersionCreate.getVersionName(options.PackageBundle, version.MajorVersion, version.MinorVersion),
+            MajorVersion: version.MajorVersion,
+            MinorVersion: version.MinorVersion,
+            BundleVersionComponents: JSON.stringify(bundleVersionComponents),
+            RequestStatus: interfaces_1.BundleSObjects.PkgBundleVersionCreateReqStatus.success,
+            CreatedDate: new Date().toISOString(),
+            CreatedById: connection.getUsername() ?? 'unknown',
+        };
+    }
+    static readBundleVersionComponents(filePath, project) {
+        try {
+            const fileContent = fs.readFileSync(filePath, 'utf8');
+            const bundleVersionComponents = JSON.parse(fileContent);
+            if (!Array.isArray(bundleVersionComponents)) {
+                throw new core_1.SfError(messages.getMessage('bundleVersionComponentsMustBeArray'));
+            }
+            // Validate that each item has the required packageVersion property
+            for (const component of bundleVersionComponents) {
+                if (!component || typeof component !== 'object' || !component.packageVersion) {
+                    throw new core_1.SfError(messages.getMessage('bundleVersionComponentMustBeObject'));
+                }
+            }
+            // Process each component to get the package version ID
+            return bundleVersionComponents.map((component) => {
+                const packageVersion = component.packageVersion;
+                // Check if it's already an ID (04t followed by 15 characters)
+                if (/^04t[a-zA-Z0-9]{15}$/.test(packageVersion)) {
+                    return packageVersion;
+                }
+                // Otherwise, treat it as an alias and resolve it from sfdx-project.json
+                const packageVersionId = project.getPackageIdFromAlias(packageVersion);
+                if (!packageVersionId) {
+                    throw new core_1.SfError(messages.getMessage('noPackageVersionFoundWithAlias', [packageVersion]));
+                }
+                return packageVersionId;
+            });
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(messages.getMessage('failedToReadBundleVersionComponentsFile'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+    }
+    static getVersionName(packageBundle, majorVersion, minorVersion) {
+        return `${packageBundle}@${majorVersion}.${minorVersion}`;
+    }
+    static parsePackageBundleId(packageBundle, project) {
+        if (/^1Fl.{15}$/.test(packageBundle)) {
+            return packageBundle;
+        }
+        const bundleId = project.getPackageBundleIdFromAlias(packageBundle);
+        if (!bundleId) {
+            throw new core_1.SfError(messages.getMessage('noPackageBundleFoundWithAlias', [packageBundle]));
+        }
+        return bundleId;
+    }
+    static async getPackageVersion(options, project, connection) {
+        const packageBundleId = PackageBundleVersionCreate.parsePackageBundleId(options.PackageBundle, project);
+        const query = `SELECT BundleName FROM PackageBundle WHERE Id = '${packageBundleId}'`;
+        const result = await connection.tooling.query(query);
+        if (!result.records || result.records.length === 0) {
+            throw new core_1.SfError(messages.getMessage('noBundleFoundWithId', [packageBundleId]));
+        }
+        const bundleName = result.records[0].BundleName;
+        const bundles = project.getSfProjectJson().getPackageBundles();
+        const bundle = bundles.find((b) => b.name === bundleName);
+        if (!bundle) {
+            throw new core_1.SfError(messages.getMessage('noBundleFoundWithName', [bundleName]));
+        }
+        const [major, minor] = bundle.versionNumber.split('.');
+        if (!major || !minor) {
+            throw new core_1.SfError(messages.getMessage('invalidVersionNumberFormat', [bundle.versionNumber]));
+        }
+        // Check if major is an integer
+        const majorInt = parseInt(major, 10);
+        if (isNaN(majorInt) || majorInt.toString() !== major) {
+            throw new core_1.SfError(messages.getMessage('invalidVersionNumberFormat', [bundle.versionNumber]));
+        }
+        // Check if minor is either an integer or "next"
+        if (minor === 'NEXT') {
+            // Query existing bundle versions to find the highest minor version for this major version
+            const bundleVersionQuery = 'SELECT Id, PackageBundle.Id, PackageBundle.BundleName, VersionName, MajorVersion, MinorVersion, IsReleased ' +
+                'FROM PackageBundleVersion ' +
+                `WHERE PackageBundle.BundleName = '${bundleName}' AND MajorVersion = ${major} ` +
+                'ORDER BY MinorVersion DESC LIMIT 1';
+            const queryResult = await connection.tooling.query(bundleVersionQuery);
+            if (queryResult.records && queryResult.records.length > 0) {
+                const highestRecord = queryResult.records[0];
+                // Get the highest minor version and add 1
+                const highestMinorVersion = parseInt(highestRecord.MinorVersion, 10);
+                if (isNaN(highestMinorVersion)) {
+                    throw new core_1.SfError(messages.getMessage('invalidMinorVersionInExisting', [highestRecord.MinorVersion]));
+                }
+                const nextMinorVersion = (highestMinorVersion + 1).toString();
+                return { MajorVersion: major, MinorVersion: nextMinorVersion };
+            }
+            else {
+                // No existing versions found for this major version, start with .0
+                return { MajorVersion: major, MinorVersion: '0' };
+            }
+        }
+        else {
+            const minorInt = parseInt(minor, 10);
+            if (isNaN(minorInt) || minorInt.toString() !== minor) {
+                throw new core_1.SfError(messages.getMessage('invalidVersionNumberFormat', [bundle.versionNumber]));
+            }
+        }
+        return { MajorVersion: major, MinorVersion: minor };
+    }
+}
+exports.PackageBundleVersionCreate = PackageBundleVersionCreate;
+//# sourceMappingURL=packageBundleVersionCreate.js.map

package/lib/utils/bundleUtils.d.ts

@@ -0,0 +1 @@
+export declare function massageErrorMessage(err: Error): Error;

package/lib/utils/bundleUtils.js

@@ -0,0 +1,19 @@
+"use strict";
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.massageErrorMessage = massageErrorMessage;
+const core_1 = require("@salesforce/core");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_utils');
+function massageErrorMessage(err) {
+    if (err.name === 'STRING_TOO_LONG') {
+        err['message'] = messages.getMessage('STRING_TOO_LONG');
+    }
+    return err;
+}
+//# sourceMappingURL=bundleUtils.js.map

package/lib/utils/index.d.ts

@@ -1 +1,2 @@
 export { INSTALL_URL_BASE, getContainerOptions, getPackageVersionStrings, getPackageVersionNumber, } from './packageUtils';
+export { massageErrorMessage } from './bundleUtils';

package/lib/utils/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPackageVersionNumber = exports.getPackageVersionStrings = exports.getContainerOptions = exports.INSTALL_URL_BASE = void 0;
+exports.massageErrorMessage = exports.getPackageVersionNumber = exports.getPackageVersionStrings = exports.getContainerOptions = exports.INSTALL_URL_BASE = void 0;
 /*
  * Copyright (c) 2022, salesforce.com, inc.
  * All rights reserved.
@@ -12,4 +12,6 @@ Object.defineProperty(exports, "INSTALL_URL_BASE", { enumerable: true, get: func
 Object.defineProperty(exports, "getContainerOptions", { enumerable: true, get: function () { return packageUtils_1.getContainerOptions; } });
 Object.defineProperty(exports, "getPackageVersionStrings", { enumerable: true, get: function () { return packageUtils_1.getPackageVersionStrings; } });
 Object.defineProperty(exports, "getPackageVersionNumber", { enumerable: true, get: function () { return packageUtils_1.getPackageVersionNumber; } });
+var bundleUtils_1 = require("./bundleUtils");
+Object.defineProperty(exports, "massageErrorMessage", { enumerable: true, get: function () { return bundleUtils_1.massageErrorMessage; } });
 //# sourceMappingURL=index.js.map

package/messages/bundle_create.md

@@ -0,0 +1,3 @@
+# failedToCreatePackageBundle
+
+Failed to create package bundle

package/messages/bundle_install.md

@@ -0,0 +1,11 @@
+# failedToGetPackageBundleInstallStatus
+
+Failed to get package bundle install status
+
+# failedToInstallPackageBundle
+
+Failed to install package bundle
+
+# noPackageBundleVersionFoundWithAlias
+
+No package bundle version found with alias: %s

package/messages/bundle_utils.md

@@ -0,0 +1,7 @@
+# STRING_TOO_LONG
+
+Either name or description has exceeded the 255 charector limit.
+
+# invalidIdOrAlias
+
+The %s : %s isn't defined in the sfdx-project.json. Add it to the packageBundles section and add the alias to packageBundleAliases with its %s ID.

package/messages/bundle_version.md

@@ -0,0 +1,3 @@
+# componentRecordMissing
+
+Component record is missing

package/messages/bundle_version_create.md

@@ -0,0 +1,47 @@
+# failedToGetPackageBundleVersionCreateStatus
+
+Failed to get package bundle version create status
+
+# failedToCreatePackageBundleVersion
+
+Failed to create package bundle version
+
+# bundleVersionComponentsMustBeArray
+
+Bundle version components must be an array of objects with packageVersion property
+
+# bundleVersionComponentMustBeObject
+
+Each bundle version component must be an object with a packageVersion property
+
+# noPackageVersionFoundWithAlias
+
+No package version found with alias: %s
+
+# failedToReadBundleVersionComponentsFile
+
+Failed to read or parse bundle version components file
+
+# noPackageBundleFoundWithAlias
+
+No package bundle found with alias: %s
+
+# noBundleFoundWithId
+
+No bundle found with id: %s
+
+# noBundleFoundWithName
+
+No bundle found with name: %s
+
+# invalidVersionNumberFormat
+
+Invalid version number format: %s
+
+# majorVersionMismatch
+
+Major version mismatch: expected %s, found %s
+
+# invalidMinorVersionInExisting
+
+Invalid minor version in existing record: %s

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/packaging",
-  "version": "4.12.0",
+  "version": "4.13.0",
   "description": "Packaging library for the Salesforce packaging platform",
   "main": "lib/exported",
   "types": "lib/exported.d.ts",
@@ -42,10 +42,10 @@
     "!lib/**/*.map"
   ],
   "dependencies": {
-    "@jsforce/jsforce-node": "^3.6.5",
-    "@salesforce/core": "^8.18.5",
+    "@jsforce/jsforce-node": "^3.10.4",
+    "@salesforce/core": "^8.23.0",
     "@salesforce/kit": "^3.2.3",
-    "@salesforce/schemas": "^1.9.1",
+    "@salesforce/schemas": "^1.10.3",
     "@salesforce/source-deploy-retrieve": "^12.16.9",
     "@salesforce/ts-types": "^2.0.11",
     "@salesforce/types": "^1.2.0",