@getjack/jack 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.23",
+	"version": "0.1.25",
 	"description": "Ship before you forget why you started. The vibecoder's deployment CLI.",
 	"license": "Apache-2.0",
 	"type": "module",

package/src/commands/services.ts

@@ -49,31 +49,29 @@ async function ensureLocalProjectContext(projectName: string): Promise<void> {
 
 /**
  * Get database info for a project.
- * For managed: fetch from control plane
+ * For managed: fetch from control plane (throws on error - no silent fallback)
  * For BYO: parse from wrangler.jsonc
  */
 async function resolveDatabaseInfo(projectName: string): Promise<ResolvedDatabaseInfo | null> {
 	// Read deploy mode from .jack/project.json
 	const link = await readProjectLink(process.cwd());
 
-	// For managed projects, fetch from control plane
+	// For managed projects, fetch from control plane (don't fall back to wrangler)
 	if (link?.deploy_mode === "managed") {
-		try {
-			const resources = await fetchProjectResources(link.project_id);
-			const d1 = resources.find((r) => r.resource_type === "d1");
-			if (d1) {
-				return {
-					name: d1.resource_name,
-					id: d1.provider_id,
-					source: "control-plane",
-				};
-			}
-		} catch {
-			// Fall through to wrangler parsing
+		const resources = await fetchProjectResources(link.project_id);
+		const d1 = resources.find((r) => r.resource_type === "d1");
+		if (d1) {
+			return {
+				name: d1.resource_name,
+				id: d1.provider_id,
+				source: "control-plane",
+			};
 		}
+		// No database in control plane for managed project
+		return null;
 	}
 
-	// For BYO or fallback, parse from wrangler config
+	// For BYO, parse from wrangler config
 	try {
 		await ensureLocalProjectContext(projectName);
 		const resources = await parseWranglerResources(process.cwd());
@@ -85,7 +83,7 @@ async function resolveDatabaseInfo(projectName: string): Promise<ResolvedDatabas
 			};
 		}
 	} catch {
-		// No database found
+		// No database found in wrangler config
 	}
 
 	return null;
@@ -198,6 +196,41 @@ async function resolveProjectName(options: ServiceOptions): Promise<string> {
  */
 async function dbInfo(options: ServiceOptions): Promise<void> {
 	const projectName = await resolveProjectName(options);
+	const projectDir = process.cwd();
+	const link = await readProjectLink(projectDir);
+
+	// For managed projects, use control plane API (no wrangler dependency)
+	if (link?.deploy_mode === "managed") {
+		outputSpinner.start("Fetching database info...");
+		try {
+			const { getManagedDatabaseInfo } = await import("../lib/control-plane.ts");
+			const dbInfo = await getManagedDatabaseInfo(link.project_id);
+			outputSpinner.stop();
+
+			console.error("");
+			success(`Database: ${dbInfo.name}`);
+			console.error("");
+			item(`Size: ${formatSize(dbInfo.sizeBytes)}`);
+			item(`Tables: ${dbInfo.numTables}`);
+			item(`ID: ${dbInfo.id}`);
+			item("Source: managed (jack cloud)");
+			console.error("");
+			return;
+		} catch (err) {
+			outputSpinner.stop();
+			console.error("");
+			if (err instanceof Error && err.message.includes("No database found")) {
+				error("No database found for this project");
+				info("Create one with: jack services db create");
+			} else {
+				error(`Failed to fetch database info: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			console.error("");
+			process.exit(1);
+		}
+	}
+
+	// BYO mode: use wrangler
 	const dbInfo = await resolveDatabaseInfo(projectName);
 
 	if (!dbInfo) {
@@ -228,9 +261,6 @@ async function dbInfo(options: ServiceOptions): Promise<void> {
 	item(`Size: ${formatSize(wranglerDbInfo.sizeBytes)}`);
 	item(`Tables: ${wranglerDbInfo.numTables}`);
 	item(`ID: ${dbInfo.id || wranglerDbInfo.id}`);
-	if (dbInfo.source === "control-plane") {
-		item("Source: managed (jack cloud)");
-	}
 	console.error("");
 }
 
@@ -238,6 +268,54 @@ async function dbInfo(options: ServiceOptions): Promise<void> {
  * Export database to SQL file
  */
 async function dbExport(options: ServiceOptions): Promise<void> {
+	const projectDir = process.cwd();
+	const link = await readProjectLink(projectDir);
+
+	// For managed projects, use control plane export API
+	if (link?.deploy_mode === "managed") {
+		outputSpinner.start("Exporting database...");
+		try {
+			const { exportManagedDatabase, getManagedDatabaseInfo } = await import(
+				"../lib/control-plane.ts"
+			);
+
+			// Get db name for filename
+			const dbInfo = await getManagedDatabaseInfo(link.project_id);
+			const filename = generateExportFilename(dbInfo.name);
+			const outputPath = join(projectDir, filename);
+
+			// Get export URL from control plane
+			const exportResult = await exportManagedDatabase(link.project_id);
+
+			// Download the export
+			const response = await fetch(exportResult.download_url);
+			if (!response.ok) {
+				throw new Error(`Failed to download export: ${response.status}`);
+			}
+
+			const content = await response.text();
+			await Bun.write(outputPath, content);
+
+			outputSpinner.stop();
+			console.error("");
+			success(`Exported to ./${filename}`);
+			console.error("");
+		} catch (err) {
+			outputSpinner.stop();
+			console.error("");
+			if (err instanceof Error && err.message.includes("No database found")) {
+				error("No database found for this project");
+				info("Create one with: jack services db create");
+			} else {
+				error(`Failed to export: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			console.error("");
+			process.exit(1);
+		}
+		return;
+	}
+
+	// BYO mode: use wrangler
 	const projectName = await resolveProjectName(options);
 	const dbInfo = await resolveDatabaseInfo(projectName);
 
@@ -253,9 +331,9 @@ async function dbExport(options: ServiceOptions): Promise<void> {
 	const filename = generateExportFilename(dbInfo.name);
 
 	// Export to current directory
-	const outputPath = join(process.cwd(), filename);
+	const outputPath = join(projectDir, filename);
 
-	// Export
+	// Export via wrangler
 	outputSpinner.start("Exporting database...");
 	try {
 		await exportDatabase(dbInfo.name, outputPath);
@@ -283,27 +361,69 @@ async function dbDelete(options: ServiceOptions): Promise<void> {
 	const link = await readProjectLink(projectDir);
 	const isManaged = link?.deploy_mode === "managed";
 
-	const dbInfo = await resolveDatabaseInfo(projectName);
-
-	if (!dbInfo) {
-		console.error("");
-		error("No database found for this project");
-		info("Create one with: jack services db create");
-		console.error("");
-		return;
-	}
+	// For managed projects, get database info from control plane
+	let dbInfo: ResolvedDatabaseInfo | null = null;
+	let displaySizeBytes: number | undefined;
+	let displayNumTables: number | undefined;
 
-	// Get detailed database info to show what will be deleted
 	outputSpinner.start("Fetching database info...");
-	const wranglerDbInfo = await getWranglerDatabaseInfo(dbInfo.name);
-	outputSpinner.stop();
+
+	if (isManaged && link) {
+		try {
+			const { getManagedDatabaseInfo } = await import("../lib/control-plane.ts");
+			const managedDbInfo = await getManagedDatabaseInfo(link.project_id);
+			outputSpinner.stop();
+
+			dbInfo = {
+				name: managedDbInfo.name,
+				id: managedDbInfo.id,
+				source: "control-plane",
+			};
+			displaySizeBytes = managedDbInfo.sizeBytes;
+			displayNumTables = managedDbInfo.numTables;
+		} catch (err) {
+			outputSpinner.stop();
+			if (err instanceof Error && err.message.includes("No database found")) {
+				console.error("");
+				error("No database found for this project");
+				info("Create one with: jack services db create");
+				console.error("");
+				return;
+			}
+			throw err;
+		}
+	} else {
+		// BYO mode
+		dbInfo = await resolveDatabaseInfo(projectName);
+		outputSpinner.stop();
+
+		if (!dbInfo) {
+			console.error("");
+			error("No database found for this project");
+			info("Create one with: jack services db create");
+			console.error("");
+			return;
+		}
+
+		// Get detailed info via wrangler for BYO mode
+		outputSpinner.start("Fetching database details...");
+		const wranglerDbInfo = await getWranglerDatabaseInfo(dbInfo.name);
+		outputSpinner.stop();
+
+		if (wranglerDbInfo) {
+			displaySizeBytes = wranglerDbInfo.sizeBytes;
+			displayNumTables = wranglerDbInfo.numTables;
+		}
+	}
 
 	// Show what will be deleted
 	console.error("");
 	info(`Database: ${dbInfo.name}`);
-	if (wranglerDbInfo) {
-		item(`Size: ${formatSize(wranglerDbInfo.sizeBytes)}`);
-		item(`Tables: ${wranglerDbInfo.numTables}`);
+	if (displaySizeBytes !== undefined) {
+		item(`Size: ${formatSize(displaySizeBytes)}`);
+	}
+	if (displayNumTables !== undefined) {
+		item(`Tables: ${displayNumTables}`);
 	}
 	console.error("");
 	warn("This will permanently delete the database and all its data");

package/src/lib/control-plane.ts

@@ -179,12 +179,34 @@ export async function checkSlugAvailability(slug: string): Promise<SlugAvailabil
 	return response.json() as Promise<SlugAvailabilityResponse>;
 }
 
+export interface DatabaseInfoResponse {
+	name: string;
+	id: string;
+	sizeBytes: number;
+	numTables: number;
+	version?: string;
+	createdAt?: string;
+}
+
 export interface DatabaseExportResponse {
 	success: boolean;
 	download_url: string;
 	expires_in: number;
 }
 
+export interface ExecuteSqlResponse {
+	success: boolean;
+	results: unknown[];
+	meta: {
+		changes: number;
+		duration_ms: number;
+		last_row_id: number;
+		rows_read: number;
+		rows_written: number;
+	};
+	error?: string;
+}
+
 export interface DeleteProjectResponse {
 	success: boolean;
 	project_id: string;
@@ -205,6 +227,31 @@ export interface ManagedProject {
 	owner_username?: string | null;
 }
 
+/**
+ * Get managed project's D1 database info (size, tables, etc.)
+ * This avoids calling wrangler and uses the control plane API.
+ */
+export async function getManagedDatabaseInfo(projectId: string): Promise<DatabaseInfoResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/${projectId}/database/info`,
+	);
+
+	if (response.status === 404) {
+		throw new Error("No database found for this project");
+	}
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to get database info: ${response.status}`);
+	}
+
+	return response.json() as Promise<DatabaseInfoResponse>;
+}
+
 /**
  * Export a managed project's D1 database.
  */
@@ -229,6 +276,45 @@ export async function exportManagedDatabase(projectId: string): Promise<Database
 	return response.json() as Promise<DatabaseExportResponse>;
 }
 
+/**
+ * Execute SQL against a managed project's D1 database.
+ * Routes through control plane for Jack Cloud auth.
+ */
+export async function executeManagedSql(
+	projectId: string,
+	sql: string,
+	params?: unknown[],
+): Promise<ExecuteSqlResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const body: { sql: string; params?: unknown[] } = { sql };
+	if (params && params.length > 0) {
+		body.params = params;
+	}
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/${projectId}/database/execute`,
+		{
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body),
+		},
+	);
+
+	if (response.status === 504) {
+		throw new Error("SQL execution timed out. The query may be too complex.");
+	}
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to execute SQL: ${response.status}`);
+	}
+
+	return response.json() as Promise<ExecuteSqlResponse>;
+}
+
 /**
  * Delete a managed project and all its resources.
  */

package/src/lib/services/db-execute.ts

@@ -11,6 +11,9 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { $ } from "bun";
+import { type ExecuteSqlResponse, executeManagedSql } from "../control-plane.ts";
+import { readProjectLink } from "../project-link.ts";
+import { type D1BindingConfig, getExistingD1Bindings } from "../wrangler-config.ts";
 import {
 	type ClassifiedStatement,
 	type RiskLevel,
@@ -19,7 +22,6 @@ import {
 	getRiskDescription,
 	splitStatements,
 } from "./sql-classifier.ts";
-import { getExistingD1Bindings, type D1BindingConfig } from "../wrangler-config.ts";
 
 export interface ExecuteSqlOptions {
 	/** Path to project directory */
@@ -367,6 +369,55 @@ export async function executeSql(options: ExecuteSqlOptions): Promise<ExecuteSql
 		}
 	}
 
+	// Check for managed mode - route through control plane
+	const link = await readProjectLink(projectDir);
+	if (link?.deploy_mode === "managed") {
+		try {
+			const managedResult = await executeManagedSql(link.project_id, sql);
+
+			if (!managedResult.success) {
+				return {
+					success: false,
+					risk: highestRisk,
+					statements,
+					error: managedResult.error || "Failed to execute SQL",
+				};
+			}
+
+			// Build result matching wrangler format
+			const result: ExecuteSqlResult = {
+				success: true,
+				risk: highestRisk,
+				statements,
+				results: managedResult.results,
+				meta: {
+					changes: managedResult.meta.changes,
+					duration_ms: managedResult.meta.duration_ms,
+					last_row_id: managedResult.meta.last_row_id,
+				},
+			};
+
+			// Add warning for destructive ops
+			if (highestRisk === "destructive") {
+				const ops = statements
+					.filter((s) => s.risk === "destructive")
+					.map((s) => s.operation)
+					.join(", ");
+				result.warning = `Executed destructive operation(s): ${ops}`;
+			}
+
+			return result;
+		} catch (error) {
+			return {
+				success: false,
+				risk: highestRisk,
+				statements,
+				error: error instanceof Error ? error.message : "Failed to execute SQL via control plane",
+			};
+		}
+	}
+
+	// BYO mode: use wrangler
 	// Get database
 	const db = databaseName
 		? await getDatabaseByName(projectDir, databaseName)
@@ -475,6 +526,54 @@ export async function executeSqlFile(
 		}
 	}
 
+	// Check for managed mode - route through control plane
+	const link = await readProjectLink(projectDir);
+	if (link?.deploy_mode === "managed") {
+		try {
+			const managedResult = await executeManagedSql(link.project_id, sql);
+
+			if (!managedResult.success) {
+				return {
+					success: false,
+					risk: highestRisk,
+					statements,
+					error: managedResult.error || "Failed to execute SQL",
+				};
+			}
+
+			// Build result matching wrangler format
+			const result: ExecuteSqlResult = {
+				success: true,
+				risk: highestRisk,
+				statements,
+				results: managedResult.results,
+				meta: {
+					changes: managedResult.meta.changes,
+					duration_ms: managedResult.meta.duration_ms,
+					last_row_id: managedResult.meta.last_row_id,
+				},
+			};
+
+			// Add warning for destructive ops
+			if (highestRisk === "destructive") {
+				const ops = [
+					...new Set(statements.filter((s) => s.risk === "destructive").map((s) => s.operation)),
+				].join(", ");
+				result.warning = `Executed destructive operation(s): ${ops}`;
+			}
+
+			return result;
+		} catch (error) {
+			return {
+				success: false,
+				risk: highestRisk,
+				statements,
+				error: error instanceof Error ? error.message : "Failed to execute SQL via control plane",
+			};
+		}
+	}
+
+	// BYO mode: use wrangler
 	// Get database
 	const db = databaseName
 		? await getDatabaseByName(projectDir, databaseName)

package/src/lib/services/db-list.ts

@@ -2,9 +2,11 @@
  * Database listing logic for jack services db list
  *
  * Lists D1 databases configured in wrangler.jsonc with their metadata.
+ * For managed projects, fetches metadata via control plane instead of wrangler.
  */
 
 import { join } from "node:path";
+import { readProjectLink } from "../project-link.ts";
 import { getExistingD1Bindings } from "../wrangler-config.ts";
 import { getDatabaseInfo } from "./db.ts";
 
@@ -19,8 +21,8 @@ export interface DatabaseListEntry {
 /**
  * List all D1 databases configured for a project.
  *
- * Reads bindings from wrangler.jsonc and fetches additional metadata
- * (size, table count) via wrangler d1 info for each database.
+ * For managed projects: fetches metadata via control plane API.
+ * For BYO projects: reads bindings from wrangler.jsonc and fetches metadata via wrangler.
  */
 export async function listDatabases(projectDir: string): Promise<DatabaseListEntry[]> {
 	const wranglerPath = join(projectDir, "wrangler.jsonc");
@@ -32,6 +34,22 @@ export async function listDatabases(projectDir: string): Promise<DatabaseListEnt
 		return [];
 	}
 
+	// Check deploy mode for metadata fetching
+	const link = await readProjectLink(projectDir);
+	const isManaged = link?.deploy_mode === "managed";
+
+	// For managed projects, get metadata from control plane
+	let managedDbInfo: { name: string; id: string; sizeBytes: number; numTables: number } | null =
+		null;
+	if (isManaged && link) {
+		try {
+			const { getManagedDatabaseInfo } = await import("../control-plane.ts");
+			managedDbInfo = await getManagedDatabaseInfo(link.project_id);
+		} catch {
+			// Fall through - will show list without metadata
+		}
+	}
+
 	// Fetch detailed info for each database
 	const entries: DatabaseListEntry[] = [];
 
@@ -42,11 +60,20 @@ export async function listDatabases(projectDir: string): Promise<DatabaseListEnt
 			id: binding.database_id,
 		};
 
-		// Try to get additional metadata via wrangler
-		const info = await getDatabaseInfo(binding.database_name);
-		if (info) {
-			entry.sizeBytes = info.sizeBytes;
-			entry.numTables = info.numTables;
+		// Get metadata based on deploy mode
+		if (isManaged && managedDbInfo) {
+			// For managed: use control plane data (match by ID or name)
+			if (managedDbInfo.id === binding.database_id || managedDbInfo.name.includes(binding.database_name)) {
+				entry.sizeBytes = managedDbInfo.sizeBytes;
+				entry.numTables = managedDbInfo.numTables;
+			}
+		} else {
+			// For BYO: try to get metadata via wrangler
+			const info = await getDatabaseInfo(binding.database_name);
+			if (info) {
+				entry.sizeBytes = info.sizeBytes;
+				entry.numTables = info.numTables;
+			}
 		}
 
 		entries.push(entry);