convert.ts

/*
 * Copyright 2026, Salesforce, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { Flags, loglevel, orgApiVersionFlagWithDeprecations, SfCommand } from '@salesforce/sf-plugins-core';
import { Lifecycle, Messages, SfError } from '@salesforce/core';
import {
  INSTALL_URL_BASE,
  Package,
  PackageEvents,
  PackageVersionCreateEventData,
  PackageVersionCreateRequestResult,
  PackagingSObjects,
} from '@salesforce/packaging';
import { camelCaseToTitleCase, Duration } from '@salesforce/kit';
import { requiredHubFlag } from '../../utils/hubFlag.js';

Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
const messages = Messages.loadMessages('@salesforce/plugin-packaging', 'package_convert');
const pvcMessages = Messages.loadMessages('@salesforce/plugin-packaging', 'package_version_create');

export class PackageConvert extends SfCommand<PackageVersionCreateRequestResult> {
  public static readonly summary = messages.getMessage('summary');
  public static readonly description = messages.getMessage('description');
  public static readonly examples = messages.getMessages('examples');
  public static readonly deprecateAliases = true;
  public static readonly aliases = ['force:package:convert'];
  public static readonly requiresProject = true;
  public static readonly flags = {
    loglevel,
    'target-dev-hub': requiredHubFlag,
    'api-version': orgApiVersionFlagWithDeprecations,
    package: Flags.salesforceId({
      length: 'both',
      char: 'p',
      summary: messages.getMessage('flags.package.summary'),
      required: true,
      startsWith: '033',
    }),
    'installation-key': Flags.string({
      char: 'k',
      deprecateAliases: true,
      aliases: ['installationkey'],
      summary: messages.getMessage('flags.installation-key.summary'),
      description: messages.getMessage('flags.installation-key.description'),
      exactlyOne: ['installation-key', 'installation-key-bypass'],
    }),
    'definition-file': Flags.file({
      char: 'f',
      deprecateAliases: true,
      aliases: ['definitionfile'],
      summary: messages.getMessage('flags.definition-file.summary'),
      description: messages.getMessage('flags.definition-file.description'),
    }),
    'installation-key-bypass': Flags.boolean({
      char: 'x',
      deprecateAliases: true,
      aliases: ['installationkeybypass'],
      summary: messages.getMessage('flags.installation-key-bypass.summary'),
      description: messages.getMessage('flags.installation-key-bypass.description'),
      exactlyOne: ['installation-key', 'installation-key-bypass'],
    }),
    wait: Flags.duration({
      unit: 'minutes',
      char: 'w',
      summary: messages.getMessage('flags.wait.summary'),
      default: Duration.minutes(0),
    }),
    'build-instance': Flags.string({
      char: 's',
      deprecateAliases: true,
      aliases: ['buildinstance'],
      summary: messages.getMessage('flags.build-instance.summary'),
      hidden: true,
    }),
    'seed-metadata': Flags.directory({
      char: 'm',
      summary: messages.getMessage('flags.seed-metadata.summary'),
      description: messages.getMessage('flags.seed-metadata.description'),
    }),
    verbose: Flags.boolean({
      summary: messages.getMessage('flags.verbose.summary'),
    }),
    'patch-version': Flags.string({
      summary: messages.getMessage('flags.patch-version.summary'),
      description: messages.getMessage('flags.patch-version.description'),
      char: 'a',
      deprecateAliases: true,
      aliases: ['patchversion'],
    }),
    'code-coverage': Flags.boolean({
      char: 'c',
      summary: messages.getMessage('flags.code-coverage.summary'),
      description: messages.getMessage('flags.code-coverage.description'),
      default: false,
    }),
  };

  public async run(): Promise<PackageVersionCreateRequestResult> {
    const { flags } = await this.parse(PackageConvert);
    // eslint-disable-next-line @typescript-eslint/require-await
    Lifecycle.getInstance().on(PackageEvents.convert.progress, async (data: PackageVersionCreateEventData) => {
      const inProgressMessage = messages.getMessage('in-progress', [
        data.timeRemaining?.seconds,
        camelCaseToTitleCase(data.packageVersionCreateRequestResult.Status),
      ]);
      this.display(inProgressMessage, flags.verbose);
    });

    // eslint-disable-next-line @typescript-eslint/require-await
    Lifecycle.getInstance().on(PackageEvents.convert.success, async () => {
      this.display('SUCCESS', flags.verbose);
    });

    if (flags.verbose) {
      this.log('Converting Package');
    } else {
      this.spinner.start('Converting Package', 'Initializing');
    }

    const result = await Package.convert(
      flags.package,
      flags['target-dev-hub'].getConnection(flags['api-version']),
      {
        wait: flags.wait,
        installationKey: flags['installation-key'] as string,
        definitionfile: flags['definition-file'] as string,
        installationKeyBypass: flags['installation-key-bypass'],
        buildInstance: flags['build-instance'] as string,
        seedMetadata: flags['seed-metadata'] as string,
        patchversion: flags['patch-version'] as string,
        codecoverage: flags['code-coverage'] as boolean,
      },
      this.project
    );

    switch (result.Status) {
      case PackagingSObjects['Package2VersionStatus'].error:
        this.spinner.stop();
        throw new SfError(result.Error?.join('\n') ?? pvcMessages.getMessage('unknownError'));
      case PackagingSObjects['Package2VersionStatus'].success: {
        const successMessage = pvcMessages.getMessage(result.Status, [
          result.Id,
          result.SubscriberPackageVersionId,
          INSTALL_URL_BASE.href,
          result.SubscriberPackageVersionId,
          this.config.bin,
        ]);
        if (flags.verbose) {
          this.log(successMessage);
        } else {
          this.spinner.stop(successMessage);
        }
        break;
      }
      default: {
        const inProgressMessage = pvcMessages.getMessage('InProgress', [
          this.config.bin,
          camelCaseToTitleCase(result.Status),
          result.Id,
        ]);
        this.display(inProgressMessage, flags.verbose);
      }
    }

    this.spinner.stop();
    return result;
  }

  private display(message: string, verbose: boolean): void {
    if (verbose) {
      this.log(message);
    } else {
      this.spinner.status = message;
    }
  }
}