@salesforce/packaging 4.11.0 → 4.13.0

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/package/packageVersionDependency.d.ts

@@ -39,10 +39,12 @@ export declare class DependencyDotProducer {
     private subscriberPackageVersionId;
     private connection;
     private dependencyGraphData;
+    private selectedNodeIds;
     constructor(connection: Connection, dependencyGraphString: string, verbose: boolean, edgeDirection: 'root-first' | 'root-last', resolvedPackageVersionId: string);
     private static throwErrorOnInvalidRecord;
     init(): Promise<void>;
     produce(): string;
+    private addSelectedNodeIds;
     private createDependencyGraphNodes;
     /**
      * Creates a single dependency graph node.
@@ -58,6 +60,7 @@ export declare class DependencyDotProducer {
      * @param node the node id and label
      */
     private buildDotNode;
+    private addColorToSelectedNode;
     /**
      * Builds a DOT edge line of the form fromNode -> toNode
      *

package/lib/package/packageVersionDependency.js

@@ -141,6 +141,7 @@ class DependencyDotProducer {
     subscriberPackageVersionId;
     connection;
     dependencyGraphData;
+    selectedNodeIds = [];
     constructor(connection, dependencyGraphString, verbose, edgeDirection, resolvedPackageVersionId) {
         this.verbose = verbose;
         this.edgeDirection = edgeDirection;
@@ -161,6 +162,7 @@ class DependencyDotProducer {
             nodes: await this.createDependencyGraphNodes(dependencyGraphJson.nodes),
             edges: this.createDependencyGraphEdges(dependencyGraphJson.edges),
         };
+        this.selectedNodeIds = await this.addSelectedNodeIds();
     }
     produce() {
         const dotLines = [];
@@ -172,6 +174,36 @@ class DependencyDotProducer {
         }
         return `strict digraph G {${node_os_1.EOL}${dotLines.join(node_os_1.EOL)}${node_os_1.EOL}}`;
     }
+    async addSelectedNodeIds() {
+        const selectedNodes = [];
+        if (this.subscriberPackageVersionId === exports.VERSION_BEING_BUILT) {
+            selectedNodes.push(this.subscriberPackageVersionId);
+        }
+        else if (this.subscriberPackageVersionId.startsWith('04t')) {
+            selectedNodes.push(this.subscriberPackageVersionId);
+            const query = `SELECT Dependencies FROM SubscriberPackageVersion WHERE Id = '${this.subscriberPackageVersionId}'`;
+            try {
+                const result = await this.connection.tooling.query(query);
+                if (result.records?.length !== 1) {
+                    return selectedNodes;
+                }
+                const dependencies = result.records[0].Dependencies;
+                if (!dependencies) {
+                    return selectedNodes;
+                }
+                if (dependencies.ids && Array.isArray(dependencies.ids)) {
+                    const dependencyIds = dependencies.ids
+                        .map((dep) => dep.subscriberPackageVersionId)
+                        .filter((id) => id && typeof id === 'string' && id.startsWith('04t'));
+                    selectedNodes.push(...dependencyIds);
+                }
+            }
+            catch (error) {
+                throw messages.createError('invalidPackageVersionIdError', [this.subscriberPackageVersionId]);
+            }
+        }
+        return selectedNodes;
+    }
     async createDependencyGraphNodes(jsonNodes) {
         const nodePromises = jsonNodes.map(async (node) => this.createSingleDependencyGraphNode(node.id));
         const resolvedNodes = await Promise.all(nodePromises);
@@ -279,7 +311,14 @@ class DependencyDotProducer {
         if (this.verbose) {
             label += ` (${node.subscriberPackageVersionId})`;
         }
-        return `\t node_${nodeId} [label="${label}"]`;
+        const color = this.addColorToSelectedNode(node);
+        return `\t node_${nodeId} [label="${label}"${color}]`;
+    }
+    addColorToSelectedNode(node) {
+        if (this.selectedNodeIds.includes(node.subscriberPackageVersionId)) {
+            return ' color="green"';
+        }
+        return '';
     }
     /**
      * Builds a DOT edge line of the form fromNode -> toNode

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