fix(cli): address init review feedback

- --entry now fails with a usage error for frameworks that derive
  their entrypoint from build output, instead of being silently dropped
- entry resolution moved after the interactive adjust step and
  validates against the final framework, so a framework switch cannot
  write a stale or missing entry
- the post-write types step degrades to a skip with a warning when
  package.json is unreadable, so a malformed file cannot fail the
  command after the config was written (retry no longer gets stuck on
  INIT_CONFIG_EXISTS)
- init presenter drops its bespoke warning lines now that the runner
  renders success warnings (cherry-picked from the project PR)
- INIT_CONFIG_EXISTS and INIT_DETECTION_FAILED registered in
  error-conventions.md

Author: AmanVarshney01

docs/product/error-conventions.md

@@ -187,6 +187,8 @@ These codes are the minimum stable set for the MVP:
 - `BUILD_SETTINGS_MIGRATION_REQUIRED`
 - `BUILD_SETTINGS_UNSUPPORTED`
 - `FRAMEWORK_NOT_DETECTED`
+- `INIT_CONFIG_EXISTS`
+- `INIT_DETECTION_FAILED`
 - `DEPLOYMENT_NOT_FOUND`
 - `NO_DEPLOYMENTS`
 - `NO_PREVIOUS_DEPLOYMENT`
@@ -258,6 +260,8 @@ Recommended meanings:
 - `BUILD_SETTINGS_MIGRATION_REQUIRED`: a legacy `prisma.app.json` contains custom build settings that must move into the `build` block of `prisma.compute.ts`
 - `BUILD_SETTINGS_UNSUPPORTED`: a compute config `build` block targets a framework whose SDK strategy does not consume committed build settings
 - `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_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
 - `NO_PREVIOUS_DEPLOYMENT`: rollback could not find an earlier deployment for the selected app

packages/cli/src/controllers/init.ts

@@ -83,14 +83,16 @@ export async function runInit(
     value: defaultHttpPortForBuildType(frameworkByKey(framework.key).buildType),
     source: "framework default",
   };
-  const entry = await resolveInitEntry(cwd, framework.key, flags.entry, signal);
-
   const adjusted = await maybeAdjustSettings(context, framework, httpPort, {
     portExplicit: flags.httpPort !== undefined,
   });
   framework = adjusted.framework;
   httpPort = adjusted.httpPort;
 
+  // Entry resolves against the FINAL framework so an interactive framework
+  // switch cannot leave a stale (or missing) entry in the written config.
+  const entry = await resolveInitEntry(cwd, framework, flags.entry, signal);
+
   const settings: InitSettingRow[] = [
     { key: "app", value: name.value, source: name.source },
     {
@@ -203,7 +205,25 @@ async function resolveInitTypes(
   hooks: { onWarning: (message: string) => void },
 ): Promise<InitTypesState> {
   const cwd = context.runtime.cwd;
-  const packageJson = await readBunPackageJson(cwd, context.runtime.signal);
+  // This step runs after prisma.compute.ts is written; an unreadable
+  // package.json (malformed JSON, permissions) must not turn the already
+  // successful write into a command failure, so it degrades to a skip.
+  let packageJson: Awaited<ReturnType<typeof readBunPackageJson>>;
+  try {
+    packageJson = await readBunPackageJson(cwd, context.runtime.signal);
+  } catch (error) {
+    if (context.runtime.signal.aborted) {
+      throw error;
+    }
+    hooks.onWarning(
+      `Skipped the ${COMPUTE_SDK_PACKAGE} types install: package.json could not be read (${error instanceof Error ? error.message.split("\n")[0] : String(error)}).`,
+    );
+    return {
+      status: "skipped",
+      package: COMPUTE_SDK_PACKAGE,
+      installCommand: null,
+    };
+  }
   if (hasComputeSdkDependency(packageJson)) {
     return {
       status: "already-installed",
@@ -496,16 +516,25 @@ function parseInitRegion(
 
 async function resolveInitEntry(
   cwd: string,
-  frameworkKey: ComputeFramework,
+  resolvedFramework: ResolvedInitFramework,
   explicitEntry: string | undefined,
   signal: AbortSignal,
 ): Promise<{ value: string; source: string } | undefined> {
-  const framework = frameworkByKey(frameworkKey);
+  const framework = frameworkByKey(resolvedFramework.key);
+  const trimmed = explicitEntry?.trim();
   if (!framework.usesEntrypoint) {
+    if (trimmed) {
+      throw usageError(
+        "--entry is not supported for this framework",
+        `${resolvedFramework.displayName} derives its entrypoint from build output; --entry applies only to frameworks that run a source entrypoint (Bun, Hono).`,
+        "Drop --entry, or pass an entrypoint framework with --framework.",
+        [],
+        "app",
+      );
+    }
     return undefined;
   }
 
-  const trimmed = explicitEntry?.trim();
   if (trimmed) {
     return { value: trimmed, source: "flag" };
   }

packages/cli/src/presenters/init.ts

@@ -17,6 +17,8 @@ export function renderInit(
     renderSummaryLine(ui, "success", `Wrote ${result.configPath}`),
   ];
 
+  // Failed steps surface through the runner's success-warning rendering, so
+  // this block only covers the success and quiet-hint cases.
   if (result.types.status === "installed") {
     lines.push(
       renderSummaryLine(
@@ -25,16 +27,8 @@ export function renderInit(
         `Installed ${result.types.package} (config types)`,
       ),
     );
-  } else if (result.types.status === "failed" && result.types.installCommand) {
-    lines.push(
-      renderSummaryLine(
-        ui,
-        "warning",
-        `Could not install ${result.types.package}; install later with ${result.types.installCommand}`,
-      ),
-    );
   } else if (
-    result.types.status !== "already-installed" &&
+    (result.types.status === "skipped" || result.types.status === "declined") &&
     result.types.installCommand
   ) {
     lines.push(
@@ -61,14 +55,7 @@ export function renderInit(
       );
       break;
     case "failed":
-      // Human mode does not render success.warnings, so surface it here.
-      lines.push(
-        renderSummaryLine(
-          ui,
-          "warning",
-          `Project link failed; link later with ${formatCommand(["project", "link"])}`,
-        ),
-      );
+      // The failure detail renders via the runner's success-warning lines.
       break;
   }
 

packages/cli/tests/init.test.ts

@@ -411,3 +411,65 @@ describe("init types install", () => {
     expect(payload.warnings[0]).toContain("npm install -D @prisma/compute-sdk");
   });
 });
+
+describe("init edge cases", () => {
+  it("rejects --entry for frameworks that derive their entrypoint", async () => {
+    const cwd = await createTempCwd();
+    const stateDir = path.join(cwd, ".state");
+    await writePackageJson(cwd, { name: "web" });
+
+    const result = await executeCli({
+      argv: [
+        "init",
+        "--framework",
+        "nextjs",
+        "--entry",
+        "src/index.ts",
+        "--json",
+      ],
+      cwd,
+      stateDir,
+      fixturePath,
+    });
+    const payload = JSON.parse(result.stdout);
+
+    expect(result.exitCode).toBe(2);
+    expect(payload).toMatchObject({
+      ok: false,
+      command: "init",
+      error: { code: "USAGE_ERROR" },
+    });
+    await expect(readConfig(cwd)).rejects.toMatchObject({ code: "ENOENT" });
+  });
+
+  it("keeps the written config when package.json is unreadable in the types step", async () => {
+    const cwd = await createTempCwd();
+    const stateDir = path.join(cwd, ".state");
+    await writeFile(path.join(cwd, "package.json"), "{ not json", "utf8");
+
+    const result = await executeCli({
+      argv: [
+        "init",
+        "--framework",
+        "hono",
+        "--entry",
+        "src/index.ts",
+        "--name",
+        "api",
+        "--no-link",
+        "--install",
+        "--json",
+      ],
+      cwd,
+      stateDir,
+      fixturePath,
+    });
+    const payload = JSON.parse(result.stdout);
+
+    expect(result.exitCode).toBe(0);
+    expect(payload.ok).toBe(true);
+    expect(payload.result.types.status).toBe("skipped");
+    expect(payload.warnings[0]).toContain("package.json could not be read");
+    await expect(readConfig(cwd)).resolves.toContain('framework: "hono"');
+  });
+});