fix(cli): reject resolution flags during conversion; handle rollback double-fault

Review findings: init --format ts with an existing prisma.compute.json
silently ignored --framework/--entry/--name/--http-port/--region; they
now fail as a usage error since conversion transports values and never
re-resolves them. If the post-write JSON delete fails AND the rollback
delete also fails, the raw fs error escaped while two config files were
left coexisting; that now surfaces as structured INIT_CONVERT_INCOMPLETE
naming both files. Adds conversion tests for full field preservation
(env, build, root, project region) and multi-app configs including a
null build command.

Author: AmanVarshney01

docs/product/error-conventions.md

@@ -189,6 +189,7 @@ These codes are the minimum stable set for the MVP:
 - `FRAMEWORK_NOT_DETECTED`
 - `INIT_CONFIG_EXISTS`
 - `INIT_CONVERT_UNSUPPORTED`
+- `INIT_CONVERT_INCOMPLETE`
 - `INIT_DETECTION_FAILED`
 - `DEPLOYMENT_NOT_FOUND`
 - `NO_DEPLOYMENTS`
@@ -263,6 +264,7 @@ Recommended meanings:
 - `FRAMEWORK_NOT_DETECTED`: app deploy could not detect a supported Beta framework and no explicit framework/build type was provided
 - `INIT_CONFIG_EXISTS`: a compute config already exists in this directory or an ancestor; init never overwrites or merges
 - `INIT_CONVERT_UNSUPPORTED`: `init --format json` found an existing TypeScript config; TypeScript configs may contain logic, so converting them to JSON automatically would be lossy and the rewrite is manual
+- `INIT_CONVERT_INCOMPLETE`: a conversion wrote prisma.compute.ts but could not delete prisma.compute.json, and rolling back the write also failed; both files exist and one must be deleted by hand
 - `INIT_DETECTION_FAILED`: no supported framework detected and no --framework passed; `meta.frameworks` lists the valid values
 - `DEPLOYMENT_NOT_FOUND`: requested deployment id does not exist
 - `NO_DEPLOYMENTS`: command resolved a branch or app but found no deployments

packages/cli/src/controllers/init.ts

@@ -101,6 +101,7 @@ export async function runInit(
       solePath !== undefined && path.extname(solePath) === ".json";
     // Conversion must be explicit: plain init refuses every existing config.
     if (soleIsJson && format.value === "typescript" && format.explicit) {
+      rejectConversionResolutionFlags(flags, formatCommand);
       return runInitConversion(context, flags, solePath, formatCommand);
     }
     if (solePath && !soleIsJson && format.value === "json") {
@@ -460,6 +461,49 @@ function parseInitFormat(
   );
 }
 
+/**
+ * Conversion transports the existing config's values; it never re-resolves
+ * settings. Refusing resolution flags beats silently ignoring them.
+ */
+function rejectConversionResolutionFlags(
+  flags: InitFlags,
+  formatCommand: PrismaCliPackageCommandFormatter,
+): void {
+  const passed = [
+    flags.framework !== undefined ? "--framework" : null,
+    flags.entry !== undefined ? "--entry" : null,
+    flags.httpPort !== undefined ? "--http-port" : null,
+    flags.name !== undefined ? "--name" : null,
+    flags.region !== undefined ? "--region" : null,
+  ].filter((flag): flag is string => flag !== null);
+  if (passed.length === 0) {
+    return;
+  }
+  throw usageError(
+    `${passed.join(", ")} ${passed.length === 1 ? "does" : "do"} not apply when converting an existing config`,
+    `--format ts with an existing ${COMPUTE_CONFIG_JSON_FILENAME} converts it as-is; settings are transported, never re-resolved.`,
+    `Convert first, then edit ${COMPUTE_CONFIG_FILENAME} directly.`,
+    [formatCommand(["init", "--format", "ts"])],
+    "app",
+  );
+}
+
+function initConvertIncompleteError(
+  jsonConfigPath: string,
+  tsConfigPath: string,
+): CliError {
+  return new CliError({
+    code: "INIT_CONVERT_INCOMPLETE",
+    domain: "app",
+    summary: "Conversion left two config files behind",
+    why: `${path.basename(tsConfigPath)} was written but ${path.basename(jsonConfigPath)} could not be deleted, and rolling back the write also failed. Commands refuse to load a directory with two config files.`,
+    fix: `Delete one file by hand: keep ${path.basename(tsConfigPath)} to finish the conversion, or keep ${path.basename(jsonConfigPath)} to undo it.`,
+    exitCode: 1,
+    nextSteps: [],
+    meta: { jsonConfigPath, tsConfigPath },
+  });
+}
+
 function initConvertUnsupportedError(existingPath: string): CliError {
   return new CliError({
     code: "INIT_CONVERT_UNSUPPORTED",
@@ -529,7 +573,11 @@ async function runInitConversion(
   } catch (error) {
     // Two coexisting config files are a hard loader error, so a failed
     // delete rolls the write back and leaves the JSON config untouched.
-    await rm(tsConfigPath, { force: true });
+    try {
+      await rm(tsConfigPath, { force: true });
+    } catch {
+      throw initConvertIncompleteError(jsonConfigPath, tsConfigPath);
+    }
     throw error;
   }
 

packages/cli/tests/init.test.ts

@@ -715,6 +715,151 @@ describe("init config format", () => {
     });
   });
 
+  it("preserves env, build, root, and the project region through conversion", async () => {
+    const cwd = await createTempCwd();
+    const stateDir = path.join(cwd, ".state");
+    await writeFile(
+      path.join(cwd, "prisma.compute.json"),
+      `${JSON.stringify({
+        region: "eu-central-1",
+        app: {
+          name: "web",
+          framework: "nextjs",
+          root: "apps/web",
+          httpPort: 3000,
+          env: { file: ".env.production", vars: { NODE_ENV: "production" } },
+          build: { command: "pnpm build", outputDirectory: ".next" },
+        },
+      })}\n`,
+    );
+
+    const result = await executeCli({
+      argv: ["init", "--format", "ts", "--json"],
+      cwd,
+      stateDir,
+      fixturePath,
+    });
+    const payload = JSON.parse(result.stdout);
+
+    expect(result.exitCode).toBe(0);
+    expect(payload.result.converted).toBe(true);
+
+    const config = await readConfig(cwd);
+    expect(config).toContain('region: "eu-central-1"');
+    expect(config).toContain('root: "apps/web"');
+    expect(config).toContain('file: ".env.production"');
+    expect(config).toContain('NODE_ENV: "production"');
+    expect(config).toContain('command: "pnpm build"');
+    expect(config).toContain('outputDirectory: ".next"');
+
+    const loaded = await loadComputeConfig(cwd);
+    expect(loaded.isOk() && loaded.value?.targets[0]).toMatchObject({
+      name: "web",
+      framework: "nextjs",
+      root: "apps/web",
+      region: "eu-central-1",
+      envInputs: [".env.production", "NODE_ENV=production"],
+      build: {
+        command: "pnpm build",
+        outputDirectory: ".next",
+        entrypoint: undefined,
+      },
+    });
+  });
+
+  it("converts a multi-app config, including a null build command", async () => {
+    const cwd = await createTempCwd();
+    const stateDir = path.join(cwd, ".state");
+    await writeFile(
+      path.join(cwd, "prisma.compute.json"),
+      `${JSON.stringify({
+        apps: {
+          web: {
+            framework: "nextjs",
+            root: "apps/web",
+            build: { command: null },
+          },
+          api: {
+            framework: "hono",
+            root: "apps/api",
+            entry: "src/index.ts",
+            httpPort: 8080,
+          },
+        },
+      })}\n`,
+    );
+
+    const result = await executeCli({
+      argv: ["init", "--format", "ts", "--json"],
+      cwd,
+      stateDir,
+      fixturePath,
+    });
+    const payload = JSON.parse(result.stdout);
+
+    expect(result.exitCode).toBe(0);
+    expect(payload.result.converted).toBe(true);
+    // Multi-app configs carry no single app identity.
+    expect(payload.result.app).toBeNull();
+
+    const config = await readConfig(cwd);
+    expect(config).toContain("command: null");
+    await expect(readJsonConfig(cwd)).rejects.toMatchObject({
+      code: "ENOENT",
+    });
+
+    const loaded = await loadComputeConfig(cwd);
+    expect(loaded.isOk() && loaded.value?.kind).toBe("multi");
+    expect(loaded.isOk() && loaded.value?.targets).toEqual([
+      expect.objectContaining({
+        key: "web",
+        framework: "nextjs",
+        build: expect.objectContaining({ command: null }),
+      }),
+      expect.objectContaining({
+        key: "api",
+        framework: "hono",
+        entry: "src/index.ts",
+        httpPort: 8080,
+      }),
+    ]);
+  });
+
+  it("rejects resolution flags during conversion instead of ignoring them", async () => {
+    const cwd = await createTempCwd();
+    const stateDir = path.join(cwd, ".state");
+    const jsonSource = `${JSON.stringify({
+      app: { name: "api", framework: "hono", httpPort: 8080 },
+    })}\n`;
+    await writeFile(path.join(cwd, "prisma.compute.json"), jsonSource);
+
+    const result = await executeCli({
+      argv: [
+        "init",
+        "--format",
+        "ts",
+        "--framework",
+        "nextjs",
+        "--http-port",
+        "3000",
+        "--json",
+      ],
+      cwd,
+      stateDir,
+      fixturePath,
+    });
+    const payload = JSON.parse(result.stdout);
+
+    expect(result.exitCode).toBe(2);
+    expect(payload.error.code).toBe("USAGE_ERROR");
+    expect(payload.error.summary).toContain("--framework");
+    expect(payload.error.summary).toContain("--http-port");
+
+    // Nothing on disk changed: no TS config, JSON untouched.
+    await expect(readConfig(cwd)).rejects.toMatchObject({ code: "ENOENT" });
+    expect(await readJsonConfig(cwd)).toBe(jsonSource);
+  });
+
   it("runs the types install step when converting with --install", async () => {
     const cwd = await createTempCwd();
     const stateDir = path.join(cwd, ".state");