feat(cli): init offers to install @prisma/compute-sdk for config types

The generated config's typed import resolves at deploy time without a
local install, but editors need @prisma/compute-sdk locally for types.
After writing the config, init now detects an existing dependency,
otherwise offers the detected package manager's add command (pnpm add
-D / bun add -d / yarn add -D / npm install -D). --install forces it,
--no-install skips, non-interactive skips with the add command in
nextSteps, and a failed install downgrades to a visible warning with
the exact command; the config write always stands.

Also surfaces types/link failures in human output directly, since the
runner does not render success warnings in human mode.

Author: AmanVarshney01

docs/product/command-spec.md

@@ -384,7 +384,7 @@ prisma-cli --version --json
 
 `prisma-cli version` is the richer environment report; `prisma-cli --version` is the terse one-liner. Both report the same `cli.version`. Use the flag for quick checks, the subcommand for support tickets and bug reports.
 
-## `prisma-cli init --framework <nextjs|nuxt|astro|hono|nestjs|tanstack-start|bun|custom> --entry <path> --http-port <port> --region <region> --name <app-name> --link --no-link --project <id-or-name>`
+## `prisma-cli init --framework <nextjs|nuxt|astro|hono|nestjs|tanstack-start|bun|custom> --entry <path> --http-port <port> --region <region> --name <app-name> --link --no-link --project <id-or-name> --install --no-install`
 
 Purpose:
 
@@ -403,6 +403,12 @@ Behavior:
 - init never scaffolds application code, never creates schema or database resources, and never deploys
 - with `--framework custom`, the config includes a commented `build` stub, since custom artifacts require `build.outputDirectory` and `build.entrypoint` before deploy can use them
 - when detection fails and no `--framework` is passed: interactive mode prompts for the framework from the supported list; non-interactive and `--json` mode fail with `INIT_DETECTION_FAILED`, with `nextActions` enumerating the `--framework` choices
+- types step, after the config is written: the generated config's typed import (`@prisma/compute-sdk/config`) is resolved by the CLI at deploy time without a local install, so a local `@prisma/compute-sdk` devDependency exists purely for editor types
+  - when the package is already a dependency or devDependency, the step is a no-op
+  - interactive mode asks `Install @prisma/compute-sdk for config types?` (default yes) and runs the detected package manager's add command (`pnpm add -D`, `bun add -d`, `yarn add -D`, `npm install -D`)
+  - `--install` runs the install without prompting; `--no-install` skips the step; non-interactive and `--json` mode skip by default
+  - a skipped, declined, or failed install downgrades to a hint or warning with the exact add command in `nextSteps`; the config write stands and init exits 0
+  - a directory without a `package.json` skips the step with the hint
 - link step, after the config is written:
   - interactive mode asks `Link this directory to a Prisma Project now? (Y/n)` when the directory has no project binding; accepting enters the same picker `project link` uses
   - `--no-link` suppresses the question; `--link` requires the step; `--project <id-or-name>` links to that project without prompting

packages/cli/src/commands/init/index.ts

@@ -39,7 +39,11 @@ export function createInitCommand(runtime: CliRuntime): Command {
     .addOption(new Option("--no-link", "Skip the Project link step"))
     .addOption(
       new Option("--project <id-or-name>", "Project to link this directory to"),
-    );
+    )
+    .addOption(
+      new Option("--install", "Install @prisma/compute-sdk for config types"),
+    )
+    .addOption(new Option("--no-install", "Skip the types install step"));
   addGlobalFlags(command);
 
   command.action(async (options) => {
@@ -51,6 +55,7 @@ export function createInitCommand(runtime: CliRuntime): Command {
       name?: string;
       link?: boolean;
       project?: string;
+      install?: boolean;
     };
 
     await runCommand<InitResult>(
@@ -66,6 +71,7 @@ export function createInitCommand(runtime: CliRuntime): Command {
           name: flags.name,
           link: flags.link,
           project: flags.project,
+          install: flags.install,
         }),
       {
         renderHuman: (context, descriptor, result) =>

packages/cli/src/controllers/init.ts

@@ -1,6 +1,5 @@
 import { writeFile } from "node:fs/promises";
 import path from "node:path";
-
 import {
   COMPUTE_CONFIG_FILENAME,
   COMPUTE_REGIONS,
@@ -15,11 +14,16 @@ import {
   frameworkFromAlias,
   serializeComputeConfig,
 } from "@prisma/compute-sdk/config";
+import { execa } from "execa";
 
 import {
   type PrismaCliPackageCommandFormatter,
   resolvePrismaCliPackageCommandFormatterSync,
 } from "../lib/agent/cli-command";
+import {
+  type AgentPackageManager,
+  detectPackageManagerSync,
+} from "../lib/agent/package-manager";
 import {
   readBunPackageEntrypoint,
   readBunPackageJson,
@@ -34,7 +38,12 @@ import {
   textPrompt,
 } from "../shell/prompt";
 import { type CommandContext, canPrompt } from "../shell/runtime";
-import type { InitLinkState, InitResult, InitSettingRow } from "../types/init";
+import type {
+  InitLinkState,
+  InitResult,
+  InitSettingRow,
+  InitTypesState,
+} from "../types/init";
 import { detectDeployFramework } from "./app";
 import { runProjectLink } from "./project";
 
@@ -46,6 +55,7 @@ export interface InitFlags {
   name?: string;
   link?: boolean;
   project?: string;
+  install?: boolean;
 }
 
 interface ResolvedInitFramework {
@@ -129,12 +139,17 @@ export async function runInit(
   }
 
   const warnings: string[] = [];
+  const types = await resolveInitTypes(context, flags, {
+    onWarning: (message) => warnings.push(message),
+  });
   const link = await resolveInitLink(context, flags, {
     onWarning: (message) => warnings.push(message),
     formatCommand,
   });
 
   const unlinked = link.status !== "linked" && link.status !== "already-linked";
+  const typesMissing =
+    types.status !== "installed" && types.status !== "already-installed";
   return {
     command: "init",
     result: {
@@ -148,16 +163,161 @@ export async function runInit(
         ...(region ? { region } : {}),
       },
       settings,
+      types,
       link,
     },
     warnings,
     nextSteps: [
+      ...(typesMissing && types.installCommand ? [types.installCommand] : []),
       formatCommand(["app", "deploy"]),
       ...(unlinked ? [formatCommand(["project", "link"])] : []),
     ],
   };
 }
 
+/** Dev dependency that provides editor types for the generated config. */
+const COMPUTE_SDK_PACKAGE = "@prisma/compute-sdk";
+
+function packageAddCommand(packageManager: AgentPackageManager): string[] {
+  switch (packageManager) {
+    case "pnpm":
+      return ["pnpm", "add", "-D", COMPUTE_SDK_PACKAGE];
+    case "bun":
+      return ["bun", "add", "-d", COMPUTE_SDK_PACKAGE];
+    case "yarn":
+      return ["yarn", "add", "-D", COMPUTE_SDK_PACKAGE];
+    case "npm":
+      return ["npm", "install", "-D", COMPUTE_SDK_PACKAGE];
+  }
+}
+
+/**
+ * Offers to install `@prisma/compute-sdk` as a devDependency so the generated
+ * config's typed import resolves in the editor. Deploy resolves the import
+ * without a local install, so every outcome short of success is a hint, never
+ * a failure.
+ */
+async function resolveInitTypes(
+  context: CommandContext,
+  flags: InitFlags,
+  hooks: { onWarning: (message: string) => void },
+): Promise<InitTypesState> {
+  const cwd = context.runtime.cwd;
+  const packageJson = await readBunPackageJson(cwd, context.runtime.signal);
+  if (hasComputeSdkDependency(packageJson)) {
+    return {
+      status: "already-installed",
+      package: COMPUTE_SDK_PACKAGE,
+      installCommand: null,
+    };
+  }
+
+  const packageManager = detectPackageManagerSync(cwd) ?? "npm";
+  const installCommand = packageAddCommand(packageManager);
+  const installCommandText = installCommand.join(" ");
+  const state = (status: InitTypesState["status"]): InitTypesState => ({
+    status,
+    package: COMPUTE_SDK_PACKAGE,
+    installCommand: installCommandText,
+  });
+
+  // A directory without a package.json has nowhere to record the dependency.
+  if (!packageJson) {
+    return state("skipped");
+  }
+
+  if (flags.install === false) {
+    return state("skipped");
+  }
+
+  let shouldInstall = flags.install === true;
+  if (!shouldInstall) {
+    if (!canPrompt(context) || context.flags.yes) {
+      return state("skipped");
+    }
+    try {
+      shouldInstall = await confirmPrompt({
+        input: context.runtime.stdin,
+        output: context.output.stderr,
+        signal: context.runtime.signal,
+        message: `Install ${COMPUTE_SDK_PACKAGE} for config types? (${installCommandText})`,
+        initialValue: true,
+      });
+    } catch (error) {
+      if (isPromptCancelError(error)) {
+        return state("declined");
+      }
+      throw error;
+    }
+    if (!shouldInstall) {
+      return state("declined");
+    }
+  }
+
+  const command = resolveInitInstallCommandOverride(context) ?? installCommand;
+  if (!context.flags.quiet && !context.flags.json) {
+    context.output.stderr.write(`Installing ${COMPUTE_SDK_PACKAGE}...\n`);
+  }
+  try {
+    const [executable, ...args] = command;
+    await execa(executable as string, args, {
+      cwd,
+      env: context.runtime.env,
+      cancelSignal: context.runtime.signal,
+      stdin: "ignore",
+    });
+    return state("installed");
+  } catch (error) {
+    if (context.runtime.signal.aborted) {
+      throw error;
+    }
+    // execa's first message line is the short "Command failed" summary; the
+    // full package-manager output stays out of the warning.
+    const detail =
+      error instanceof Error ? error.message.split("\n")[0] : String(error);
+    hooks.onWarning(
+      `Installing ${COMPUTE_SDK_PACKAGE} failed: ${detail}. Install it later with ${installCommandText}.`,
+    );
+    return state("failed");
+  }
+}
+
+function hasComputeSdkDependency(
+  packageJson: Awaited<ReturnType<typeof readBunPackageJson>>,
+): boolean {
+  for (const group of [
+    packageJson?.dependencies,
+    packageJson?.devDependencies,
+  ]) {
+    if (
+      group &&
+      typeof group === "object" &&
+      COMPUTE_SDK_PACKAGE in (group as Record<string, unknown>)
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Test hook: JSON array command that replaces the real package-manager install. */
+function resolveInitInstallCommandOverride(
+  context: CommandContext,
+): string[] | null {
+  const raw = context.runtime.env.PRISMA_CLI_INIT_INSTALL_COMMAND;
+  if (!raw) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) && parsed.every((p) => typeof p === "string")
+      ? parsed
+      : null;
+  } catch {
+    return null;
+  }
+}
+
 const CUSTOM_BUILD_STUB = `
 // framework "custom" deploys a prebuilt artifact. Add its build settings:
 // build: {

packages/cli/src/presenters/init.ts

@@ -17,6 +17,31 @@ export function renderInit(
     renderSummaryLine(ui, "success", `Wrote ${result.configPath}`),
   ];
 
+  if (result.types.status === "installed") {
+    lines.push(
+      renderSummaryLine(
+        ui,
+        "success",
+        `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.installCommand
+  ) {
+    lines.push(
+      `  ${ui.dim(`For editor types: ${result.types.installCommand}`)}`,
+    );
+  }
+
   switch (result.link.status) {
     case "linked":
       lines.push(
@@ -36,7 +61,14 @@ export function renderInit(
       );
       break;
     case "failed":
-      // The failure detail is in warnings; nothing extra here.
+      // 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"])}`,
+        ),
+      );
       break;
   }
 

packages/cli/src/types/init.ts

@@ -19,6 +19,20 @@ export interface InitLinkState {
   } | null;
 }
 
+export type InitTypesStatus =
+  | "installed"
+  | "already-installed"
+  | "skipped"
+  | "declined"
+  | "failed";
+
+export interface InitTypesState {
+  status: InitTypesStatus;
+  package: string;
+  /** Human-runnable install command for hints when not installed. */
+  installCommand: string | null;
+}
+
 export interface InitResult {
   configPath: string;
   directory: string;
@@ -30,5 +44,6 @@ export interface InitResult {
     region?: string;
   };
   settings: InitSettingRow[];
+  types: InitTypesState;
   link: InitLinkState;
 }