@getjack/jack 0.1.14 → 0.1.16

package/src/lib/control-plane.ts

@@ -300,10 +300,18 @@ export interface ProjectResource {
 	resource_type: string;
 	resource_name: string;
 	provider_id: string;
+	binding_name: string;
 	status: string;
 	created_at: string;
 }
 
+export interface CreateResourceResponse {
+	resource_type: string;
+	resource_name: string;
+	provider_id: string;
+	binding_name: string;
+}
+
 /**
  * Fetch all resources for a managed project.
  * Uses GET /v1/projects/:id/resources endpoint.
@@ -324,6 +332,45 @@ export async function fetchProjectResources(projectId: string): Promise<ProjectR
 	return data.resources;
 }
 
+/**
+ * Create a resource for a managed project.
+ * Uses POST /v1/projects/:id/resources/:type endpoint.
+ */
+export async function createProjectResource(
+	projectId: string,
+	resourceType: "d1" | "kv" | "r2",
+	options?: { name?: string; bindingName?: string },
+): Promise<CreateResourceResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const body: Record<string, string> = {};
+	if (options?.name) {
+		body.name = options.name;
+	}
+	if (options?.bindingName) {
+		body.binding_name = options.bindingName;
+	}
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/${projectId}/resources/${resourceType}`,
+		{
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body),
+		},
+	);
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to create ${resourceType} resource: ${response.status}`);
+	}
+
+	const data = (await response.json()) as { resource: CreateResourceResponse };
+	return data.resource;
+}
+
 /**
  * Sync project tags to the control plane.
  * Fire-and-forget: errors are logged but not thrown.

package/src/lib/hooks.ts

@@ -83,50 +83,30 @@ const noopOutput: HookOutput = {
  */
 
 /**
- * Prompt user with numbered options (Claude Code style)
+ * Prompt user with numbered options
+ * Uses @clack/prompts selectKey for reliable input handling
  * Returns the selected option index (0-based) or -1 if cancelled
  */
 export async function promptSelect(options: string[]): Promise<number> {
-	// Display options
-	for (let i = 0; i < options.length; i++) {
-		console.error(`  ${i + 1}. ${options[i]}`);
-	}
-	console.error("");
-	console.error("  Esc to skip");
-
-	// Read single keypress
-	if (process.stdin.isTTY) {
-		process.stdin.setRawMode(true);
-	}
-	process.stdin.resume();
-
-	return new Promise((resolve) => {
-		const onData = (key: Buffer) => {
-			const char = key.toString();
+	const { selectKey, isCancel } = await import("@clack/prompts");
 
-			// Esc or q to cancel
-			if (char === "\x1b" || char === "q") {
-				cleanup();
-				resolve(-1);
-				return;
-			}
+	// Build options with number keys (1, 2, 3, ...)
+	const clackOptions = options.map((label, index) => ({
+		value: String(index + 1),
+		label,
+	}));
 
-			// Number keys
-			const num = Number.parseInt(char, 10);
-			if (num >= 1 && num <= options.length) {
-				cleanup();
-				resolve(num - 1);
-				return;
-			}
-		};
+	const result = await selectKey({
+		message: "",
+		options: clackOptions,
+	});
 
-		const cleanup = () => {
-			process.stdin.removeListener("data", onData);
-			restoreTty();
-		};
+	if (isCancel(result)) {
+		return -1;
+	}
 
-		process.stdin.on("data", onData);
-	});
+	// Convert "1", "2", etc. back to 0-based index
+	return Number.parseInt(result as string, 10) - 1;
 }
 
 /**
@@ -446,15 +426,12 @@ const actionHandlers: {
 		if (action.validate === "json" || action.validate === "accountAssociation") {
 			rawValue = await readMultilineJson(action.message);
 		} else {
-			const { input } = await import("@inquirer/prompts");
-			try {
-				rawValue = await input({ message: action.message });
-			} catch (err) {
-				if (err instanceof Error && err.name === "ExitPromptError") {
-					return true;
-				}
-				throw err;
+			const { isCancel, text } = await import("@clack/prompts");
+			const result = await text({ message: action.message });
+			if (isCancel(result)) {
+				return true;
 			}
+			rawValue = result;
 		}
 
 		if (!rawValue.trim()) {

package/src/lib/project-operations.ts

@@ -477,14 +477,23 @@ async function runAutoDetectFlow(
 	}
 
 	// Interactive mode - prompt for project name
-	const { input } = await import("@inquirer/prompts");
+	const { isCancel, text } = await import("@clack/prompts");
 
 	console.error("");
-	const projectName = await input({
+	const projectNameInput = await text({
 		message: "Project name:",
-		default: defaultName,
+		defaultValue: defaultName,
 	});
 
+	if (isCancel(projectNameInput)) {
+		throw new JackError(JackErrorCode.VALIDATION_ERROR, "Deployment cancelled", undefined, {
+			exitCode: 0,
+			reported: true,
+		});
+	}
+
+	const projectName = projectNameInput;
+
 	const slugifiedName = slugify(projectName.trim());
 	const runjackUrl = ownerUsername
 		? `https://${ownerUsername}-${slugifiedName}.runjack.xyz`
@@ -852,29 +861,28 @@ export async function createProject(
 
 			// Prompt user
 			reporter.stop();
-			const { input, select } = await import("@inquirer/prompts");
+			const { isCancel, select, text } = await import("@clack/prompts");
 			console.error("");
 			console.error(`  ${optionalSecret.description}`);
 			if (optionalSecret.setupUrl) {
 				console.error(`  Setup: ${optionalSecret.setupUrl}`);
 			}
 			console.error("");
-			console.error("  Esc to skip\n");
 
 			const choice = await select({
 				message: `Add ${optionalSecret.name}?`,
-				choices: [
-					{ name: "1. Yes", value: "yes" },
-					{ name: "2. Skip", value: "skip" },
+				options: [
+					{ label: "Yes", value: "yes" },
+					{ label: "Skip", value: "skip" },
 				],
 			});
 
-			if (choice === "yes") {
-				const value = await input({
+			if (!isCancel(choice) && choice === "yes") {
+				const value = await text({
 					message: `Enter ${optionalSecret.name}:`,
 				});
 
-				if (value.trim()) {
+				if (!isCancel(value) && value.trim()) {
 					secretsToUse[optionalSecret.name] = value.trim();
 					// Save to global secrets for reuse
 					await saveSecrets([

package/src/lib/prompts.ts

@@ -1,4 +1,4 @@
-import { input, select } from "@inquirer/prompts";
+import { isCancel, select, text } from "@clack/prompts";
 import type { DetectedSecret } from "./env-parser.ts";
 import { info, success, warn } from "./output.ts";
 import { getSavedSecrets, getSecretsPath, maskSecret, saveSecrets } from "./secrets.ts";
@@ -25,14 +25,14 @@ export async function promptSaveSecrets(detected: DetectedSecret[]): Promise<voi
 
 	const action = await select({
 		message: "What would you like to do?",
-		choices: [
-			{ value: "save", name: "Save to jack for future projects" },
-			{ value: "paste", name: "Paste additional secrets" },
-			{ value: "skip", name: "Skip for now" },
+		options: [
+			{ value: "save", label: "Save to jack for future projects" },
+			{ value: "paste", label: "Paste additional secrets" },
+			{ value: "skip", label: "Skip for now" },
 		],
 	});
 
-	if (action === "skip") {
+	if (isCancel(action) || action === "skip") {
 		return;
 	}
 
@@ -65,18 +65,22 @@ async function promptAdditionalSecrets(): Promise<
 	const secrets: Array<{ key: string; value: string; source: string }> = [];
 
 	while (true) {
-		const key = await input({
+		const key = await text({
 			message: "Enter secret name (or press enter to finish):",
 		});
 
-		if (!key.trim()) {
+		if (isCancel(key) || !key.trim()) {
 			break;
 		}
 
-		const value = await input({
+		const value = await text({
 			message: `Enter value for ${key}:`,
 		});
 
+		if (isCancel(value)) {
+			break;
+		}
+
 		if (value.trim()) {
 			secrets.push({ key: key.trim(), value: value.trim(), source: "manual" });
 		}
@@ -107,20 +111,19 @@ export async function promptUseSecrets(): Promise<Record<string, string> | null>
 	}
 	console.error("");
 
-	console.error("  Esc to skip\n");
 	const action = await select({
 		message: "Use them for this project?",
-		choices: [
-			{ name: "1. Yes", value: "yes" },
-			{ name: "2. No", value: "no" },
+		options: [
+			{ label: "Yes", value: "yes" },
+			{ label: "No", value: "no" },
 		],
 	});
 
-	if (action === "yes") {
-		return saved;
+	if (isCancel(action) || action !== "yes") {
+		return null;
 	}
 
-	return null;
+	return saved;
 }
 
 /**
@@ -151,14 +154,13 @@ export async function promptUseSecretsFromList(
 		return false;
 	}
 
-	console.error("  Esc to skip\n");
 	const action = await select({
 		message: "Use saved secrets for this project?",
-		choices: [
-			{ name: "1. Yes", value: "yes" },
-			{ name: "2. No", value: "no" },
+		options: [
+			{ label: "Yes", value: "yes" },
+			{ label: "No", value: "no" },
 		],
 	});
 
-	return action === "yes";
+	return !isCancel(action) && action === "yes";
 }

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

@@ -0,0 +1,187 @@
+/**
+ * Database creation logic for jack services db create
+ *
+ * Handles both managed (control plane) and BYO (wrangler d1 create) modes.
+ */
+
+import { join } from "node:path";
+import { $ } from "bun";
+import { createProjectResource } from "../control-plane.ts";
+import { readProjectLink } from "../project-link.ts";
+import { getProjectNameFromDir } from "../storage/index.ts";
+import { addD1Binding, getExistingD1Bindings } from "../wrangler-config.ts";
+
+export interface CreateDatabaseOptions {
+	name?: string;
+	interactive?: boolean; // Whether to prompt for deploy
+}
+
+export interface CreateDatabaseResult {
+	databaseName: string;
+	databaseId: string;
+	bindingName: string;
+	created: boolean; // false if reused existing
+}
+
+/**
+ * Convert a database name to SCREAMING_SNAKE_CASE for the binding name.
+ * Special case: first database in a project gets "DB" as the binding.
+ */
+function toBindingName(dbName: string, isFirst: boolean): string {
+	if (isFirst) {
+		return "DB";
+	}
+	// Convert kebab-case/snake_case to SCREAMING_SNAKE_CASE
+	return dbName
+		.replace(/-/g, "_")
+		.replace(/[^a-zA-Z0-9_]/g, "")
+		.toUpperCase();
+}
+
+/**
+ * Generate a unique database name for a project.
+ * First DB: {project}-db
+ * Subsequent DBs: {project}-db-{n}
+ */
+function generateDatabaseName(projectName: string, existingCount: number): string {
+	if (existingCount === 0) {
+		return `${projectName}-db`;
+	}
+	return `${projectName}-db-${existingCount + 1}`;
+}
+
+interface ExistingDatabase {
+	uuid: string;
+	name: string;
+}
+
+/**
+ * List all D1 databases in the Cloudflare account via wrangler
+ */
+async function listDatabasesViaWrangler(): Promise<ExistingDatabase[]> {
+	const result = await $`wrangler d1 list --json`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		// If wrangler fails, return empty list (might not be logged in)
+		return [];
+	}
+
+	try {
+		const output = result.stdout.toString().trim();
+		const data = JSON.parse(output);
+		// wrangler d1 list --json returns array: [{ "uuid": "...", "name": "...", ... }]
+		return Array.isArray(data) ? data : [];
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Find an existing D1 database by name
+ */
+async function findExistingDatabase(dbName: string): Promise<ExistingDatabase | null> {
+	const databases = await listDatabasesViaWrangler();
+	return databases.find((db) => db.name === dbName) ?? null;
+}
+
+/**
+ * Create a D1 database via wrangler (for BYO mode)
+ */
+async function createDatabaseViaWrangler(
+	dbName: string,
+): Promise<{ id: string; created: boolean }> {
+	// Check if database already exists
+	const existing = await findExistingDatabase(dbName);
+	if (existing) {
+		return { id: existing.uuid, created: false };
+	}
+
+	const result = await $`wrangler d1 create ${dbName} --json`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		const stderr = result.stderr.toString().trim();
+		throw new Error(stderr || `Failed to create database ${dbName}`);
+	}
+
+	try {
+		const output = result.stdout.toString().trim();
+		const data = JSON.parse(output);
+		// wrangler d1 create --json returns: { "uuid": "...", "name": "..." }
+		return { id: data.uuid || "", created: true };
+	} catch {
+		throw new Error("Failed to parse wrangler d1 create output");
+	}
+}
+
+/**
+ * Create a D1 database for the current project.
+ *
+ * For managed projects: calls control plane POST /v1/projects/:id/resources/d1
+ * For BYO projects: uses wrangler d1 create
+ *
+ * In both cases, updates wrangler.jsonc with the new binding.
+ */
+export async function createDatabase(
+	projectDir: string,
+	options: CreateDatabaseOptions = {},
+): Promise<CreateDatabaseResult> {
+	// Read project link to determine deploy mode
+	const link = await readProjectLink(projectDir);
+	if (!link) {
+		throw new Error("Not in a jack project. Run 'jack new' to create a project.");
+	}
+
+	// Get project name from wrangler config
+	const projectName = await getProjectNameFromDir(projectDir);
+
+	// Get existing D1 bindings to determine naming
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const existingBindings = await getExistingD1Bindings(wranglerPath);
+	const existingCount = existingBindings.length;
+
+	// Determine database name
+	const databaseName = options.name ?? generateDatabaseName(projectName, existingCount);
+
+	// Determine binding name
+	const isFirst = existingCount === 0;
+	const bindingName = toBindingName(databaseName, isFirst);
+
+	// Check if binding name already exists
+	const bindingExists = existingBindings.some((b) => b.binding === bindingName);
+	if (bindingExists) {
+		throw new Error(`Binding "${bindingName}" already exists. Choose a different database name.`);
+	}
+
+	let databaseId: string;
+	let created = true;
+
+	if (link.deploy_mode === "managed") {
+		// Managed mode: call control plane
+		// Note: Control plane will reuse existing DB if name matches
+		const resource = await createProjectResource(link.project_id, "d1", {
+			name: databaseName,
+			bindingName,
+		});
+		databaseId = resource.provider_id;
+		// Control plane always creates for now; could add reuse logic there too
+	} else {
+		// BYO mode: use wrangler d1 create (checks for existing first)
+		const result = await createDatabaseViaWrangler(databaseName);
+		databaseId = result.id;
+		created = result.created;
+	}
+
+	// Update wrangler.jsonc with the new binding
+	await addD1Binding(wranglerPath, {
+		binding: bindingName,
+		database_name: databaseName,
+		database_id: databaseId,
+	});
+
+	return {
+		databaseName,
+		databaseId,
+		bindingName,
+		created,
+	};
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Database listing logic for jack services db list
+ *
+ * Lists D1 databases configured in wrangler.jsonc with their metadata.
+ */
+
+import { join } from "node:path";
+import { getExistingD1Bindings } from "../wrangler-config.ts";
+import { getDatabaseInfo } from "./db.ts";
+
+export interface DatabaseListEntry {
+	name: string;
+	binding: string;
+	id: string;
+	sizeBytes?: number;
+	numTables?: number;
+}
+
+/**
+ * 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.
+ */
+export async function listDatabases(projectDir: string): Promise<DatabaseListEntry[]> {
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+
+	// Get existing D1 bindings from wrangler.jsonc
+	const bindings = await getExistingD1Bindings(wranglerPath);
+
+	if (bindings.length === 0) {
+		return [];
+	}
+
+	// Fetch detailed info for each database
+	const entries: DatabaseListEntry[] = [];
+
+	for (const binding of bindings) {
+		const entry: DatabaseListEntry = {
+			name: binding.database_name,
+			binding: binding.binding,
+			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;
+		}
+
+		entries.push(entry);
+	}
+
+	return entries;
+}