fix(cli): format new database command hints with the detected package runner

usage/backup/restore/rotate recovery commands, confirmation nextSteps,
and result nextSteps now render through the project's package runner
(pnpm dlx / bunx / npx -y with @prisma/cli@latest) instead of the
hardcoded prisma-cli bin name, matching the agent group's convention.
The management provider takes an optional formatter so its error
factories stay consistent with the invoking directory.

Author: AmanVarshney01

packages/cli/src/controllers/database.ts

@@ -1,5 +1,9 @@
 import { randomBytes } from "node:crypto";
 
+import {
+  type PrismaCliPackageCommandFormatter,
+  resolvePrismaCliPackageCommandFormatterSync,
+} from "../lib/agent/cli-command";
 import { requireComputeAuth } from "../lib/auth/guard";
 import {
   createManagementDatabaseProvider,
@@ -363,15 +367,26 @@ export async function runDatabaseUsage(
   databaseRef: string,
   flags: DatabaseUsageFlags,
 ): Promise<CommandSuccess<DatabaseUsageResult>> {
-  const from = parseUsageDate(flags.from, "--from");
-  const to = parseUsageDate(flags.to, "--to");
+  const formatCommand = resolvePrismaCliPackageCommandFormatterSync(
+    context.runtime.cwd,
+  );
+  const from = parseUsageDate(flags.from, "--from", formatCommand);
+  const to = parseUsageDate(flags.to, "--to", formatCommand);
   if (from && to && Date.parse(from) > Date.parse(to)) {
     throw usageError(
       "Invalid usage period",
       "--from must not be later than --to.",
       "Pass a --from date that is on or before the --to date.",
       [
-        "prisma-cli database usage <database> --from 2026-06-01 --to 2026-06-30",
+        formatCommand([
+          "database",
+          "usage",
+          "<database>",
+          "--from",
+          "2026-06-01",
+          "--to",
+          "2026-06-30",
+        ]),
       ],
       "database",
     );
@@ -416,7 +431,10 @@ export async function runDatabaseBackupList(
   databaseRef: string,
   flags: DatabaseBackupListFlags,
 ): Promise<CommandSuccess<DatabaseBackupListResult>> {
-  const limit = parseBackupLimit(flags.limit);
+  const limit = parseBackupLimit(
+    flags.limit,
+    resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd),
+  );
 
   const { provider, target } = await requireDatabaseContext(
     context,
@@ -456,13 +474,16 @@ export async function runDatabaseRestore(
   databaseRef: string,
   flags: DatabaseRestoreFlags,
 ): Promise<CommandSuccess<DatabaseRestoreResult>> {
+  const formatCommand = resolvePrismaCliPackageCommandFormatterSync(
+    context.runtime.cwd,
+  );
   const backupId = flags.backupId?.trim();
   if (!backupId) {
     throw usageError(
       "Backup id required",
       "Database restore needs the backup to restore from.",
-      "Pass --backup <backup-id> from prisma-cli database backup list.",
-      ["prisma-cli database backup list <database>"],
+      `Pass --backup <backup-id> from ${formatCommand(["database", "backup", "list", "<database>"])}.`,
+      [formatCommand(["database", "backup", "list", "<database>"])],
       "database",
     );
   }
@@ -500,7 +521,7 @@ export async function runDatabaseRestore(
     confirm: flags.confirm,
     summary: "Confirm database restore",
     why: "Restoring immediately and irreversibly overwrites all data in the target database, so it requires the exact target database id.",
-    nextStep: `prisma-cli database restore ${database.id} --backup ${backupId}${sourceDatabaseArg} --confirm ${database.id}`,
+    nextStep: `${formatCommand(["database", "restore", database.id, "--backup", backupId])}${sourceDatabaseArg} --confirm ${database.id}`,
   });
 
   const restored = await provider.restoreDatabase({
@@ -524,7 +545,7 @@ export async function runDatabaseRestore(
       },
     },
     warnings: [],
-    nextSteps: [`prisma-cli database show ${database.id}`],
+    nextSteps: [formatCommand(["database", "show", database.id])],
   };
 }
 
@@ -533,14 +554,24 @@ export async function runDatabaseConnectionRotate(
   connectionRef: string,
   flags: DatabaseConnectionRotateFlags,
 ): Promise<CommandSuccess<DatabaseConnectionRotateResult>> {
+  const formatCommand = resolvePrismaCliPackageCommandFormatterSync(
+    context.runtime.cwd,
+  );
   const connectionId = connectionRef.trim();
   if (!connectionId) {
     throw usageError(
       "Connection id required",
       "Database connection rotation needs a connection id.",
       "Pass the connection id to rotate.",
       [
-        "prisma-cli database connection rotate <connection-id> --confirm <connection-id>",
+        formatCommand([
+          "database",
+          "connection",
+          "rotate",
+          "<connection-id>",
+          "--confirm",
+          "<connection-id>",
+        ]),
       ],
       "database",
     );
@@ -553,6 +584,14 @@ export async function runDatabaseConnectionRotate(
     confirm: flags.confirm,
     summary: "Confirm database connection rotation",
     why: "Rotating revokes the previous credentials and breaks clients still using them, so it requires the exact connection id.",
+    nextStep: formatCommand([
+      "database",
+      "connection",
+      "rotate",
+      connectionId,
+      "--confirm",
+      connectionId,
+    ]),
   });
 
   const provider = await requireDatabaseProviderOnly(context);
@@ -578,6 +617,7 @@ const USAGE_DATETIME_PATTERN = /^\d{4}-\d{2}-\d{2}T/;
 function parseUsageDate(
   value: string | undefined,
   flagName: string,
+  formatCommand: PrismaCliPackageCommandFormatter,
 ): string | undefined {
   if (value === undefined) {
     return undefined;
@@ -603,7 +643,17 @@ function parseUsageDate(
     "Invalid usage period",
     `${flagName} must be an ISO date such as 2026-06-01 or an ISO datetime such as 2026-06-01T12:00:00Z.`,
     `Pass an ISO date or datetime to ${flagName}.`,
-    ["prisma-cli database usage <database> --from 2026-06-01 --to 2026-06-30"],
+    [
+      formatCommand([
+        "database",
+        "usage",
+        "<database>",
+        "--from",
+        "2026-06-01",
+        "--to",
+        "2026-06-30",
+      ]),
+    ],
     "database",
   );
 }
@@ -616,7 +666,10 @@ function isValidCalendarDate(datePart: string): boolean {
   );
 }
 
-function parseBackupLimit(value: string | undefined): number | undefined {
+function parseBackupLimit(
+  value: string | undefined,
+  formatCommand: PrismaCliPackageCommandFormatter,
+): number | undefined {
   if (value === undefined) {
     return undefined;
   }
@@ -627,7 +680,16 @@ function parseBackupLimit(value: string | undefined): number | undefined {
       "Invalid backup limit",
       "--limit must be an integer between 1 and 100.",
       "Pass a --limit between 1 and 100.",
-      ["prisma-cli database backup list <database> --limit 50"],
+      [
+        formatCommand([
+          "database",
+          "backup",
+          "list",
+          "<database>",
+          "--limit",
+          "50",
+        ]),
+      ],
       "database",
     );
   }
@@ -668,7 +730,11 @@ async function requireDatabaseContext(
     }
 
     return {
-      provider: createManagementDatabaseProvider(client),
+      provider: createManagementDatabaseProvider(client, {
+        formatCommand: resolvePrismaCliPackageCommandFormatterSync(
+          context.runtime.cwd,
+        ),
+      }),
       target: targetResult.value,
     };
   }
@@ -703,7 +769,11 @@ async function requireDatabaseProviderOnly(
     if (!client) {
       throw authRequiredError();
     }
-    return createManagementDatabaseProvider(client);
+    return createManagementDatabaseProvider(client, {
+      formatCommand: resolvePrismaCliPackageCommandFormatterSync(
+        context.runtime.cwd,
+      ),
+    });
   }
 
   return createFixtureDatabaseProvider(context);
@@ -805,7 +875,11 @@ function createFixtureDatabaseProvider(
         throw databaseNotFoundError(options.targetDatabaseId);
       }
       if (restored.outcome === "backup-not-found") {
-        throw backupNotFoundError(options.backupId, options.sourceDatabaseId);
+        throw backupNotFoundError(
+          options.backupId,
+          options.sourceDatabaseId,
+          resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd),
+        );
       }
       return normalizeDatabase(restored.database, options.projectId);
     },
@@ -981,15 +1055,22 @@ function databaseAmbiguousError(
 function backupNotFoundError(
   backupId: string,
   sourceDatabaseId: string,
+  formatCommand: PrismaCliPackageCommandFormatter,
 ): CliError {
+  const listCommand = formatCommand([
+    "database",
+    "backup",
+    "list",
+    sourceDatabaseId,
+  ]);
   return new CliError({
     code: "DATABASE_BACKUP_NOT_FOUND",
     domain: "database",
     summary: "Database backup not found",
     why: `No backup matched "${backupId}" for database "${sourceDatabaseId}".`,
-    fix: "Pass a backup id from prisma-cli database backup list.",
+    fix: `Pass a backup id from ${listCommand}.`,
     exitCode: 1,
-    nextSteps: [`prisma-cli database backup list ${sourceDatabaseId}`],
+    nextSteps: [listCommand],
   });
 }
 

packages/cli/src/lib/database/provider.ts

@@ -1,11 +1,13 @@
 // biome-ignore-all lint/performance/noAwaitInLoops: Database pagination requests must run sequentially.
 import type { ManagementApiClient } from "@prisma/management-api-sdk";
 
+import { formatPrismaCliCommand } from "../../shell/cli-command";
 import { CliError } from "../../shell/errors";
 import type {
   DatabaseConnectionSummary,
   DatabaseSummary,
 } from "../../types/database";
+import type { PrismaCliPackageCommandFormatter } from "../agent/cli-command";
 
 export interface DatabaseCreateInput {
   projectId: string;
@@ -207,7 +209,11 @@ interface RawDatabaseRecord {
 
 export function createManagementDatabaseProvider(
   client: ManagementApiClient,
+  options?: { formatCommand?: PrismaCliPackageCommandFormatter },
 ): DatabaseProvider {
+  const formatCommand =
+    options?.formatCommand ?? ((args) => formatPrismaCliCommand(args));
+
   return {
     async listDatabases(options) {
       const databases: RawDatabaseRecord[] = [];
@@ -445,12 +451,16 @@ export function createManagementDatabaseProvider(
         },
       );
       if (result.response?.status === 409) {
-        throw restoreConflictError(options.targetDatabaseId, result.error);
+        throw restoreConflictError(
+          options.targetDatabaseId,
+          result.error,
+          formatCommand,
+        );
       }
       // Target and source databases are resolved before this call, so a 404
       // here identifies the backup.
       if (result.response?.status === 404) {
-        throw restoreBackupNotFoundError(options, result.error);
+        throw restoreBackupNotFoundError(options, result.error, formatCommand);
       }
       if (result.error || !result.data) {
         throw databaseApiError(
@@ -698,23 +708,31 @@ function backupsUnsupportedError(
 function restoreBackupNotFoundError(
   options: { backupId: string; sourceDatabaseId: string },
   error: RawApiErrorBody | undefined,
+  formatCommand: PrismaCliPackageCommandFormatter,
 ): CliError {
+  const listCommand = formatCommand([
+    "database",
+    "backup",
+    "list",
+    options.sourceDatabaseId,
+  ]);
   return new CliError({
     code: "DATABASE_BACKUP_NOT_FOUND",
     domain: "database",
     summary: "Database backup not found",
     why:
       error?.error?.message ??
       `No backup matched "${options.backupId}" for database "${options.sourceDatabaseId}".`,
-    fix: "Pass a backup id from prisma-cli database backup list.",
+    fix: `Pass a backup id from ${listCommand}.`,
     exitCode: 1,
-    nextSteps: [`prisma-cli database backup list ${options.sourceDatabaseId}`],
+    nextSteps: [listCommand],
   });
 }
 
 function restoreConflictError(
   targetDatabaseId: string,
   error: RawApiErrorBody | undefined,
+  formatCommand: PrismaCliPackageCommandFormatter,
 ): CliError {
   return new CliError({
     code: "DATABASE_RESTORE_CONFLICT",
@@ -725,7 +743,7 @@ function restoreConflictError(
       `Database "${targetDatabaseId}" is provisioning or already recovering.`,
     fix: "Wait for the database to become ready, then retry the restore.",
     exitCode: 1,
-    nextSteps: [`prisma-cli database show ${targetDatabaseId}`],
+    nextSteps: [formatCommand(["database", "show", targetDatabaseId])],
   });
 }
 

packages/cli/tests/database.test.ts

@@ -798,7 +798,7 @@ describe("database commands", () => {
           backupId: "bkp_101",
         },
       },
-      nextSteps: ["prisma-cli database show db_123"],
+      nextSteps: ["npx -y @prisma/cli@latest database show db_123"],
     });
   });
 
@@ -868,7 +868,7 @@ describe("database commands", () => {
     expect(result.exitCode).toBe(2);
     expect(payload.error.code).toBe("CONFIRMATION_REQUIRED");
     expect(payload.nextSteps).toEqual([
-      "prisma-cli database restore db_123 --backup bkp_201 --source-database db_456 --confirm db_123",
+      "npx -y @prisma/cli@latest database restore db_123 --backup bkp_201 --source-database db_456 --confirm db_123",
     ]);
   });