@hs-x/cli 0.4.2 → 0.4.4

package/dist/commands/deploy.js

@@ -10,6 +10,7 @@ import { cloudflareResourceName, generateHubSpotRuntimeProject, generateProjectA
 import { HttpClientRequest, Schema, schemas, signDeploymentAttestationGrant } from '@hs-x/types';
 import { validateProject } from '@hs-x/validator';
 import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
+import { translate as translateHubSpotProject } from '@hubspot/project-parsing-lib/translate';
 import { Effect, Option } from 'effect';
 import { isLinked } from '../account-store.js';
 import { exitWith } from '../cli-error.js';
@@ -27,7 +28,7 @@ import { resolveDeployTargets } from '../deploy-targets.js';
 import { executeCliHttp } from '../effect-http.js';
 import { DirectHubSpotAccountResolutionError, createDeployHubSpotDeveloperClient, resolveDirectHubSpotContext, } from '../hubspot-developer-client.js';
 import { HubSpotProjectArchiveSourceError, fingerprintHubSpotArchiveSource, writeLocalHubSpotProjectArchive, } from '../hubspot-project-archive.js';
-import { deployHubSpotProjectBuild, waitForHubSpotAutoDeploy, waitForHubSpotBuildStatus, } from '../hubspot-project-lifecycle.js';
+import { deployHubSpotProjectBuild, readHubSpotSubbuildStatuses, waitForHubSpotAutoDeploy, waitForHubSpotBuildStatus, } from '../hubspot-project-lifecycle.js';
 import { detectLocalProjectMode, readHubSpotProjectDescriptor, validateHubSpotProject, } from '../hubspot-project.js';
 import { hydrateAncestorEnv } from '../load-env.js';
 import { LocalProjectPickerCancelled, resolveLocalProject } from '../local-project-picker.js';
@@ -772,6 +773,15 @@ async function executeHubSpotDirectDeployCommand({ argv, root, json, }) {
                     force,
                     sourceFingerprint,
                     createClient: async () => context.createClient(),
+                    ...(!isLegacyProject(platformVersion)
+                        ? {
+                            translateProject: () => context.runWithEnvironment((selectedAccount) => translateHubSpotProject({
+                                projectSourceDir: join(root, descriptor.srcDir),
+                                platformVersion,
+                                accountId: Number(selectedAccount.id),
+                            })),
+                        }
+                        : {}),
                 };
             }
         }
@@ -929,7 +939,6 @@ async function executeHubSpotDirectDeployCommand({ argv, root, json, }) {
         });
     }
     try {
-        const step = machineOutput ? undefined : reporter.step('Uploading to HubSpot');
         const uploaded = await executeHubSpotOnlyUpload({
             argv,
             root,
@@ -937,6 +946,7 @@ async function executeHubSpotDirectDeployCommand({ argv, root, json, }) {
             persistBinding: false,
             uploadOnly,
             prepared: preparedUpload,
+            ...(machineOutput ? {} : { progress: reporter }),
         });
         const buildState = readStatus(uploaded.buildStatus) ?? 'UNKNOWN';
         const deployState = uploaded.deployStatus
@@ -944,7 +954,6 @@ async function executeHubSpotDirectDeployCommand({ argv, root, json, }) {
             : undefined;
         const deployUnverified = uploaded.autoDeployExpected && deployState === undefined;
         const ok = buildState === 'SUCCESS' && !deployUnverified && (!deployState || deployState === 'SUCCESS');
-        step?.[ok ? 'ok' : 'fail'](`build #${uploaded.buildId} ${buildState}${deployState ? ` · deploy ${deployState}` : deployUnverified ? ' · deploy unverified' : ''}`);
         const result = {
             schema_version: 1,
             ok,
@@ -970,7 +979,7 @@ async function executeHubSpotDirectDeployCommand({ argv, root, json, }) {
             reporter.done(ok ? directDeployDoneMessage(uploaded) : 'HubSpot deploy failed', ok ? 0 : 1);
         }
         else {
-            streamHubSpotUploadOutcome(reporter, uploaded);
+            streamHubSpotUploadOutcome(reporter, uploaded, { componentMode: 'failures' });
             if (deployUnverified) {
                 reporter.error('HSX_E_DEPLOY_HUBSPOT', 'HubSpot auto-deploy could not be verified before the timeout.', { hint: 'Check the project deploy status in HubSpot, then retry if it did not ship.' });
             }
@@ -1455,31 +1464,22 @@ export async function deployCommand({ argv, root, json, }) {
     // vs deploy-then-upload). A FAILED build resolves the step as a failure so
     // the failing phase is visible in the transcript, not just the exit code.
     const runHubSpotUploadPhase = async () => {
-        const uploadStartedAt = Date.now();
-        const uploadStep = progress?.step('Uploading to HubSpot');
-        let result;
-        try {
-            result = await executeHubSpotOnlyUpload({
-                argv,
-                root,
-                local: localHubspotUpload,
-                uploadOnly: hubspotUploadOnly,
-            });
-        }
-        catch (error) {
-            uploadStep?.fail(firstErrorLine(error));
-            throw error;
-        }
-        const buildState = readStatus(result.buildStatus) ?? 'UNKNOWN';
-        const detail = `build #${result.buildId} ${buildState} (${elapsedSince(uploadStartedAt)})`;
-        if (buildState === 'SUCCESS') {
-            uploadStep?.ok(detail);
-        }
-        else {
-            uploadStep?.fail(detail);
-        }
+        const result = await executeHubSpotOnlyUpload({
+            argv,
+            root,
+            local: localHubspotUpload,
+            uploadOnly: hubspotUploadOnly,
+            ...(progress
+                ? {
+                    progress: {
+                        step: (label) => progress.step(label),
+                        rows: (rows) => progress.reporter.rows(rows),
+                    },
+                }
+                : {}),
+        });
         if (echo)
-            streamHubSpotUploadOutcome(echo, result);
+            streamHubSpotUploadOutcome(echo, result, { componentMode: 'failures' });
         return result;
     };
     if (uploadFirstOrigin && controlPlanePlan) {
@@ -1635,9 +1635,20 @@ export async function deployCommand({ argv, root, json, }) {
         const configDrift = controlPlaneRecord.configDrift;
         echo.warn('HSX_W_DEPLOY_CONFIG_DRIFT', `Worker binding/config changed since the previously recorded deploy (${configDrift.previousDeployId}): fingerprint ${configDrift.previousFingerprint} -> ${configDrift.currentFingerprint}. This is expected if you intentionally changed bindings; investigate if you did not.`);
     }
+    // A combined plan cannot know the Worker URL that a real Cloudflare deploy
+    // will mint. Keep plan mode useful and non-provider-mutating by deferring
+    // runtime-bound HubSpot metadata until the actual deploy. Callers may still
+    // pass --runtime-origin when they intentionally want to preview that bundle.
+    const hubspotBundleDeferred = planOnly &&
+        hubspotUploadRequested &&
+        needsHubSpotBundle &&
+        !resolveFlag(argv, '--runtime-origin');
+    if (hubspotBundleDeferred && echo) {
+        echo.info('HubSpot runtime bundle: deferred until deploy resolves the Worker URL.');
+    }
     // Default order (skipped when we already uploaded first above): generate the
     // HubSpot bundle from the deployed Worker URL, then upload.
-    if (!uploadFirstOrigin && hubspotUploadRequested && validation.ok) {
+    if (!uploadFirstOrigin && hubspotUploadRequested && validation.ok && !hubspotBundleDeferred) {
         const bundleStep = needsHubSpotBundle ? progress?.step('Generating HubSpot bundle') : undefined;
         try {
             await ensureHubSpotRuntimeProjectArtifacts({
@@ -1720,6 +1731,7 @@ export async function deployCommand({ argv, root, json, }) {
             },
             hubspot: {
                 uploadRequested: hubspotUploadRequested,
+                bundleDeferred: hubspotBundleDeferred,
             },
         },
         root,
@@ -2069,12 +2081,13 @@ function buildDeploySummaryRows(input) {
  * diagnosable from the terminal, not the HubSpot UI (run-008 build #2 failed
  * silently here).
  */
-function streamHubSpotUploadOutcome(reporter, upload) {
+function streamHubSpotUploadOutcome(reporter, upload, options = {}) {
+    const componentMode = options.componentMode ?? 'all';
     for (const subbuild of readSubbuildStatuses(upload.buildStatus)) {
-        if (subbuild.status === 'SUCCESS') {
+        if (subbuild.status === 'SUCCESS' && componentMode === 'all') {
             reporter.info(`  [ok] ${subbuild.name}${subbuild.type ? ` (${subbuild.type})` : ''}`);
         }
-        else {
+        else if (subbuild.status !== 'SUCCESS' && componentMode !== 'none') {
             reporter.error('HSX_E_DEPLOY_HUBSPOT_BUILD_COMPONENT', `${subbuild.name}${subbuild.type ? ` (${subbuild.type})` : ''}: ${subbuild.errorMessage ?? subbuild.status}`);
         }
     }
@@ -4276,15 +4289,35 @@ function runCloudflareCommand(command, options) {
         },
     })));
 }
-async function executeHubSpotOnlyUpload({ argv, root, local, persistBinding = true, uploadOnly, prepared, }) {
+async function executeHubSpotOnlyUpload({ argv, root, local, persistBinding = true, uploadOnly, prepared, progress, }) {
     // The HubSpot project name must match the name baked into the generated
     // bundle (hsproject.json + app-hsmeta uid), not the on-disk directory name.
     // Using basename(root) breaks when the project lives in a generic dir (e.g.
     // `app/`): the upload targets a project named "app" while the bundle declares
     // the real project id, and HubSpot rejects the mismatch with an opaque 400.
     const projectName = prepared?.projectName ?? (await resolveHubSpotProjectName(argv, root));
-    const intermediateRepresentation = prepared?.intermediateRepresentation ??
+    let intermediateRepresentation = prepared?.intermediateRepresentation ??
         (await readHubSpotProjectIntermediateRepresentation(root));
+    if (prepared?.translateProject) {
+        const translateStartedAt = Date.now();
+        const translateStep = progress?.step('Translating HubSpot components');
+        try {
+            const translated = await prepared.translateProject();
+            if (translated.skippedHsMetaFiles.length > 0 && !prepared.force) {
+                throw new Error(`HubSpot skipped ${translated.skippedHsMetaFiles.length} component metadata file(s): ${translated.skippedHsMetaFiles.join(', ')}. Review them or re-run with --force.`);
+            }
+            intermediateRepresentation = translated.intermediateRepresentation;
+            const nodes = isRecord(intermediateRepresentation)
+                ? intermediateRepresentation.intermediateNodesIndexedByUid
+                : undefined;
+            const componentCount = isRecord(nodes) ? Object.keys(nodes).length : 0;
+            translateStep?.ok(`${componentCount} components · ${elapsedSince(translateStartedAt)}`);
+        }
+        catch (error) {
+            translateStep?.fail(`${firstErrorLine(error)} · ${elapsedSince(translateStartedAt)}`);
+            throw error;
+        }
+    }
     const appUid = prepared?.appUid ??
         readAppUidFromIntermediateRepresentation(intermediateRepresentation) ??
         (await readAppUidFromProjectSource(root));
@@ -4294,10 +4327,20 @@ async function executeHubSpotOnlyUpload({ argv, root, local, persistBinding = tr
     const developerAccountId = prepared?.developerAccountId ??
         resolveFlag(argv, '--developer-account-id') ??
         process.env.HSX_HUBSPOT_DEVELOPER_ACCOUNT_ID;
-    const archivePath = await writeLocalHubSpotProjectArchive(root, projectName, {
-        sourceOnly: intermediateRepresentation !== undefined,
-        ...(prepared ? { expectedSourceFingerprint: prepared.sourceFingerprint } : {}),
-    });
+    const packageStartedAt = Date.now();
+    const packageStep = progress?.step('Packaging HubSpot project');
+    let archivePath;
+    try {
+        archivePath = await writeLocalHubSpotProjectArchive(root, projectName, {
+            sourceOnly: intermediateRepresentation !== undefined,
+            ...(prepared ? { expectedSourceFingerprint: prepared.sourceFingerprint } : {}),
+        });
+        packageStep?.ok(elapsedSince(packageStartedAt));
+    }
+    catch (error) {
+        packageStep?.fail(`${firstErrorLine(error)} · ${elapsedSince(packageStartedAt)}`);
+        throw error;
+    }
     const client = prepared
         ? await prepared.createClient()
         : await createDeployHubSpotDeveloperClient({
@@ -4306,29 +4349,52 @@ async function executeHubSpotOnlyUpload({ argv, root, local, persistBinding = tr
             allowedOperations: ['hubspot-project-upload'],
             cwd: root,
         });
-    await client.projects.ensureProject({ projectName });
     const hsproject = await readHubSpotProjectConfig(root);
     const configuredPlatformVersion = typeof hsproject.platformVersion === 'string' ? hsproject.platformVersion : undefined;
     const platformVersion = prepared?.platformVersion ??
         resolveFlag(argv, '--platform-version') ??
         configuredPlatformVersion ??
         '2026.03';
-    const upload = await client.projects.upload({
-        projectName,
-        archivePath,
-        message: prepared?.buildMessage ?? resolveFlag(argv, '--message') ?? 'HS-X HubSpot-only deploy',
-        platformVersion,
-        intermediateRepresentation,
-        skipAutoDeploy: uploadOnly,
-    });
     const timeoutMs = prepared?.buildTimeoutMs ?? Number(resolveFlag(argv, '--hubspot-build-timeout-ms') ?? '60000');
-    const buildStatus = await waitForHubSpotBuildStatus({
-        client,
-        projectName,
-        buildId: upload.buildId,
-        timeoutMs,
-        intervalMs: 1000,
-    });
+    const uploadStartedAt = Date.now();
+    const uploadStep = progress?.step('Uploading project');
+    let upload;
+    try {
+        await client.projects.ensureProject({ projectName });
+        upload = await client.projects.upload({
+            projectName,
+            archivePath,
+            message: prepared?.buildMessage ?? resolveFlag(argv, '--message') ?? 'HS-X HubSpot-only deploy',
+            platformVersion,
+            intermediateRepresentation,
+            skipAutoDeploy: uploadOnly,
+        });
+        uploadStep?.ok(`build #${upload.buildId} · ${elapsedSince(uploadStartedAt)}`);
+    }
+    catch (error) {
+        uploadStep?.fail(`${firstErrorLine(error)} · ${elapsedSince(uploadStartedAt)}`);
+        throw error;
+    }
+    const buildStartedAt = Date.now();
+    const buildStep = progress?.step(`Building project (build #${upload.buildId})`);
+    const reportedComponents = new Map();
+    let buildStatus;
+    try {
+        buildStatus = await waitForHubSpotBuildStatus({
+            client,
+            projectName,
+            buildId: upload.buildId,
+            timeoutMs,
+            intervalMs: 1000,
+            onStatus: (status) => streamHubSpotComponentProgress(progress, status, reportedComponents, 'build'),
+        });
+    }
+    catch (error) {
+        buildStep?.fail(`${firstErrorLine(error)} · ${elapsedSince(buildStartedAt)}`);
+        throw error;
+    }
+    const buildState = readStatus(buildStatus) ?? 'UNKNOWN';
+    buildStep?.[buildState === 'SUCCESS' ? 'ok' : 'fail'](`${buildState} · ${elapsedSince(buildStartedAt)}`);
     const autoDeployEnabled = readBooleanProperty(buildStatus, 'isAutoDeployEnabled');
     if (uploadOnly || readStatus(buildStatus) !== 'SUCCESS' || autoDeployEnabled) {
         const appId = readStatus(buildStatus) === 'SUCCESS'
@@ -4346,15 +4412,32 @@ async function executeHubSpotOnlyUpload({ argv, root, local, persistBinding = tr
         // Normal uploads can auto-deploy; uploadOnly sends skipAutoDeploy and is
         // therefore a strict build-only result.
         const autoDeployExpected = !uploadOnly && autoDeployEnabled === true && readStatus(buildStatus) === 'SUCCESS';
-        const autoDeployStatus = autoDeployExpected
-            ? (await waitForHubSpotAutoDeploy({
-                client,
-                projectName,
-                buildId: upload.buildId,
-                buildStatus,
-                timeoutMs,
-            })).status
-            : undefined;
+        let autoDeployStatus;
+        if (autoDeployExpected) {
+            const deployStartedAt = Date.now();
+            const deployStep = progress?.step(`Auto-deploying project (build #${upload.buildId})`);
+            const reportedDeployComponents = new Map();
+            try {
+                const autoDeploy = await waitForHubSpotAutoDeploy({
+                    client,
+                    projectName,
+                    buildId: upload.buildId,
+                    buildStatus,
+                    timeoutMs,
+                    onStatus: (status) => streamHubSpotComponentProgress(progress, status, reportedDeployComponents, 'deploy'),
+                });
+                autoDeployStatus = autoDeploy.status;
+                const state = readStatus(autoDeployStatus) ?? 'UNKNOWN';
+                if (state === 'SUCCESS') {
+                    streamHubSpotComponentProgress(progress, buildStatus, reportedDeployComponents, 'deploy');
+                }
+                deployStep?.[state === 'SUCCESS' ? 'ok' : 'fail'](`deploy #${autoDeploy.deployId} ${state} · ${elapsedSince(deployStartedAt)}`);
+            }
+            catch (error) {
+                deployStep?.fail(`${firstErrorLine(error)} · ${elapsedSince(deployStartedAt)}`);
+                throw error;
+            }
+        }
         return {
             projectName,
             archivePath,
@@ -4370,15 +4453,31 @@ async function executeHubSpotOnlyUpload({ argv, root, local, persistBinding = tr
             local,
         };
     }
-    const deployed = await deployHubSpotProjectBuild({
-        client,
-        projectName,
-        buildId: upload.buildId,
-        force: prepared?.force ?? argv.includes('--force'),
-        legacy: isLegacyProject(platformVersion),
-        timeoutMs,
-        executeDeploy: (request) => withTransientDeployRetry(() => client.projects.deployBuild(request)),
-    });
+    const deployStartedAt = Date.now();
+    const deployStep = progress?.step(`Deploying project (build #${upload.buildId})`);
+    const reportedDeployComponents = new Map();
+    let deployed;
+    try {
+        deployed = await deployHubSpotProjectBuild({
+            client,
+            projectName,
+            buildId: upload.buildId,
+            force: prepared?.force ?? argv.includes('--force'),
+            legacy: isLegacyProject(platformVersion),
+            timeoutMs,
+            onStatus: (status) => streamHubSpotComponentProgress(progress, status, reportedDeployComponents, 'deploy'),
+            executeDeploy: (request) => withTransientDeployRetry(() => client.projects.deployBuild(request)),
+        });
+        const state = readStatus(deployed.status) ?? 'UNKNOWN';
+        if (state === 'SUCCESS') {
+            streamHubSpotComponentProgress(progress, buildStatus, reportedDeployComponents, 'deploy');
+        }
+        deployStep?.[state === 'SUCCESS' ? 'ok' : 'fail'](`deploy #${deployed.deployId} ${state} · ${elapsedSince(deployStartedAt)}`);
+    }
+    catch (error) {
+        deployStep?.fail(`${firstErrorLine(error)} · ${elapsedSince(deployStartedAt)}`);
+        throw error;
+    }
     const deployId = deployed.deployId;
     const deployStatus = deployed.status;
     const appId = await optionalHubSpotAppId(client, projectName, appUid);
@@ -4592,18 +4691,30 @@ async function resolveHubSpotAppAuthUrl(argv, root) {
 function readStatus(value) {
     return isRecord(value) && typeof value.status === 'string' ? value.status : undefined;
 }
-/** Tolerant parse of local-dev-lib's build subbuildStatuses for reporting. */
-function readSubbuildStatuses(value) {
-    if (!isRecord(value) || !Array.isArray(value.subbuildStatuses))
-        return [];
-    return value.subbuildStatuses.filter(isRecord).map((subbuild) => ({
-        name: String(subbuild.buildName ?? subbuild.componentName ?? 'component'),
-        ...(typeof subbuild.buildType === 'string' ? { type: subbuild.buildType } : {}),
-        status: String(subbuild.status ?? 'UNKNOWN'),
-        ...(typeof subbuild.errorMessage === 'string' && subbuild.errorMessage.length > 0
-            ? { errorMessage: subbuild.errorMessage }
-            : {}),
-    }));
+const readSubbuildStatuses = readHubSpotSubbuildStatuses;
+const HUBSPOT_COMPONENT_TERMINAL_STATES = new Set(['SUCCESS', 'FAILURE', 'ERROR', 'CANCELLED']);
+/** Emit each HubSpot component once, when it reaches a terminal build state. */
+function streamHubSpotComponentProgress(progress, buildStatus, reported, phase) {
+    if (!progress)
+        return;
+    const rows = [];
+    for (const component of readSubbuildStatuses(buildStatus)) {
+        const state = component.status.toUpperCase();
+        if (!HUBSPOT_COMPONENT_TERMINAL_STATES.has(state))
+            continue;
+        const key = `${component.name}\0${component.type ?? ''}`;
+        if (reported.get(key) === state)
+            continue;
+        reported.set(key, state);
+        rows.push({
+            key: component.name,
+            value: component.type ?? 'COMPONENT',
+            status: state === 'SUCCESS' ? 'ok' : 'fail',
+            detail: `${phase} ${state}`,
+            ...(component.errorMessage ? { hint: component.errorMessage } : {}),
+        });
+    }
+    progress.rows(rows);
 }
 function hasFlag(argv, flag) {
     return argv.includes(flag);