@prisma/compute-cli 0.1.0

package/src/commands/deploy.ts

@@ -0,0 +1,127 @@
+import path from "node:path";
+import { BunBuild, ComputeClient, PreBuilt } from "@prisma/compute-sdk";
+import { defineCommand } from "citty";
+import { writeComputeConfig } from "../lib/compute-config.ts";
+import { createDeployInteraction } from "../lib/interaction.ts";
+import { printJsonResult } from "../lib/json-output.ts";
+import { createDeployProgress } from "../lib/progress.ts";
+import {
+  endFlow,
+  getConfigPath,
+  handleError,
+  parseEnvFromArgs,
+  parsePollOptions,
+  parsePortMapping,
+  readComputeConfig,
+  startFlow,
+  withAuthAndSignal,
+} from "./helpers.ts";
+
+export const deployCommand = defineCommand({
+  meta: { name: "deploy", description: "Build and deploy your application" },
+  args: {
+    project: { type: "string", description: "Project ID" },
+    service: { type: "string", description: "Compute service ID" },
+    path: { type: "string", default: ".", description: "App directory" },
+    entrypoint: { type: "string", description: "Relative app entrypoint" },
+    serviceName: {
+      type: "string",
+      description: "Name for a new compute service",
+    },
+    region: { type: "string", description: "Region for a new compute service" },
+    skipBuild: {
+      type: "boolean",
+      default: false,
+      description: "Skip build, deploy pre-built artifact",
+    },
+    env: {
+      type: "string",
+      description: "Environment variables (repeat --env KEY=VALUE)",
+    },
+    httpPort: {
+      type: "string",
+      description: "HTTP port your application listens on",
+    },
+    timeout: {
+      type: "string",
+      default: "120",
+      description: "Poll timeout in seconds",
+    },
+    pollInterval: {
+      type: "string",
+      default: "1000",
+      description: "Poll interval in milliseconds",
+    },
+    json: { type: "boolean", default: false, description: "Output JSON" },
+  },
+  run: async ({ args, rawArgs }) => {
+    const exitCode = await withAuthAndSignal(
+      async (managementClient, signal) => {
+        const flowStarted = !args.json && startFlow("Prisma Compute · Deploy");
+
+        try {
+          const sdk = new ComputeClient(managementClient);
+          const appPath = path.resolve(process.cwd(), args.path);
+          const envVars = parseEnvFromArgs(rawArgs);
+          const portMapping = parsePortMapping(args.httpPort);
+
+          const configPath = getConfigPath();
+          const currentConfig = await readComputeConfig(configPath);
+
+          const projectId = args.project ?? currentConfig?.projectId;
+          const serviceId = args.service ?? currentConfig?.serviceId;
+
+          let strategy: PreBuilt | BunBuild;
+          if (args.skipBuild) {
+            if (!args.entrypoint) {
+              throw new Error(
+                "When --skip-build is set you must provide --entrypoint",
+              );
+            }
+            strategy = new PreBuilt({ appPath, entrypoint: args.entrypoint });
+          } else {
+            strategy = new BunBuild({ appPath, entrypoint: args.entrypoint });
+          }
+
+          const result = await sdk.deploy({
+            strategy,
+            projectId,
+            serviceId,
+            serviceName: args.serviceName,
+            region: args.region,
+            envVars,
+            portMapping: portMapping ?? currentConfig?.portMapping,
+            ...parsePollOptions(args),
+            interaction: args.json ? undefined : createDeployInteraction(),
+            progress: args.json ? undefined : createDeployProgress(),
+            signal,
+          });
+
+          if (args.json) {
+            printJsonResult(result);
+            return result.isOk() ? 0 : 1;
+          }
+
+          if (result.isErr()) {
+            endFlow(flowStarted, "Deploy flow failed.");
+            console.error(result.error.message);
+            return 1;
+          }
+
+          await writeComputeConfig(configPath, result.value.resolvedConfig);
+
+          console.log(`Version: ${result.value.versionId}`);
+          console.log("");
+          console.log("Deployment URL:");
+          console.log(result.value.deploymentUrl);
+          endFlow(flowStarted, "Deploy flow completed.");
+          return 0;
+        } catch (error) {
+          return handleError(error);
+        }
+      },
+    );
+
+    if (exitCode !== 0) process.exit(exitCode);
+  },
+});

package/src/commands/env.ts

@@ -0,0 +1,104 @@
+import { ComputeClient } from "@prisma/compute-sdk";
+import { defineCommand } from "citty";
+import { writeComputeConfig } from "../lib/compute-config.ts";
+import { createDeployInteraction } from "../lib/interaction.ts";
+import { printJsonResult } from "../lib/json-output.ts";
+import { createUpdateEnvProgress } from "../lib/progress.ts";
+import {
+  endFlow,
+  getConfigPath,
+  handleError,
+  parseEnvFromArgs,
+  parsePollOptions,
+  parsePortMapping,
+  readComputeConfig,
+  startFlow,
+  withAuthAndSignal,
+} from "./helpers.ts";
+
+const envUpdateCommand = defineCommand({
+  meta: {
+    name: "update",
+    description: "Update environment variables (creates a new version)",
+  },
+  args: {
+    project: { type: "string", description: "Project ID" },
+    service: { type: "string", description: "Compute service ID" },
+    env: {
+      type: "string",
+      description: "Environment variables (repeat --env KEY=VALUE)",
+      required: true,
+    },
+    httpPort: {
+      type: "string",
+      description: "HTTP port your application listens on",
+    },
+    timeout: {
+      type: "string",
+      default: "120",
+      description: "Poll timeout in seconds",
+    },
+    pollInterval: {
+      type: "string",
+      default: "1000",
+      description: "Poll interval in milliseconds",
+    },
+    json: { type: "boolean", default: false, description: "Output JSON" },
+  },
+  run: async ({ args, rawArgs }) => {
+    const exitCode = await withAuthAndSignal(
+      async (managementClient, signal) => {
+        const flowStarted =
+          !args.json && startFlow("Prisma Compute · Env Update");
+
+        try {
+          const sdk = new ComputeClient(managementClient);
+          const envVars = parseEnvFromArgs(rawArgs);
+          const portMapping = parsePortMapping(args.httpPort);
+
+          const configPath = getConfigPath();
+          const currentConfig = await readComputeConfig(configPath);
+
+          const result = await sdk.updateEnv({
+            projectId: args.project ?? currentConfig?.projectId,
+            serviceId: args.service ?? currentConfig?.serviceId,
+            envVars,
+            portMapping: portMapping ?? currentConfig?.portMapping,
+            ...parsePollOptions(args),
+            interaction: args.json ? undefined : createDeployInteraction(),
+            progress: args.json ? undefined : createUpdateEnvProgress(),
+            signal,
+          });
+
+          if (args.json) {
+            printJsonResult(result);
+            return result.isOk() ? 0 : 1;
+          }
+
+          if (result.isErr()) {
+            console.error(result.error.message);
+            return 1;
+          }
+
+          await writeComputeConfig(configPath, result.value.resolvedConfig);
+
+          console.log(`Version: ${result.value.versionId}`);
+          console.log("");
+          console.log("Deployment URL:");
+          console.log(result.value.deploymentUrl);
+          endFlow(flowStarted, "Env update completed.");
+          return 0;
+        } catch (error) {
+          return handleError(error);
+        }
+      },
+    );
+
+    if (exitCode !== 0) process.exit(exitCode);
+  },
+});
+
+export const envGroup = defineCommand({
+  meta: { name: "env", description: "Environment variable management" },
+  subCommands: { update: envUpdateCommand },
+});

package/src/commands/helpers.ts

@@ -0,0 +1,153 @@
+import path from "node:path";
+import { intro, outro } from "@clack/prompts";
+import type { ManagementApiClient } from "@prisma/management-api-sdk";
+import { requireAuth } from "../lib/auth/guard.ts";
+import {
+  COMPUTE_CONFIG_FILENAME,
+  readComputeConfig,
+} from "../lib/compute-config.ts";
+import { isInteractiveSession, isPromptCancelled } from "../lib/interaction.ts";
+
+export function parseEnvAssignments(entries: string[]): Record<string, string> {
+  const envVars: Record<string, string> = {};
+  for (const value of entries) {
+    const delimiter = value.indexOf("=");
+    if (delimiter <= 0) {
+      throw new Error(`Invalid --env value \`${value}\`; expected KEY=VALUE`);
+    }
+    const key = value.slice(0, delimiter).trim();
+    const envValue = value.slice(delimiter + 1);
+    if (key.length === 0) {
+      throw new Error(`Invalid --env key in \`${value}\``);
+    }
+    envVars[key] = envValue;
+  }
+  return envVars;
+}
+
+function extractEnvBatches(rawArgs: string[]): string[] {
+  const batches: string[] = [];
+
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg === undefined) continue;
+    if (arg === "--") break;
+
+    if (arg === "--env") {
+      const value = rawArgs[i + 1];
+      if (value === undefined || value.startsWith("-")) {
+        batches.push("");
+      } else {
+        batches.push(value);
+        i++;
+      }
+      continue;
+    }
+
+    if (arg.startsWith("--env=")) {
+      batches.push(arg.slice("--env=".length));
+    }
+  }
+
+  return batches;
+}
+
+export function parseEnvFromArgs(rawArgs: string[]): Record<string, string> {
+  // Citty still collapses repeated string flags, so preserve each --env from raw args.
+  const batches = extractEnvBatches(rawArgs);
+  return parseEnvAssignments(batches);
+}
+
+export function parsePortMapping(
+  httpPort: string | undefined,
+): { http: number } | undefined {
+  if (!httpPort) return undefined;
+  const port = Number.parseInt(httpPort, 10);
+  if (Number.isNaN(port)) {
+    throw new Error(`Invalid --http-port value: ${httpPort}`);
+  }
+  return { http: port };
+}
+
+function parseIntOrThrow(value: string, flag: string): number {
+  const n = Number.parseInt(value, 10);
+  if (Number.isNaN(n)) {
+    throw new Error(`Invalid ${flag} value: ${value}`);
+  }
+  return n;
+}
+
+export function parsePollOptions(args: {
+  timeout: string;
+  pollInterval: string;
+}) {
+  return {
+    timeoutSeconds: parseIntOrThrow(args.timeout, "--timeout"),
+    pollIntervalMs: parseIntOrThrow(args.pollInterval, "--poll-interval"),
+  };
+}
+
+export function getConfigPath(): string {
+  return path.join(process.cwd(), COMPUTE_CONFIG_FILENAME);
+}
+
+export { readComputeConfig };
+
+export function createCommandAbortSignal(): {
+  signal: AbortSignal;
+  cleanup(): void;
+} {
+  const controller = new AbortController();
+  let cleanedUp = false;
+
+  function cleanup(): void {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    process.off("SIGINT", onAbort);
+    process.off("SIGTERM", onAbort);
+  }
+
+  function onAbort(): void {
+    cleanup();
+    controller.abort();
+  }
+
+  process.once("SIGINT", onAbort);
+  process.once("SIGTERM", onAbort);
+
+  return {
+    signal: controller.signal,
+    cleanup,
+  };
+}
+
+export async function withAuthAndSignal(
+  fn: (client: ManagementApiClient, signal: AbortSignal) => Promise<number>,
+): Promise<number> {
+  const client = await requireAuth();
+  if (!client) return 1;
+  const { signal, cleanup } = createCommandAbortSignal();
+  try {
+    return await fn(client, signal);
+  } finally {
+    cleanup();
+  }
+}
+
+export function handleError(error: unknown): number {
+  if (isPromptCancelled(error)) return 1;
+  console.error(error instanceof Error ? error.message : String(error));
+  return 1;
+}
+
+export function startFlow(title: string): boolean {
+  if (!isInteractiveSession()) return false;
+  intro(title);
+  return true;
+}
+
+export function endFlow(started: boolean, message = "Done."): void {
+  if (started) outro(message);
+}
+
+export { isInteractiveSession };

package/src/commands/login.ts

@@ -0,0 +1,18 @@
+import { defineCommand } from "citty";
+import { login as startLoginFlow } from "../lib/auth/login.ts";
+
+export const loginCommand = defineCommand({
+  meta: { name: "login", description: "Authenticate with Prisma" },
+  run: async () => {
+    try {
+      console.log("Opening browser for authentication...");
+      await startLoginFlow();
+      console.log("Successfully authenticated.");
+    } catch (error) {
+      console.error(
+        `Login failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      process.exit(1);
+    }
+  },
+});

package/src/commands/logout.ts

@@ -0,0 +1,18 @@
+import { defineCommand } from "citty";
+import { FileTokenStorage } from "../lib/auth/token-storage.ts";
+
+export const logoutCommand = defineCommand({
+  meta: { name: "logout", description: "Clear stored credentials" },
+  run: async () => {
+    try {
+      const tokenStorage = new FileTokenStorage();
+      await tokenStorage.clearTokens();
+      console.log("Logged out.");
+    } catch (error) {
+      console.error(
+        `Logout failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      process.exit(1);
+    }
+  },
+});

package/src/commands/projects.ts

@@ -0,0 +1,54 @@
+import { ComputeClient } from "@prisma/compute-sdk";
+import { defineCommand } from "citty";
+import { formatTable } from "../lib/format.ts";
+import { printJsonResult } from "../lib/json-output.ts";
+import { handleError, withAuthAndSignal } from "./helpers.ts";
+
+const projectsListCommand = defineCommand({
+  meta: { name: "list", description: "List projects in your workspace" },
+  args: {
+    json: { type: "boolean", default: false, description: "Output JSON" },
+  },
+  run: async ({ args }) => {
+    const exitCode = await withAuthAndSignal(
+      async (managementClient, signal) => {
+        try {
+          const sdk = new ComputeClient(managementClient);
+          const result = await sdk.listProjects({ signal });
+
+          if (args.json) {
+            printJsonResult(result);
+            return result.isOk() ? 0 : 1;
+          }
+
+          if (result.isErr()) {
+            console.error(result.error.message);
+            return 1;
+          }
+
+          if (result.value.length === 0) {
+            console.log("No projects found.");
+            return 0;
+          }
+
+          console.log(
+            formatTable(
+              ["ID", "Name"],
+              result.value.map((p) => [p.id, p.name]),
+            ),
+          );
+          return 0;
+        } catch (error) {
+          return handleError(error);
+        }
+      },
+    );
+
+    if (exitCode !== 0) process.exit(exitCode);
+  },
+});
+
+export const projectsGroup = defineCommand({
+  meta: { name: "projects", description: "Project management" },
+  subCommands: { list: projectsListCommand },
+});