Initial autoconfig scaffolding (#11149)

* Initial autoconfig

* Convert autoconfig types comments to JSDoc style

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

---------

Co-authored-by: Claude <[email protected]>

Author: penalosa

.changeset/soft-flies-drive.md

@@ -0,0 +1,5 @@
+---
+"wrangler": minor
+---
+
+Add no-op autoconfig logic behind an experimental flag

packages/wrangler/src/__tests__/autoconfig.test.ts

@@ -0,0 +1,93 @@
+import { FatalError } from "@cloudflare/workers-utils";
+import { vi } from "vitest";
+import * as details from "../autoconfig/get-details";
+import * as run from "../autoconfig/run";
+import * as format from "../deployment-bundle/guess-worker-format";
+import { clearOutputFilePath } from "../output";
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { clearDialogs } from "./helpers/mock-dialogs";
+import { useMockIsTTY } from "./helpers/mock-istty";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import { writeWorkerSource } from "./helpers/write-worker-source";
+import { writeWranglerConfig } from "./helpers/write-wrangler-config";
+
+vi.mock("../deploy/deploy", async (importOriginal) => ({
+	...(await importOriginal()),
+	default: () => {
+		// In unit tests of autoconfig we only care about the configuration aspect, so bail before any actual deployment happens
+		throw new FatalError("Bailing early in tests");
+	},
+}));
+
+async function runDeploy(withArgs: string = "") {
+	// Expect "Bailing early in tests" to be thrown
+	await expect(runWrangler(`deploy ${withArgs}`)).rejects.toThrowError();
+}
+
+// We don't care about module/service worker detection in the autoconfig tests,
+// and mocking it out speeds up the tests by removing an esbuild invocation
+vi.spyOn(format, "guessWorkerFormat").mockImplementation(() =>
+	Promise.resolve({
+		format: "modules",
+		exports: [],
+	})
+);
+
+describe("autoconfig (deploy)", () => {
+	mockAccountId();
+	mockApiToken();
+	runInTempDir();
+	const { setIsTTY } = useMockIsTTY();
+
+	beforeEach(() => {
+		setIsTTY(true);
+	});
+
+	afterEach(() => {
+		vi.unstubAllGlobals();
+		clearDialogs();
+		clearOutputFilePath();
+	});
+
+	it("should not check for autoconfig without flag", async () => {
+		writeWorkerSource();
+		writeWranglerConfig({ main: "index.js" });
+		const getDetailsSpy = vi.spyOn(details, "getDetailsForAutoConfig");
+		await runDeploy();
+
+		expect(getDetailsSpy).not.toHaveBeenCalled();
+	});
+
+	it("should check for autoconfig with flag", async () => {
+		const getDetailsSpy = vi.spyOn(details, "getDetailsForAutoConfig");
+
+		await runDeploy("--x-autoconfig");
+
+		expect(getDetailsSpy).toHaveBeenCalled();
+	});
+
+	it("should run autoconfig if project is not configured", async () => {
+		const getDetailsSpy = vi
+			.spyOn(details, "getDetailsForAutoConfig")
+			.mockImplementationOnce(() => Promise.resolve({ configured: false }));
+		const runSpy = vi.spyOn(run, "runAutoConfig");
+
+		await runDeploy("--x-autoconfig");
+
+		expect(getDetailsSpy).toHaveBeenCalled();
+		expect(runSpy).toHaveBeenCalled();
+	});
+
+	it("should not run autoconfig if project is already configured", async () => {
+		const getDetailsSpy = vi
+			.spyOn(details, "getDetailsForAutoConfig")
+			.mockImplementationOnce(() => Promise.resolve({ configured: true }));
+		const runSpy = vi.spyOn(run, "runAutoConfig");
+
+		await runDeploy("--x-autoconfig");
+
+		expect(getDetailsSpy).toHaveBeenCalled();
+		expect(runSpy).not.toHaveBeenCalled();
+	});
+});

packages/wrangler/src/__tests__/guess-worker-format.test.ts

@@ -1,6 +1,6 @@
 import { writeFile } from "fs/promises";
 import path from "path";
-import guessWorkerFormat from "../deployment-bundle/guess-worker-format";
+import { guessWorkerFormat } from "../deployment-bundle/guess-worker-format";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 

packages/wrangler/src/autoconfig/get-details.ts

@@ -0,0 +1,11 @@
+import { logger } from "../logger";
+import type { AutoConfigDetails } from "./types";
+
+export async function getDetailsForAutoConfig(options?: {
+	projectPath?: string; // the path to the project, defaults to cwd
+}): Promise<AutoConfigDetails> {
+	logger.debug(
+		`Running autoconfig detection in ${options?.projectPath ?? process.cwd()}...`
+	);
+	return { configured: true };
+}

packages/wrangler/src/autoconfig/run.ts

@@ -0,0 +1,11 @@
+import { logger } from "../logger";
+import type { AutoConfigDetails } from "./types";
+
+export async function runAutoConfig(
+	autoConfigDetails: AutoConfigDetails
+): Promise<void> {
+	logger.debug(
+		`Running autoconfig with:\n${JSON.stringify(autoConfigDetails, null, 2)}...`
+	);
+	return;
+}

packages/wrangler/src/autoconfig/types.ts

@@ -0,0 +1,21 @@
+export type AutoConfigDetails = {
+	/** The path to the project (defaults to cwd) */
+	projectPath?: string;
+	/** The content of the project's package.json file (if any) */
+	packageJson?: string;
+	/** Whether the project is already configured (no autoconfig required) */
+	configured: boolean;
+	/** Details about the detected framework (if any) */
+	framework?: {
+		/** The detected framework */
+		name: "astro";
+		/** The detected version of the framework */
+		version: string;
+		/** Whether the framework is used for static generation or fullstack deployment */
+		mode: "static" | "fullstack";
+	};
+	/** The build command used to build the project (if any) */
+	buildCommand?: string;
+	/** The output directory (if no framework is used, points to the raw asset files) */
+	outputDir?: string;
+};

packages/wrangler/src/deploy/index.ts

@@ -8,6 +8,9 @@ import {
 } from "@cloudflare/workers-utils";
 import chalk from "chalk";
 import { getAssetsOptions, validateAssetsArgsAndConfig } from "../assets";
+import { getDetailsForAutoConfig } from "../autoconfig/get-details";
+import { runAutoConfig } from "../autoconfig/run";
+import { readConfig } from "../config";
 import { createCommand } from "../core/create-command";
 import { getEntry } from "../deployment-bundle/entry";
 import { confirm, prompt } from "../dialogs";
@@ -238,6 +241,13 @@ export const deployCommand = createCommand({
 			type: "boolean",
 			default: false,
 		},
+		"experimental-autoconfig": {
+			alias: ["x-autoconfig"],
+			describe:
+				"Experimental: Enables framework detection and automatic configuration when deploying",
+			type: "boolean",
+			default: false,
+		},
 	},
 	behaviour: {
 		useConfigRedirectIfAvailable: true,
@@ -265,6 +275,20 @@ export const deployCommand = createCommand({
 				{ telemetryMessage: true }
 			);
 		}
+		if (args.experimentalAutoconfig) {
+			const details = await getDetailsForAutoConfig();
+
+			// Only run auto config if the project is not already configured
+			if (!details.configured) {
+				await runAutoConfig(details);
+
+				// If autoconfig worked, there should now be a new config file, and so we need to read config again
+				config = readConfig(args, {
+					hideWarnings: false,
+					useRedirectIfAvailable: true,
+				});
+			}
+		}
 		// We use the `userConfigPath` to compute the root of a project,
 		// rather than a redirected (potentially generated) `configPath`.
 		const projectRoot =

packages/wrangler/src/deployment-bundle/entry.ts

@@ -7,7 +7,7 @@ import {
 } from "@cloudflare/workers-utils";
 import dedent from "ts-dedent";
 import { sniffUserAgent } from "../package-manager";
-import guessWorkerFormat from "./guess-worker-format";
+import { guessWorkerFormat } from "./guess-worker-format";
 import {
 	resolveEntryWithAssets,
 	resolveEntryWithEntryPoint,

packages/wrangler/src/deployment-bundle/guess-worker-format.ts

@@ -13,7 +13,7 @@ import type { CfScriptFormat } from "@cloudflare/workers-utils";
  * Else, it's a "service-worker" worker. This seems hacky, but works remarkably
  * well in practice.
  */
-export default async function guessWorkerFormat(
+export async function guessWorkerFormat(
 	entryFile: string,
 	entryWorkingDirectory: string,
 	tsconfig?: string | undefined