trigger.dev 0.0.0-v3-prerelease-20250108141813 → 0.0.0-v4-prerelease-20250916125920

package/dist/esm/commands/deploy.js

@@ -1,77 +1,77 @@
-import { intro, outro } from "@clack/prompts";
-import { prepareDeploymentError } from "@trigger.dev/core/v3";
+import { intro, log, outro } from "@clack/prompts";
+import { getBranch, prepareDeploymentError, tryCatch } from "@trigger.dev/core/v3";
 import { Option as CommandOption } from "commander";
-import { writeFile } from "node:fs/promises";
-import { join, relative, resolve } from "node:path";
-import { readPackageJSON, writePackageJSON } from "pkg-types";
+import { resolve } from "node:path";
+import { isCI } from "std-env";
+import { x } from "tinyexec";
 import { z } from "zod";
 import { buildWorker } from "../build/buildWorker.js";
+import { resolveAlwaysExternal } from "../build/externals.js";
 import { CommonCommandOptions, commonOptions, handleTelemetry, SkipLoggingError, wrapCommandAction, } from "../cli/common.js";
 import { loadConfig } from "../config.js";
-import { buildImage, generateContainerfile } from "../deploy/buildImage.js";
+import { buildImage } from "../deploy/buildImage.js";
 import { checkLogsForErrors, checkLogsForWarnings, printErrors, printWarnings, saveLogs, } from "../deploy/logs.js";
-import { buildManifestToJSON } from "../utilities/buildManifest.js";
 import { chalkError, cliLink, isLinksSupported, prettyError } from "../utilities/cliOutput.js";
 import { loadDotEnvVars } from "../utilities/dotEnv.js";
-import { writeJSONFile } from "../utilities/fileSystem.js";
+import { isDirectory } from "../utilities/fileSystem.js";
+import { setGithubActionsOutputAndEnvVars } from "../utilities/githubActions.js";
+import { createGitMeta } from "../utilities/gitMeta.js";
 import { printStandloneInitialBanner } from "../utilities/initialBanner.js";
+import { resolveLocalEnvVars } from "../utilities/localEnvVars.js";
 import { logger } from "../utilities/logger.js";
-import { getProjectClient } from "../utilities/session.js";
+import { getProjectClient, upsertBranch } from "../utilities/session.js";
 import { getTmpDir } from "../utilities/tempDirectories.js";
 import { spinner } from "../utilities/windows.js";
 import { login } from "./login.js";
+import { archivePreviewBranch } from "./preview.js";
 import { updateTriggerPackages } from "./update.js";
-import { resolveAlwaysExternal } from "../build/externals.js";
-import { x } from "tinyexec";
 const DeployCommandOptions = CommonCommandOptions.extend({
     dryRun: z.boolean().default(false),
     skipSyncEnvVars: z.boolean().default(false),
-    env: z.enum(["prod", "staging"]),
-    loadImage: z.boolean().default(false),
-    buildPlatform: z.enum(["linux/amd64", "linux/arm64"]).default("linux/amd64"),
-    namespace: z.string().optional(),
-    selfHosted: z.boolean().default(false),
-    registry: z.string().optional(),
-    push: z.boolean().default(false),
+    env: z.enum(["prod", "staging", "preview", "production"]),
+    branch: z.string().optional(),
+    load: z.boolean().optional(),
     config: z.string().optional(),
     projectRef: z.string().optional(),
-    apiUrl: z.string().optional(),
     saveLogs: z.boolean().default(false),
     skipUpdateCheck: z.boolean().default(false),
+    skipPromotion: z.boolean().default(false),
     noCache: z.boolean().default(false),
     envFile: z.string().optional(),
+    // Local build options
     network: z.enum(["default", "none", "host"]).optional(),
+    push: z.boolean().optional(),
+    builder: z.string().default("trigger"),
 });
 export function configureDeployCommand(program) {
-    return commonOptions(program
+    return (commonOptions(program
         .command("deploy")
-        .description("Deploy your Trigger.dev v3 project to the cloud.")
+        .description("Deploy your Trigger.dev project to the cloud.")
         .argument("[path]", "The path to the project", ".")
         .option("-e, --env <env>", "Deploy to a specific environment (currently only prod and staging are supported)", "prod")
+        .option("-b, --branch <branch>", "The preview branch to deploy to when passing --env preview. If not provided, we'll detect your git branch.")
         .option("--skip-update-check", "Skip checking for @trigger.dev package updates")
         .option("-c, --config <config file>", "The name of the config file, found at [path]")
         .option("-p, --project-ref <project ref>", "The project ref. Required if there is no config file. This will override the project specified in the config file.")
         .option("--dry-run", "Do a dry run of the deployment. This will not actually deploy the project, but will show you what would be deployed.")
         .option("--skip-sync-env-vars", "Skip syncing environment variables when using the syncEnvVars extension.")
-        .option("--env-file <env file>", "Path to the .env file to load into the CLI process. Defaults to .env in the project directory."))
-        .addOption(new CommandOption("--self-hosted", "Build and load the image using your local Docker. Use the --registry option to specify the registry to push the image to when using --self-hosted, or just use --push to push to the default registry.").hideHelp())
+        .option("--env-file <env file>", "Path to the .env file to load into the CLI process. Defaults to .env in the project directory.")
+        .option("--skip-promotion", "Skip promoting the deployment to the current deployment for the environment."))
         .addOption(new CommandOption("--no-cache", "Do not use the cache when building the image. This will slow down the build process but can be useful if you are experiencing issues with the cache.").hideHelp())
-        .addOption(new CommandOption("--push", "When using the --self-hosted flag, push the image to the default registry. (defaults to false when not using --registry)").hideHelp())
-        .addOption(new CommandOption("--registry <registry>", "The registry to push the image to when using --self-hosted").hideHelp())
-        .addOption(new CommandOption("--tag <tag>", "(Coming soon) Specify the tag to use when pushing the image to the registry").hideHelp())
-        .addOption(new CommandOption("--namespace <namespace>", "Specify the namespace to use when pushing the image to the registry").hideHelp())
-        .addOption(new CommandOption("--load-image", "Load the built image into your local docker").hideHelp())
-        .addOption(new CommandOption("--build-platform <platform>", "The platform to build the deployment image for")
-        .default("linux/amd64")
-        .hideHelp())
+        .addOption(new CommandOption("--load", "Load the built image into your local docker").hideHelp())
+        .addOption(new CommandOption("--no-load", "Do not load the built image into your local docker").hideHelp())
         .addOption(new CommandOption("--save-logs", "If provided, will save logs even for successful builds").hideHelp())
-        .option("--network <mode>", "The networking mode for RUN instructions when using --self-hosted")
+        // Local build options
+        .addOption(new CommandOption("--push", "Push the image after local builds").hideHelp())
+        .addOption(new CommandOption("--no-push", "Do not push the image after local builds").hideHelp())
+        .addOption(new CommandOption("--network <mode>", "The networking mode for RUN instructions when building locally").hideHelp())
+        .addOption(new CommandOption("--builder <builder>", "The builder to use when building locally").hideHelp())
         .action(async (path, options) => {
         await handleTelemetry(async () => {
             await printStandloneInitialBanner(true);
             await deployCommand(path, options);
         });
-    });
+    }));
 }
 export async function deployCommand(dir, options) {
     return await wrapCommandAction("deployCommand", DeployCommandOptions, options, async (opts) => {
@@ -79,11 +79,13 @@ export async function deployCommand(dir, options) {
     });
 }
 async function _deployCommand(dir, options) {
-    intro("Deploying project");
+    intro(`Deploying project${options.skipPromotion ? " (without promotion)" : ""}`);
     if (!options.skipUpdateCheck) {
         await updateTriggerPackages(dir, { ...options }, true, true);
     }
-    const projectPath = resolve(process.cwd(), dir);
+    const cwd = process.cwd();
+    const projectPath = resolve(cwd, dir);
+    verifyDirectory(dir, projectPath);
     const authorization = await login({
         embedded: true,
         defaultApiUrl: options.apiUrl,
@@ -97,17 +99,56 @@ async function _deployCommand(dir, options) {
             throw new Error(`You must login first. Use the \`login\` CLI command.\n\n${authorization.error}`);
         }
     }
+    //coerce env from production to prod
+    if (options.env === "production") {
+        options.env = "prod";
+    }
+    const envVars = resolveLocalEnvVars(options.envFile);
+    if (envVars.TRIGGER_PROJECT_REF) {
+        logger.debug("Using project ref from env", { ref: envVars.TRIGGER_PROJECT_REF });
+    }
     const resolvedConfig = await loadConfig({
         cwd: projectPath,
-        overrides: { project: options.projectRef },
+        overrides: { project: options.projectRef ?? envVars.TRIGGER_PROJECT_REF },
         configFile: options.config,
     });
     logger.debug("Resolved config", resolvedConfig);
+    const gitMeta = await createGitMeta(resolvedConfig.workspaceDir);
+    logger.debug("gitMeta", gitMeta);
+    const branch = options.env === "preview" ? getBranch({ specified: options.branch, gitMeta }) : undefined;
+    if (options.env === "preview" && !branch) {
+        throw new Error("Didn't auto-detect preview branch, so you need to specify one. Pass --branch <branch>.");
+    }
+    if (options.env === "preview" && branch) {
+        //auto-archive a branch if the PR is merged or closed
+        if (gitMeta?.pullRequestState === "merged" || gitMeta?.pullRequestState === "closed") {
+            log.message(`Pull request ${gitMeta?.pullRequestNumber} is ${gitMeta?.pullRequestState}.`);
+            const $buildSpinner = spinner();
+            $buildSpinner.start(`Archiving preview branch: "${branch}"`);
+            const result = await archivePreviewBranch(authorization, branch, resolvedConfig.project);
+            $buildSpinner.stop(result ? `Successfully archived "${branch}"` : `Failed to archive "${branch}".`);
+            return;
+        }
+        logger.debug("Upserting branch", { env: options.env, branch });
+        const branchEnv = await upsertBranch({
+            accessToken: authorization.auth.accessToken,
+            apiUrl: authorization.auth.apiUrl,
+            projectRef: resolvedConfig.project,
+            branch,
+            gitMeta,
+        });
+        logger.debug("Upserted branch env", branchEnv);
+        log.success(`Using preview branch "${branch}"`);
+        if (!branchEnv) {
+            throw new Error(`Failed to create branch "${branch}"`);
+        }
+    }
     const projectClient = await getProjectClient({
         accessToken: authorization.auth.accessToken,
         apiUrl: authorization.auth.apiUrl,
         projectRef: resolvedConfig.project,
         env: options.env,
+        branch,
         profile: options.profile,
     });
     if (!projectClient) {
@@ -118,9 +159,11 @@ async function _deployCommand(dir, options) {
     const destination = getTmpDir(resolvedConfig.workingDir, "build", options.dryRun);
     const $buildSpinner = spinner();
     const forcedExternals = await resolveAlwaysExternal(projectClient.client);
-    const buildManifest = await buildWorker({
+    const { features } = resolvedConfig;
+    const [error, buildManifest] = await tryCatch(buildWorker({
         target: "deploy",
         environment: options.env,
+        branch,
         destination: destination.path,
         resolvedConfig,
         rewritePaths: true,
@@ -128,55 +171,55 @@ async function _deployCommand(dir, options) {
         forcedExternals,
         listener: {
             onBundleStart() {
-                $buildSpinner.start("Building project");
+                $buildSpinner.start("Building trigger code");
             },
             onBundleComplete(result) {
-                $buildSpinner.stop("Successfully built project");
+                $buildSpinner.stop("Successfully built code");
                 logger.debug("Bundle result", result);
             },
         },
-    });
+    }));
+    if (error) {
+        $buildSpinner.stop("Failed to build code");
+        throw error;
+    }
     logger.debug("Successfully built project to", destination.path);
     if (options.dryRun) {
         logger.info(`Dry run complete. View the built project at ${destination.path}`);
         return;
     }
-    const deploymentResponse = await projectClient.client.initializeDeployment({
+    const deployment = await initializeOrAttachDeployment(projectClient.client, {
         contentHash: buildManifest.contentHash,
-        userId: authorization.userId,
-        selfHosted: options.selfHosted,
-        registryHost: options.registry,
-        namespace: options.namespace,
-    });
-    if (!deploymentResponse.success) {
-        throw new Error(`Failed to start deployment: ${deploymentResponse.error}`);
-    }
-    const deployment = deploymentResponse.data;
-    // If the deployment doesn't have any externalBuildData, then we can't use the remote image builder
-    // TODO: handle this and allow the user to the build and push the image themselves
-    if (!deployment.externalBuildData && !options.selfHosted) {
-        throw new Error(`Failed to start deployment, as your instance of trigger.dev does not support hosting. To deploy this project, you must use the --self-hosted flag to build and push the image yourself.`);
-    }
-    if (options.selfHosted) {
+        userId: authorization.auth.tokenType === "personal" ? authorization.userId : undefined,
+        gitMeta,
+        type: features.run_engine_v2 ? "MANAGED" : "V1",
+        runtime: buildManifest.runtime,
+    }, envVars.TRIGGER_EXISTING_DEPLOYMENT_ID);
+    const isLocalBuild = !deployment.externalBuildData;
+    // Fail fast if we know local builds will fail
+    if (isLocalBuild) {
         const result = await x("docker", ["buildx", "version"]);
         if (result.exitCode !== 0) {
             logger.debug(`"docker buildx version" failed (${result.exitCode}):`, result);
             throw new Error("Failed to find docker buildx. Please install it: https://github.com/docker/buildx#installing.");
         }
     }
-    if (buildManifest.deploy.sync &&
-        buildManifest.deploy.sync.env &&
-        Object.keys(buildManifest.deploy.sync.env).length > 0) {
-        const numberOfEnvVars = Object.keys(buildManifest.deploy.sync.env).length;
+    const hasVarsToSync = Object.keys(buildManifest.deploy.sync?.env || {}).length > 0 ||
+        // Only sync parent variables if this is a branch environment
+        (branch && Object.keys(buildManifest.deploy.sync?.parentEnv || {}).length > 0);
+    if (hasVarsToSync) {
+        const childVars = buildManifest.deploy.sync?.env ?? {};
+        const parentVars = buildManifest.deploy.sync?.parentEnv ?? {};
+        const numberOfEnvVars = Object.keys(childVars).length + Object.keys(parentVars).length;
         const vars = numberOfEnvVars === 1 ? "var" : "vars";
         if (!options.skipSyncEnvVars) {
             const $spinner = spinner();
             $spinner.start(`Syncing ${numberOfEnvVars} env ${vars} with the server`);
-            const success = await syncEnvVarsWithServer(projectClient.client, resolvedConfig.project, options.env, buildManifest.deploy.sync.env);
-            if (!success) {
+            const uploadResult = await syncEnvVarsWithServer(projectClient.client, resolvedConfig.project, options.env, childVars, parentVars);
+            if (!uploadResult.success) {
                 await failDeploy(projectClient.client, deployment, {
                     name: "SyncEnvVarsError",
-                    message: `Failed to sync ${numberOfEnvVars} env ${vars} with the server`,
+                    message: `Failed to sync ${numberOfEnvVars} env ${vars} with the server: ${uploadResult.error}`,
                 }, "", $spinner);
             }
             else {
@@ -188,28 +231,32 @@ async function _deployCommand(dir, options) {
         }
     }
     const version = deployment.version;
-    const deploymentLink = cliLink("View deployment", `${authorization.dashboardUrl}/projects/v3/${resolvedConfig.project}/deployments/${deployment.shortCode}`);
-    const testLink = cliLink("Test tasks", `${authorization.dashboardUrl}/projects/v3/${resolvedConfig.project}/test?environment=${options.env === "prod" ? "prod" : "stg"}`);
+    const rawDeploymentLink = `${authorization.dashboardUrl}/projects/v3/${resolvedConfig.project}/deployments/${deployment.shortCode}`;
+    const rawTestLink = `${authorization.dashboardUrl}/projects/v3/${resolvedConfig.project}/test?environment=${options.env === "prod" ? "prod" : "stg"}`;
+    const deploymentLink = cliLink("View deployment", rawDeploymentLink);
+    const testLink = cliLink("Test tasks", rawTestLink);
     const $spinner = spinner();
-    if (isLinksSupported) {
-        $spinner.start(`Deploying version ${version} ${deploymentLink}`);
+    const buildSuffix = isLocalBuild ? " (local)" : "";
+    const deploySuffix = isLocalBuild ? " (local build)" : "";
+    if (isCI) {
+        log.step(`Building version ${version}\n`);
     }
     else {
-        $spinner.start(`Deploying version ${version}`);
+        if (isLinksSupported) {
+            $spinner.start(`Building version ${version}${buildSuffix} ${deploymentLink}`);
+        }
+        else {
+            $spinner.start(`Building version ${version}${buildSuffix}`);
+        }
     }
-    const selfHostedRegistryHost = deployment.registryHost ?? options.registry;
-    const registryHost = selfHostedRegistryHost ?? "registry.trigger.dev";
     const buildResult = await buildImage({
-        selfHosted: options.selfHosted,
-        buildPlatform: options.buildPlatform,
+        isLocalBuild,
         noCache: options.noCache,
-        push: options.push,
-        registryHost,
-        registry: options.registry,
         deploymentId: deployment.id,
         deploymentVersion: deployment.version,
         imageTag: deployment.imageTag,
-        loadImage: options.loadImage,
+        imagePlatform: deployment.imagePlatform,
+        load: options.load,
         contentHash: deployment.contentHash,
         externalBuildId: deployment.externalBuildData?.buildId,
         externalBuildToken: deployment.externalBuildData?.buildToken,
@@ -218,10 +265,26 @@ async function _deployCommand(dir, options) {
         projectRef: resolvedConfig.project,
         apiUrl: projectClient.client.apiURL,
         apiKey: projectClient.client.accessToken,
+        branchName: branch,
         authAccessToken: authorization.auth.accessToken,
         compilationPath: destination.path,
         buildEnvVars: buildManifest.build.env,
+        onLog: (logMessage) => {
+            if (isCI) {
+                console.log(logMessage);
+                return;
+            }
+            if (isLinksSupported) {
+                $spinner.message(`Building version ${version}${buildSuffix} ${deploymentLink}: ${logMessage}`);
+            }
+            else {
+                $spinner.message(`Building version ${version}${buildSuffix}: ${logMessage}`);
+            }
+        },
+        // Local build options
         network: options.network,
+        builder: options.builder,
+        push: options.push,
     });
     logger.debug("Build result", buildResult);
     const warnings = checkLogsForWarnings(buildResult.logs);
@@ -236,109 +299,95 @@ async function _deployCommand(dir, options) {
     const getDeploymentResponse = await projectClient.client.getDeployment(deployment.id);
     if (!getDeploymentResponse.success) {
         await failDeploy(projectClient.client, deployment, { name: "DeploymentError", message: getDeploymentResponse.error }, buildResult.logs, $spinner);
-        throw new SkipLoggingError("Failed to get deployment with worker");
+        throw new SkipLoggingError(getDeploymentResponse.error);
     }
     const deploymentWithWorker = getDeploymentResponse.data;
     if (!deploymentWithWorker.worker) {
-        await failDeploy(projectClient.client, deployment, { name: "DeploymentError", message: "Failed to get deployment with worker" }, buildResult.logs, $spinner);
-        throw new SkipLoggingError("Failed to get deployment with worker");
+        const errorData = deploymentWithWorker.errorData
+            ? prepareDeploymentError(deploymentWithWorker.errorData)
+            : undefined;
+        await failDeploy(projectClient.client, deployment, {
+            name: "DeploymentError",
+            message: errorData?.message ?? "Failed to get deployment with worker",
+        }, buildResult.logs, $spinner);
+        throw new SkipLoggingError(errorData?.message ?? "Failed to get deployment with worker");
+    }
+    if (isCI) {
+        log.step(`Deploying version ${version}${deploySuffix}\n`);
+    }
+    else {
+        if (isLinksSupported) {
+            $spinner.message(`Deploying version ${version}${deploySuffix} ${deploymentLink}`);
+        }
+        else {
+            $spinner.message(`Deploying version ${version}${deploySuffix}`);
+        }
     }
-    const imageReference = options.selfHosted
-        ? `${selfHostedRegistryHost ? `${selfHostedRegistryHost}/` : ""}${buildResult.image}${buildResult.digest ? `@${buildResult.digest}` : ""}`
-        : `${registryHost}/${buildResult.image}${buildResult.digest ? `@${buildResult.digest}` : ""}`;
     const finalizeResponse = await projectClient.client.finalizeDeployment(deployment.id, {
-        imageReference,
-        selfHosted: options.selfHosted,
+        imageDigest: buildResult.digest,
+        skipPromotion: options.skipPromotion,
+    }, (logMessage) => {
+        if (isCI) {
+            console.log(logMessage);
+            return;
+        }
+        if (isLinksSupported) {
+            $spinner.message(`Deploying version ${version}${deploySuffix} ${deploymentLink}: ${logMessage}`);
+        }
+        else {
+            $spinner.message(`Deploying version ${version}${deploySuffix}: ${logMessage}`);
+        }
     });
     if (!finalizeResponse.success) {
         await failDeploy(projectClient.client, deployment, { name: "FinalizeError", message: finalizeResponse.error }, buildResult.logs, $spinner);
         throw new SkipLoggingError("Failed to finalize deployment");
     }
-    $spinner.stop(`Successfully deployed version ${version}`);
+    if (isCI) {
+        log.step(`Successfully deployed version ${version}${deploySuffix}`);
+    }
+    else {
+        $spinner.stop(`Successfully deployed version ${version}${deploySuffix}`);
+    }
     const taskCount = deploymentWithWorker.worker?.tasks.length ?? 0;
     outro(`Version ${version} deployed with ${taskCount} detected task${taskCount === 1 ? "" : "s"} ${isLinksSupported ? `| ${deploymentLink} | ${testLink}` : ""}`);
-}
-function rewriteBuildManifestPaths(buildManifest, destinationDir) {
-    return {
-        ...buildManifest,
-        files: buildManifest.files.map((file) => ({
-            ...file,
-            entry: cleanEntryPath(file.entry),
-            out: rewriteOutputPath(destinationDir, file.out),
-        })),
-        outputPath: rewriteOutputPath(destinationDir, buildManifest.outputPath),
-        configPath: rewriteOutputPath(destinationDir, buildManifest.configPath),
-        runControllerEntryPoint: buildManifest.runControllerEntryPoint
-            ? rewriteOutputPath(destinationDir, buildManifest.runControllerEntryPoint)
-            : undefined,
-        runWorkerEntryPoint: rewriteOutputPath(destinationDir, buildManifest.runWorkerEntryPoint),
-        indexControllerEntryPoint: buildManifest.indexControllerEntryPoint
-            ? rewriteOutputPath(destinationDir, buildManifest.indexControllerEntryPoint)
-            : undefined,
-        indexWorkerEntryPoint: rewriteOutputPath(destinationDir, buildManifest.indexWorkerEntryPoint),
-        loaderEntryPoint: buildManifest.loaderEntryPoint
-            ? rewriteOutputPath(destinationDir, buildManifest.loaderEntryPoint)
-            : undefined,
-    };
-}
-async function writeProjectFiles(buildManifest, resolvedConfig, outputPath) {
-    // Step 1. Read the package.json file
-    const packageJson = await readProjectPackageJson(resolvedConfig.packageJsonPath);
-    if (!packageJson) {
-        throw new Error("Could not read the package.json file");
+    if (!isLinksSupported) {
+        console.log("View deployment");
+        console.log(rawDeploymentLink);
+        console.log(); // new line
+        console.log("Test tasks");
+        console.log(rawTestLink);
     }
-    const dependencies = buildManifest.externals?.reduce((acc, external) => {
-        acc[external.name] = external.version;
-        return acc;
-    }, {}) ?? {};
-    // Step 3: Write the resolved dependencies to the package.json file
-    await writePackageJSON(join(outputPath, "package.json"), {
-        ...packageJson,
-        name: packageJson.name ?? "trigger-project",
-        dependencies: {
-            ...dependencies,
-        },
-        trustedDependencies: Object.keys(dependencies),
-        devDependencies: {},
-        peerDependencies: {},
-        scripts: {},
-    });
-    await writeJSONFile(join(outputPath, "build.json"), buildManifestToJSON(buildManifest));
-    await writeContainerfile(outputPath, buildManifest);
-}
-async function readProjectPackageJson(packageJsonPath) {
-    const packageJson = await readPackageJSON(packageJsonPath);
-    return packageJson;
-}
-// Remove any query parameters from the entry path
-// For example, src/trigger/ai.ts?sentryProxyModule=true -> src/trigger/ai.ts
-function cleanEntryPath(entry) {
-    return entry.split("?")[0];
-}
-function rewriteOutputPath(destinationDir, filePath) {
-    return `/app/${relative(destinationDir, filePath)}`;
-}
-async function writeContainerfile(outputPath, buildManifest) {
-    if (!buildManifest.runControllerEntryPoint || !buildManifest.indexControllerEntryPoint) {
-        throw new Error("Something went wrong with the build. Aborting deployment. [code 7789]");
+    if (options.saveLogs) {
+        const logPath = await saveLogs(deployment.shortCode, buildResult.logs);
+        console.log(`Full build logs have been saved to ${logPath}`);
     }
-    const containerfile = await generateContainerfile({
-        runtime: buildManifest.runtime,
-        entrypoint: buildManifest.runControllerEntryPoint,
-        build: buildManifest.build,
-        image: buildManifest.image,
-        indexScript: buildManifest.indexControllerEntryPoint,
+    setGithubActionsOutputAndEnvVars({
+        envVars: {
+            TRIGGER_DEPLOYMENT_VERSION: version,
+            TRIGGER_VERSION: version,
+            TRIGGER_DEPLOYMENT_SHORT_CODE: deployment.shortCode,
+            TRIGGER_DEPLOYMENT_URL: `${authorization.dashboardUrl}/projects/v3/${resolvedConfig.project}/deployments/${deployment.shortCode}`,
+            TRIGGER_TEST_URL: `${authorization.dashboardUrl}/projects/v3/${resolvedConfig.project}/test?environment=${options.env === "prod" ? "prod" : "stg"}`,
+        },
+        outputs: {
+            deploymentVersion: version,
+            workerVersion: version,
+            deploymentShortCode: deployment.shortCode,
+            deploymentUrl: `${authorization.dashboardUrl}/projects/v3/${resolvedConfig.project}/deployments/${deployment.shortCode}`,
+            testUrl: `${authorization.dashboardUrl}/projects/v3/${resolvedConfig.project}/test?environment=${options.env === "prod" ? "prod" : "stg"}`,
+            needsPromotion: options.skipPromotion ? "true" : "false",
+        },
     });
-    await writeFile(join(outputPath, "Containerfile"), containerfile);
 }
-export async function syncEnvVarsWithServer(apiClient, projectRef, environmentSlug, envVars) {
-    const uploadResult = await apiClient.importEnvVars(projectRef, environmentSlug, {
+export async function syncEnvVarsWithServer(apiClient, projectRef, environmentSlug, envVars, parentEnvVars) {
+    return await apiClient.importEnvVars(projectRef, environmentSlug, {
         variables: envVars,
+        parentVariables: parentEnvVars,
         override: true,
     });
-    return uploadResult.success;
 }
 async function failDeploy(client, deployment, error, logs, $spinner, warnings, errors) {
+    logger.debug("failDeploy", { error, logs, warnings, errors });
     $spinner.stop(`Failed to deploy project`);
     const doOutputLogs = async (prefix = "Error") => {
         if (logs.trim() !== "") {
@@ -347,9 +396,20 @@ async function failDeploy(client, deployment, error, logs, $spinner, warnings, e
             printErrors(errors);
             checkLogsForErrors(logs);
             outro(`${chalkError(`${prefix}:`)} ${error.message}. Full build logs have been saved to ${logPath}`);
+            // Display the last few lines of the logs, remove #-prefixed ones
+            const lastFewLines = logs
+                .split("\n")
+                .filter((line) => !line.startsWith("#"))
+                .filter((line) => line.trim() !== "")
+                .slice(-5)
+                .join("\n");
+            if (lastFewLines.trim() !== "") {
+                console.log("Last few lines of logs:\n");
+                console.log(lastFewLines);
+            }
         }
         else {
-            outro(`${chalkError(`${prefix}:`)} ${error.message}.`);
+            outro(`${chalkError(`${prefix}:`)} ${error.message}`);
         }
     };
     const exitCommand = (message) => {
@@ -382,7 +442,7 @@ async function failDeploy(client, deployment, error, logs, $spinner, warnings, e
                     ? prepareDeploymentError(serverDeployment.errorData)
                     : undefined;
                 if (errorData) {
-                    prettyError(errorData.name, errorData.stack, errorData.stderr);
+                    prettyError(errorData.message, errorData.stack, errorData.stderr);
                     if (logs.trim() !== "") {
                         const logPath = await saveLogs(deployment.shortCode, logs);
                         outro(`Aborting deployment. Full build logs have been saved to ${logPath}`);
@@ -410,4 +470,55 @@ async function failDeploy(client, deployment, error, logs, $spinner, warnings, e
         }
     }
 }
+async function initializeOrAttachDeployment(apiClient, data, existingDeploymentId) {
+    if (existingDeploymentId) {
+        // In the build server we initialize the deployment before installing the project dependencies,
+        // so that the status is correctly reflected in the dashboard. In this case, we need to attach
+        // to the existing deployment and continue with the remote build process.
+        // This is a workaround to avoid major changes in the deploy command and workflow. In the future,
+        // we'll likely make the build server the entry point of the flow for building and deploying and also
+        // adapt the related deployment API endpoints.
+        const existingDeploymentOrError = await apiClient.getDeployment(existingDeploymentId);
+        if (!existingDeploymentOrError.success) {
+            throw new Error(`Failed to attach to existing deployment: ${existingDeploymentOrError.error}`);
+        }
+        const { imageReference, status } = existingDeploymentOrError.data;
+        if (!imageReference) {
+            // this is just an artifact of our current DB schema
+            // `imageReference` is stored as nullable, but it should always exist
+            throw new Error("Existing deployment does not have an image reference");
+        }
+        if (status === "CANCELED" ||
+            status === "FAILED" ||
+            status === "TIMED_OUT" ||
+            status === "DEPLOYED") {
+            throw new Error(`Existing deployment is in an unexpected state: ${status}`);
+        }
+        return {
+            ...existingDeploymentOrError.data,
+            imageTag: imageReference,
+        };
+    }
+    const newDeploymentOrError = await apiClient.initializeDeployment({
+        ...data,
+    });
+    if (!newDeploymentOrError.success) {
+        throw new Error(`Failed to start deployment: ${newDeploymentOrError.error}`);
+    }
+    return newDeploymentOrError.data;
+}
+export function verifyDirectory(dir, projectPath) {
+    if (dir !== "." && !isDirectory(projectPath)) {
+        if (dir === "staging" || dir === "prod" || dir === "preview") {
+            throw new Error(`To deploy to ${dir}, you need to pass "--env ${dir}", not just "${dir}".`);
+        }
+        if (dir === "production") {
+            throw new Error(`To deploy to production, you need to pass "--env prod", not "production".`);
+        }
+        if (dir === "stg") {
+            throw new Error(`To deploy to staging, you need to pass "--env staging", not "stg".`);
+        }
+        throw new Error(`Directory "${dir}" not found at ${projectPath}`);
+    }
+}
 //# sourceMappingURL=deploy.js.map