@hs-x/cli 0.4.0 → 0.4.2-next.0

package/dist/commands/project-lifecycle.js

@@ -0,0 +1,641 @@
+import { rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import { PLATFORM_VERSIONS } from '@hubspot/project-parsing-lib/constants';
+import { loadHsProfileFile } from '@hubspot/project-parsing-lib/profiles';
+import { isLegacyProject, meetsMinimumPlatformVersion, } from '@hubspot/project-parsing-lib/projects';
+import { translate } from '@hubspot/project-parsing-lib/translate';
+import { findAndParsePackageJsonFiles } from '@hubspot/project-parsing-lib/workspaces';
+import { runNpmAuditJson } from '@hubspot/ui-extensions-dev-server';
+import { Effect, Option } from 'effect';
+import { cwdOption, jsonOption, runHandler, runQuarantined } from '../cli/kit.js';
+import { resolveDirectHubSpotContext, } from '../hubspot-developer-client.js';
+import { writeLocalHubSpotProjectArchive } from '../hubspot-project-archive.js';
+import { HubSpotProjectDeployBlockedError, deployHubSpotProjectBuild, lastSuccessfulHubSpotBuild, readHubSpotAutoDeployEnabled, readHubSpotBuilds, readHubSpotDeployedBuildId, readHubSpotStatus, waitForHubSpotAutoDeploy, waitForHubSpotBuildStatus, } from '../hubspot-project-lifecycle.js';
+import { readHubSpotProjectDescriptor } from '../hubspot-project.js';
+import { requestMutationConsent } from '../mutation-consent.js';
+import { isInteractive, promptConfirm, promptSelect } from '../prompt.js';
+import { createReporter } from '../reporter/index.js';
+import { Cwd } from '../services/cwd.js';
+import { PROJECT_DEPLOY_JSON_SCHEMA, PROJECT_UPLOAD_JSON_SCHEMA, } from './project-lifecycle-schema.js';
+const accountOption = Options.text('account').pipe(Options.withAlias('a'), Options.optional);
+const configOption = Options.text('config').pipe(Options.withAlias('c'), Options.optional);
+const useEnvOption = Options.boolean('use-env').pipe(Options.withDefault(false));
+const formatJsonOption = Options.boolean('format-output-as-json').pipe(Options.withDefault(false));
+const jsonSchemaOption = Options.boolean('json-schema').pipe(Options.withDefault(false));
+const debugOption = Options.boolean('debug').pipe(Options.withAlias('d'), Options.withDefault(false));
+const profileOption = Options.text('profile').pipe(Options.withAlias('p'), Options.optional);
+const pakOption = Options.text('pak').pipe(Options.optional);
+const yesOption = Options.boolean('yes').pipe(Options.withAlias('y'), Options.withDefault(false));
+const planOption = Options.boolean('plan').pipe(Options.withDefault(false));
+const timeoutOption = Options.text('timeout-ms').pipe(Options.optional);
+const sharedMutationOptions = {
+    account: accountOption,
+    config: configOption,
+    useEnv: useEnvOption,
+    json: jsonOption,
+    formatJson: formatJsonOption,
+    jsonSchema: jsonSchemaOption,
+    debug: debugOption,
+    profile: profileOption,
+    pak: pakOption,
+    yes: yesOption,
+    plan: planOption,
+    cwd: cwdOption,
+    timeout: timeoutOption,
+};
+const projectUploadCmd = Command.make('upload', {
+    ...sharedMutationOptions,
+    force: Options.boolean('force').pipe(Options.withAlias('f'), Options.withDefault(false)),
+    forceCreate: Options.boolean('force-create').pipe(Options.withDefault(false)),
+    message: Options.text('message').pipe(Options.withAlias('m'), Options.optional),
+    skipNpmAudit: Options.boolean('skip-npm-audit').pipe(Options.withDefault(false)),
+    skipAutoDeploy: Options.boolean('skip-auto-deploy').pipe(Options.withDefault(false)),
+}, (opts) => {
+    const json = opts.json || opts.formatJson;
+    return runHandler('project upload', { json, debug: opts.debug }, Effect.gen(function* () {
+        const cwd = yield* Cwd;
+        const root = Option.getOrElse(opts.cwd, () => cwd);
+        const argv = projectUploadArgv(opts, json);
+        yield* runQuarantined('project upload', json, () => projectUploadCommand({ argv, root, json }));
+    }));
+});
+const projectDeployCmd = Command.make('deploy', {
+    ...sharedMutationOptions,
+    project: Options.text('project').pipe(Options.optional),
+    build: Options.text('build').pipe(Options.withAlias('build-id'), Options.optional),
+    deployLatestBuild: Options.boolean('deployLatestBuild').pipe(Options.withAlias('deploy-latest-build'), Options.withDefault(false)),
+    force: Options.boolean('force').pipe(Options.withAlias('f'), Options.withDefault(false)),
+}, (opts) => {
+    const json = opts.json || opts.formatJson;
+    return runHandler('project deploy', { json, debug: opts.debug }, Effect.gen(function* () {
+        const cwd = yield* Cwd;
+        const root = Option.getOrElse(opts.cwd, () => cwd);
+        const argv = projectDeployArgv(opts, json);
+        yield* runQuarantined('project deploy', json, () => projectDeployCommand({ argv, root, json }));
+    }));
+});
+export { projectDeployCmd, projectUploadCmd };
+const projectLifecycleCommandDependencies = {
+    resolveContext: resolveDirectHubSpotContext,
+    translateProject: translate,
+};
+export async function projectUploadCommand(input, dependencyOverrides = {}) {
+    const dependencies = { ...projectLifecycleCommandDependencies, ...dependencyOverrides };
+    const reporter = createReporter({ command: 'project upload', argv: input.argv });
+    if (hasFlag(input.argv, '--json-schema')) {
+        reporter.raw(`${JSON.stringify(PROJECT_UPLOAD_JSON_SCHEMA, null, 2)}\n`);
+        return { exitCode: 0 };
+    }
+    let archivePath;
+    try {
+        rejectConflictingSelectors(input.argv, 'upload');
+        const descriptor = await readHubSpotProjectDescriptor(input.root);
+        const profile = resolveFlag(input.argv, '--profile');
+        const accountArgv = await accountArgvForProfile(input.argv, input.root, descriptor.srcDir, profile);
+        const context = await dependencies.resolveContext({ argv: accountArgv, cwd: input.root });
+        if (!context.account.authReady) {
+            throw new Error(`HubSpot account ${accountLabel(context.account)} does not have deploy authentication available.`);
+        }
+        const client = context.createClient();
+        const projectExists = await hubSpotProjectExists(client, descriptor.name);
+        const message = resolveFlag(input.argv, '--message') ?? '';
+        const skipAutoDeploy = hasFlag(input.argv, '--skip-auto-deploy');
+        const skipNpmAudit = hasFlag(input.argv, '--skip-npm-audit');
+        const force = hasFlag(input.argv, '--force') || hasFlag(input.argv, '-f');
+        const forceCreate = force || hasFlag(input.argv, '--force-create');
+        const timeoutMs = readTimeout(input.argv);
+        const plan = {
+            mode: 'hubspot-direct',
+            operation: 'upload',
+            account: safeAccount(context.account),
+            project: {
+                name: descriptor.name,
+                platformVersion: descriptor.platformVersion,
+                source: join(input.root, descriptor.srcDir),
+                exists: projectExists,
+            },
+            options: {
+                ...(profile ? { profile } : {}),
+                message,
+                skipNpmAudit,
+                skipAutoDeploy,
+                forceCreate,
+                timeoutMs,
+            },
+            targets: { hubspot: true, cloudflare: false, controlPlane: false },
+        };
+        renderPlan(reporter, `${descriptor.name} upload`, uploadPlanRows(plan));
+        if (hasFlag(input.argv, '--plan')) {
+            emitMachineData(reporter, plan);
+            reporter.done('Upload plan ready');
+            return { exitCode: 0 };
+        }
+        if (!projectExists && !forceCreate && (!isInteractive() || reporter.mode !== 'human')) {
+            throw new Error(`HubSpot project ${descriptor.name} does not exist. Re-run interactively or pass --force to create it.`);
+        }
+        const consent = await requestMutationConsent({
+            yes: hasFlag(input.argv, '--yes') || hasFlag(input.argv, '-y') || force,
+            machineOutput: reporter.mode === 'json' || reporter.mode === 'ndjson',
+            interactive: isInteractive(),
+            message: projectExists
+                ? `Upload ${descriptor.name} to ${accountLabel(context.account)}?`
+                : `Create and upload ${descriptor.name} in ${accountLabel(context.account)}?`,
+            confirm: promptConfirm,
+        });
+        if (consent === 'cancelled') {
+            reporter.done('Cancelled', 130);
+            return { exitCode: 130 };
+        }
+        if (consent === 'require-yes') {
+            throw new Error('Project upload requires --yes or --force in non-interactive mode.');
+        }
+        const sourceDir = join(input.root, descriptor.srcDir);
+        const auditWarnings = skipNpmAudit ? [] : await auditProjectDependencies(sourceDir, input.root);
+        for (const warning of auditWarnings)
+            reporter.warn('HSX_W_HUBSPOT_NPM_AUDIT', warning);
+        const translated = await dependencies.translateProject({
+            projectSourceDir: sourceDir,
+            platformVersion: descriptor.platformVersion,
+            accountId: Number(context.account.id),
+        }, profile ? { profile } : undefined);
+        if (translated.skippedHsMetaFiles.length > 0 && !force) {
+            throw new Error(`HubSpot skipped ${translated.skippedHsMetaFiles.length} component metadata file(s): ${translated.skippedHsMetaFiles.join(', ')}. Review them or re-run with --force.`);
+        }
+        archivePath = await writeLocalHubSpotProjectArchive(input.root, descriptor.name, {
+            sourceOnly: true,
+        });
+        const uploadStep = reporter.step(projectExists ? 'Uploading project' : 'Creating project');
+        await client.projects.ensureProject({ projectName: descriptor.name });
+        const upload = await client.projects.upload({
+            projectName: descriptor.name,
+            archivePath,
+            message,
+            platformVersion: descriptor.platformVersion,
+            intermediateRepresentation: translated.intermediateRepresentation,
+            skipAutoDeploy,
+        });
+        uploadStep.ok(`build #${upload.buildId}`);
+        const buildStep = reporter.step('Building project');
+        const buildStatus = await waitForHubSpotBuildStatus({
+            client,
+            projectName: descriptor.name,
+            buildId: upload.buildId,
+            timeoutMs,
+        });
+        const buildState = readHubSpotStatus(buildStatus) ?? 'UNKNOWN';
+        if (buildState !== 'SUCCESS') {
+            buildStep.fail(buildState);
+            throw new Error(`HubSpot build #${upload.buildId} finished with ${buildState}.`);
+        }
+        buildStep.ok(`build #${upload.buildId}`);
+        let deployId;
+        let deployStatus;
+        const autoDeployEnabled = readHubSpotAutoDeployEnabled(buildStatus) === true;
+        if (!skipAutoDeploy && autoDeployEnabled) {
+            const deployStep = reporter.step('Auto-deploying project');
+            const deployed = await waitForHubSpotAutoDeploy({
+                client,
+                projectName: descriptor.name,
+                buildId: upload.buildId,
+                buildStatus,
+                timeoutMs,
+            });
+            deployId = deployed.deployId;
+            deployStatus = readHubSpotStatus(deployed.status) ?? 'UNKNOWN';
+            if (deployStatus !== 'SUCCESS') {
+                deployStep.fail(deployStatus);
+                throw new Error(`HubSpot auto-deploy #${deployId} finished with ${deployStatus}.`);
+            }
+            deployStep.ok(`deploy #${deployId}`);
+        }
+        const releaseRequired = meetsMinimumPlatformVersion(descriptor.platformVersion, PLATFORM_VERSIONS.v2026_09_BETA);
+        const nextCommand = deployStatus === 'SUCCESS'
+            ? undefined
+            : releaseRequired
+                ? `hs project release create --build=${upload.buildId}`
+                : `hs-x project deploy --build ${upload.buildId}`;
+        const result = {
+            mode: 'hubspot-direct',
+            operation: 'upload',
+            account: safeAccount(context.account),
+            projectName: descriptor.name,
+            buildId: upload.buildId,
+            buildStatus: buildState,
+            autoDeployEnabled,
+            autoDeploySkipped: skipAutoDeploy,
+            ...(deployId === undefined ? {} : { deployId }),
+            ...(deployStatus ? { deployStatus } : {}),
+            ...(nextCommand ? { nextCommand } : {}),
+        };
+        emitMachineData(reporter, result);
+        if (nextCommand)
+            reporter.info(`Next: ${nextCommand}`);
+        reporter.done(deployStatus === 'SUCCESS'
+            ? `Uploaded, built, and deployed ${descriptor.name}`
+            : `Uploaded and built ${descriptor.name}`);
+        return { exitCode: 0 };
+    }
+    catch (cause) {
+        return lifecycleFailure(reporter, 'HSX_E_PROJECT_UPLOAD', cause);
+    }
+    finally {
+        if (archivePath)
+            await rm(dirname(archivePath), { recursive: true, force: true });
+    }
+}
+export async function projectDeployCommand(input, dependencyOverrides = {}) {
+    const dependencies = { ...projectLifecycleCommandDependencies, ...dependencyOverrides };
+    const reporter = createReporter({ command: 'project deploy', argv: input.argv });
+    if (hasFlag(input.argv, '--json-schema')) {
+        reporter.raw(`${JSON.stringify(PROJECT_DEPLOY_JSON_SCHEMA, null, 2)}\n`);
+        return { exitCode: 0 };
+    }
+    try {
+        rejectConflictingSelectors(input.argv, 'deploy');
+        const descriptor = await readHubSpotProjectDescriptor(input.root).catch(() => undefined);
+        const projectName = resolveFlag(input.argv, '--project') ?? descriptor?.name;
+        if (!projectName) {
+            throw new Error('Run from a HubSpot project or pass --project <name>.');
+        }
+        const profile = resolveFlag(input.argv, '--profile');
+        if (profile && !descriptor)
+            throw new Error('--profile requires a local hsproject.json.');
+        const accountArgv = await accountArgvForProfile(input.argv, input.root, descriptor?.srcDir ?? 'src', profile);
+        const context = await dependencies.resolveContext({ argv: accountArgv, cwd: input.root });
+        if (!context.account.authReady) {
+            throw new Error(`HubSpot account ${accountLabel(context.account)} does not have deploy authentication available.`);
+        }
+        const client = context.createClient();
+        const [project, buildsResponse] = await Promise.all([
+            client.projects.getProject({ projectName }),
+            client.projects.listBuilds({ projectName, limit: 100 }),
+        ]);
+        const builds = readHubSpotBuilds(buildsResponse);
+        const deployedBuildId = readHubSpotDeployedBuildId(project);
+        const explicitBuild = resolveFlag(input.argv, '--build') ?? resolveFlag(input.argv, '--build-id');
+        let buildId = explicitBuild ? readPositiveInteger(explicitBuild, '--build') : undefined;
+        if (buildId === undefined && hasDeployLatestBuildFlag(input.argv)) {
+            buildId = lastSuccessfulHubSpotBuild(builds)?.id;
+        }
+        if (buildId === undefined && reporter.mode === 'human' && isInteractive()) {
+            const successful = builds.filter((build) => build.status?.toUpperCase() === 'SUCCESS');
+            if (successful.length === 0) {
+                throw new Error(`${projectName} does not have a successful build to deploy.`);
+            }
+            const latest = lastSuccessfulHubSpotBuild(successful);
+            const selected = await promptSelect({
+                message: 'Which successful build should be deployed?',
+                options: successful.map((build) => ({
+                    value: String(build.id),
+                    label: `#${build.id}${build.id === deployedBuildId ? ' (deployed)' : ''}`,
+                    description: [build.platformVersion, build.createdAt, build.message]
+                        .filter(Boolean)
+                        .join(' · '),
+                })),
+                ...(latest ? { default: String(latest.id) } : {}),
+            });
+            if (!selected) {
+                reporter.done('Cancelled', 130);
+                return { exitCode: 130 };
+            }
+            buildId = readPositiveInteger(selected, 'build');
+        }
+        if (buildId === undefined) {
+            throw new Error('No successful build was selected. Pass --build <id> or --deploy-latest-build.');
+        }
+        const build = builds.find((candidate) => candidate.id === buildId);
+        if (!build)
+            throw new Error(`HubSpot build #${buildId} was not found in ${projectName}.`);
+        if (build.status?.toUpperCase() !== 'SUCCESS') {
+            throw new Error(`HubSpot build #${buildId} is ${build.status ?? 'not successful'} and cannot deploy.`);
+        }
+        const alreadyDeployed = deployedBuildId === buildId;
+        const platformVersion = build.platformVersion ?? descriptor?.platformVersion;
+        if (!alreadyDeployed &&
+            platformVersion &&
+            meetsMinimumPlatformVersion(platformVersion, PLATFORM_VERSIONS.v2026_09_BETA)) {
+            throw new Error(`Build #${buildId} uses release management. Run hs project release create --build=${buildId}.`);
+        }
+        const force = hasFlag(input.argv, '--force') || hasFlag(input.argv, '-f');
+        const timeoutMs = readTimeout(input.argv);
+        const plan = {
+            mode: 'hubspot-direct',
+            operation: 'deploy',
+            account: safeAccount(context.account),
+            project: {
+                name: projectName,
+                buildId,
+                alreadyDeployed,
+                ...(platformVersion ? { platformVersion } : {}),
+            },
+            options: { ...(profile ? { profile } : {}), force, timeoutMs },
+            targets: { hubspot: true, cloudflare: false, controlPlane: false },
+        };
+        renderPlan(reporter, `${projectName} deploy`, deployPlanRows(plan));
+        if (hasFlag(input.argv, '--plan')) {
+            emitMachineData(reporter, plan);
+            reporter.done('Deploy plan ready');
+            return { exitCode: 0 };
+        }
+        if (alreadyDeployed) {
+            emitMachineData(reporter, {
+                mode: 'hubspot-direct',
+                operation: 'deploy',
+                account: safeAccount(context.account),
+                projectName,
+                buildId,
+                changed: false,
+                status: 'ALREADY_DEPLOYED',
+            });
+            reporter.done(`${projectName} build #${buildId} is already deployed`);
+            return { exitCode: 0 };
+        }
+        const consent = await requestMutationConsent({
+            yes: hasFlag(input.argv, '--yes') || hasFlag(input.argv, '-y') || force,
+            machineOutput: reporter.mode === 'json' || reporter.mode === 'ndjson',
+            interactive: isInteractive(),
+            message: `Deploy build #${buildId} of ${projectName} to ${accountLabel(context.account)}?`,
+            confirm: promptConfirm,
+        });
+        if (consent === 'cancelled') {
+            reporter.done('Cancelled', 130);
+            return { exitCode: 130 };
+        }
+        if (consent === 'require-yes') {
+            throw new Error('Project deploy requires --yes or --force in non-interactive mode.');
+        }
+        const step = reporter.step(`Deploying build #${buildId}`);
+        const deployed = await deployHubSpotProjectBuild({
+            client,
+            projectName,
+            buildId,
+            force,
+            legacy: platformVersion ? isLegacyProject(platformVersion) : false,
+            timeoutMs,
+        });
+        const status = readHubSpotStatus(deployed.status) ?? 'UNKNOWN';
+        if (status !== 'SUCCESS') {
+            step.fail(status);
+            throw new Error(`HubSpot deploy #${deployed.deployId} finished with ${status}.`);
+        }
+        step.ok(`deploy #${deployed.deployId}`);
+        emitMachineData(reporter, {
+            mode: 'hubspot-direct',
+            operation: 'deploy',
+            account: safeAccount(context.account),
+            projectName,
+            buildId,
+            deployId: deployed.deployId,
+            changed: true,
+            status,
+        });
+        reporter.done(`Deployed ${projectName} build #${buildId}`);
+        return { exitCode: 0 };
+    }
+    catch (cause) {
+        return lifecycleFailure(reporter, cause instanceof HubSpotProjectDeployBlockedError
+            ? 'HSX_E_PROJECT_DEPLOY_BLOCKED'
+            : 'HSX_E_PROJECT_DEPLOY', cause);
+    }
+}
+function projectUploadArgv(opts, json) {
+    const argv = ['project', 'upload'];
+    pushSharedArgs(argv, opts, json);
+    pushOption(argv, '--message', opts.message);
+    pushFlag(argv, '--force', opts.force);
+    pushFlag(argv, '--force-create', opts.forceCreate);
+    pushFlag(argv, '--skip-npm-audit', opts.skipNpmAudit);
+    pushFlag(argv, '--skip-auto-deploy', opts.skipAutoDeploy);
+    return argv;
+}
+function projectDeployArgv(opts, json) {
+    const argv = ['project', 'deploy'];
+    pushSharedArgs(argv, opts, json);
+    pushOption(argv, '--project', opts.project);
+    pushOption(argv, '--build', opts.build);
+    pushFlag(argv, '--deploy-latest-build', opts.deployLatestBuild);
+    pushFlag(argv, '--force', opts.force);
+    return argv;
+}
+// These identity declarations give the two argv builders the exact inferred
+// Effect option types without exporting or duplicating hand-written interfaces.
+function projectUploadCommandOptionsMarker(opts) {
+    void opts;
+}
+function projectDeployCommandOptionsMarker(opts) {
+    void opts;
+}
+function pushSharedArgs(argv, opts, json) {
+    pushOption(argv, '--account', opts.account);
+    pushOption(argv, '--config', opts.config);
+    pushOption(argv, '--profile', opts.profile);
+    pushOption(argv, '--pak', opts.pak);
+    pushOption(argv, '--timeout-ms', opts.timeout);
+    pushFlag(argv, '--use-env', opts.useEnv);
+    pushFlag(argv, '--json-schema', opts.jsonSchema);
+    pushFlag(argv, '--yes', opts.yes);
+    pushFlag(argv, '--plan', opts.plan);
+    pushFlag(argv, '--json', json);
+}
+function pushOption(argv, flag, value) {
+    if (Option.isSome(value))
+        argv.push(flag, value.value);
+}
+function pushFlag(argv, flag, enabled) {
+    if (enabled)
+        argv.push(flag);
+}
+async function accountArgvForProfile(argv, root, srcDir, profile) {
+    if (!profile)
+        return argv;
+    const loaded = loadHsProfileFile(join(root, srcDir), profile);
+    if (!loaded?.accountId) {
+        throw new Error(`hsprofile.${profile}.json is missing accountId.`);
+    }
+    return [...argv, '--developer-account-id', String(loaded.accountId)];
+}
+function rejectConflictingSelectors(argv, operation) {
+    if (resolveFlag(argv, '--profile') && resolveFlag(argv, '--account')) {
+        throw new Error('--profile cannot be combined with --account.');
+    }
+    if (operation === 'deploy' && resolveFlag(argv, '--profile') && resolveFlag(argv, '--project')) {
+        throw new Error('--profile cannot be combined with --project.');
+    }
+}
+async function hubSpotProjectExists(client, projectName) {
+    try {
+        await client.projects.getProject({ projectName });
+        return true;
+    }
+    catch (cause) {
+        if (readHttpStatus(cause) === 404 &&
+            !/auth|credential|permission/i.test(describeCause(cause))) {
+            return false;
+        }
+        throw cause;
+    }
+}
+async function auditProjectDependencies(sourceDir, projectRoot) {
+    const parsed = await findAndParsePackageJsonFiles(sourceDir);
+    const roots = new Set(parsed.length > 0 ? parsed.map((entry) => entry.dir) : [sourceDir]);
+    const results = await Promise.all([...roots].map(async (root) => ({ root, result: await runNpmAuditJson(root) })));
+    return results.flatMap(({ root, result }) => {
+        if (result.skipped || result.exitCode === 0)
+            return [];
+        const relativeRoot = root.startsWith(projectRoot) ? root.slice(projectRoot.length + 1) : root;
+        const summary = summarizeNpmAudit(result.source);
+        if (result.exitCode === 127)
+            return [`npm is unavailable; skipped audit for ${relativeRoot}.`];
+        return [`npm audit reported ${summary ?? `exit ${result.exitCode}`} in ${relativeRoot}.`];
+    });
+}
+function summarizeNpmAudit(source) {
+    try {
+        const parsed = JSON.parse(source);
+        const metadata = asRecord(parsed.metadata);
+        const vulnerabilities = asRecord(metadata?.vulnerabilities);
+        const total = readNumber(vulnerabilities?.total);
+        if (!total)
+            return undefined;
+        const parts = ['critical', 'high', 'moderate', 'low', 'info'].flatMap((severity) => {
+            const count = readNumber(vulnerabilities?.[severity]);
+            return count ? [`${count} ${severity}`] : [];
+        });
+        return `${total} total${parts.length ? ` (${parts.join(', ')})` : ''}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+function renderPlan(reporter, title, rows) {
+    if (reporter.mode !== 'human' && reporter.mode !== 'plain')
+        return;
+    reporter.header(title);
+    reporter.rows(rows);
+}
+function emitMachineData(reporter, payload) {
+    if (reporter.mode === 'json' || reporter.mode === 'ndjson')
+        reporter.data(payload);
+}
+function uploadPlanRows(plan) {
+    return [
+        { key: 'account', value: accountLabel(plan.account), status: 'ok' },
+        { key: 'project', value: plan.project.name },
+        { key: 'platform', value: plan.project.platformVersion },
+        {
+            key: 'remote project',
+            value: plan.project.exists ? 'exists' : 'will be created',
+            status: plan.project.exists ? 'ok' : 'warn',
+        },
+        ...(plan.options.profile ? [{ key: 'profile', value: plan.options.profile }] : []),
+        { key: 'message', value: plan.options.message || '(none)' },
+        { key: 'npm audit', value: plan.options.skipNpmAudit ? 'skipped' : 'enabled' },
+        {
+            key: 'auto-deploy',
+            value: plan.options.skipAutoDeploy ? 'explicitly skipped' : 'project setting',
+        },
+        { key: 'Cloudflare', value: 'not used' },
+        { key: 'HS-X control plane', value: 'not used' },
+    ];
+}
+function deployPlanRows(plan) {
+    return [
+        { key: 'account', value: accountLabel(plan.account), status: 'ok' },
+        { key: 'project', value: plan.project.name },
+        { key: 'build', value: `#${plan.project.buildId}` },
+        ...(plan.project.platformVersion
+            ? [{ key: 'platform', value: plan.project.platformVersion }]
+            : []),
+        ...(plan.options.profile ? [{ key: 'profile', value: plan.options.profile }] : []),
+        {
+            key: 'action',
+            value: plan.project.alreadyDeployed ? 'no changes — already deployed' : 'deploy build',
+            ...(plan.project.alreadyDeployed ? { status: 'ok' } : {}),
+        },
+        {
+            key: 'force',
+            value: plan.options.force ? 'yes' : 'no',
+            ...(plan.options.force ? { status: 'warn' } : {}),
+        },
+        { key: 'Cloudflare', value: 'not used' },
+        { key: 'HS-X control plane', value: 'not used' },
+    ];
+}
+function lifecycleFailure(reporter, code, cause) {
+    reporter.error(code, describeCause(cause), {
+        hint: cause instanceof HubSpotProjectDeployBlockedError
+            ? 'Review the component warnings above; use --force only when the removals are intentional.'
+            : 'Fix the reported HubSpot project issue and retry.',
+    });
+    reporter.done(undefined, 1);
+    return { exitCode: 1 };
+}
+function readTimeout(argv) {
+    const raw = resolveFlag(argv, '--timeout-ms') ?? '120000';
+    return readPositiveInteger(raw, '--timeout-ms');
+}
+function readPositiveInteger(value, label) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0)
+        throw new Error(`${label} must be positive.`);
+    return parsed;
+}
+function hasDeployLatestBuildFlag(argv) {
+    return hasFlag(argv, '--deploy-latest-build') || hasFlag(argv, '--deployLatestBuild');
+}
+function hasFlag(argv, flag) {
+    return argv.includes(flag);
+}
+function resolveFlag(argv, flag) {
+    const index = argv.indexOf(flag);
+    const next = index === -1 ? undefined : argv[index + 1];
+    if (next && !next.startsWith('-'))
+        return next;
+    const prefix = `${flag}=`;
+    return argv.find((token) => token.startsWith(prefix))?.slice(prefix.length) || undefined;
+}
+function safeAccount(account) {
+    return {
+        id: account.id,
+        ...(account.name ? { name: account.name } : {}),
+        source: account.source,
+        selectedBy: account.selectedBy,
+        authReady: account.authReady,
+        ...(account.configSource ? { configSource: account.configSource } : {}),
+    };
+}
+function accountLabel(account) {
+    return account.name ? `${account.name} (${account.id})` : account.id;
+}
+function readHttpStatus(cause) {
+    const record = asRecord(cause);
+    const response = asRecord(record?.response);
+    return (readNumber(record?.status) ??
+        readNumber(record?.statusCode) ??
+        readNumber(response?.status) ??
+        readNumber(response?.statusCode));
+}
+function describeCause(cause) {
+    const record = asRecord(cause);
+    const data = asRecord(record?.data) ?? asRecord(asRecord(record?.response)?.data);
+    return [
+        cause instanceof Error ? cause.message : String(cause),
+        typeof data?.message === 'string' ? data.message : undefined,
+        typeof data?.category === 'string' ? data.category : undefined,
+        typeof data?.correlationId === 'string' ? `correlation ${data.correlationId}` : undefined,
+    ]
+        .filter((value) => Boolean(value))
+        .filter((value, index, values) => values.indexOf(value) === index)
+        .join(' · ');
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null
+        ? value
+        : undefined;
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+//# sourceMappingURL=project-lifecycle.js.map