fix(cli): apply build path modifiers in one place, keep every native dry run local

--local-bundle, --detach and --dry-run are applied after the build path is
resolved, whether a flag or the server chose it. A native dry run now
always bundles locally on the Depot path (it previously deployed for real
with --native-build --dry-run), and --local-bundle --dry-run stays on the
local bundle path, which supports dry runs.

Author: myftija

packages/cli-v3/src/deploy/buildPath.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { applyBuildPathOptions } from "./buildPath.js";
+
+const none = { localBundle: false, detach: false, dryRun: false };
+
+describe("applyBuildPathOptions", () => {
+  it("passes the resolved path through without modifiers", () => {
+    expect(applyBuildPathOptions("depot", none)).toBe("depot");
+    expect(applyBuildPathOptions("native", none)).toBe("native");
+    expect(applyBuildPathOptions("native_local_bundle", none)).toBe("native_local_bundle");
+  });
+
+  it("upgrades a native path to the local bundle variant with --local-bundle", () => {
+    expect(applyBuildPathOptions("native", { ...none, localBundle: true })).toBe(
+      "native_local_bundle"
+    );
+  });
+
+  it("rejects --local-bundle and --detach on Depot", () => {
+    expect(() => applyBuildPathOptions("depot", { ...none, localBundle: true })).toThrow(
+      /--local-bundle is only available with the native build server/
+    );
+    expect(() => applyBuildPathOptions("depot", { ...none, detach: true })).toThrow(
+      /--detach is only available with the native build server/
+    );
+  });
+
+  it("keeps --detach on the native paths", () => {
+    expect(applyBuildPathOptions("native", { ...none, detach: true })).toBe("native");
+    expect(applyBuildPathOptions("native_local_bundle", { ...none, detach: true })).toBe(
+      "native_local_bundle"
+    );
+  });
+
+  it("moves a native dry run onto the Depot path, however native was chosen", () => {
+    expect(applyBuildPathOptions("native", { ...none, dryRun: true })).toBe("depot");
+  });
+
+  it("lets a local-bundle dry run stay on the local bundle path", () => {
+    expect(applyBuildPathOptions("native", { ...none, localBundle: true, dryRun: true })).toBe(
+      "native_local_bundle"
+    );
+    expect(applyBuildPathOptions("native_local_bundle", { ...none, dryRun: true })).toBe(
+      "native_local_bundle"
+    );
+  });
+});

packages/cli-v3/src/deploy/buildPath.ts

@@ -0,0 +1,40 @@
+import type { DeployBuildPath } from "@trigger.dev/core/v3/schemas";
+
+export type BuildPathOptions = {
+  localBundle: boolean;
+  detach: boolean;
+  dryRun: boolean;
+};
+
+/**
+ * Applies the native-only modifiers to the resolved build path. --local-bundle and --detach
+ * need the native build server: with it they apply, on Depot they throw. A dry run never
+ * reaches the plain native path (it has no dry-run mode and would deploy for real); it is
+ * bundled locally on the Depot path instead. The local-bundle path handles dry runs itself.
+ */
+export function applyBuildPathOptions(
+  resolved: DeployBuildPath,
+  options: BuildPathOptions
+): DeployBuildPath {
+  const nativeOnly = options.localBundle
+    ? "--local-bundle"
+    : options.detach
+      ? "--detach"
+      : undefined;
+
+  if (nativeOnly && resolved === "depot") {
+    throw new Error(
+      `${nativeOnly} is only available with the native build server. Pass --native-build, or configure the native build path for this environment.`
+    );
+  }
+
+  if (options.localBundle) {
+    return "native_local_bundle";
+  }
+
+  if (options.dryRun && resolved === "native") {
+    return "depot";
+  }
+
+  return resolved;
+}