@getjack/jack 0.1.17 → 0.1.20

package/src/lib/project-operations.ts

@@ -39,8 +39,7 @@ import {
 	slugify,
 	writeWranglerConfig,
 } from "./config-generator.ts";
-import { getSyncConfig } from "./config.ts";
-import { deleteManagedProject } from "./control-plane.ts";
+import { deleteManagedProject, listManagedProjects } from "./control-plane.ts";
 import { debug, isDebug, printTimingSummary, timerEnd, timerStart } from "./debug.ts";
 import { ensureWranglerInstalled, validateModeAvailability } from "./deploy-mode.ts";
 import { detectSecrets, generateEnvFile, generateSecretsJson } from "./env-parser.ts";
@@ -67,7 +66,7 @@ import {
 import { filterNewSecrets, promptSaveSecrets } from "./prompts.ts";
 import { applySchema, getD1Bindings, getD1DatabaseName, hasD1Config } from "./schema.ts";
 import { getSavedSecrets, saveSecrets } from "./secrets.ts";
-import { getProjectNameFromDir, getRemoteManifest, syncToCloud } from "./storage/index.ts";
+import { getProjectNameFromDir, getRemoteManifest } from "./storage/index.ts";
 import { Events, track } from "./telemetry.ts";
 
 // ============================================================================
@@ -364,7 +363,11 @@ async function runParallelSetup(
 	installSuccess: boolean;
 	remoteResult: ManagedCreateResult;
 }> {
+	const setupStart = Date.now();
+	debug("Parallel setup started", { template: options.template, usePrebuilt: options.usePrebuilt });
+
 	// Start both operations
+	const installStart = Date.now();
 	const installPromise = (async () => {
 		const install = Bun.spawn(["bun", "install", "--prefer-offline"], {
 			cwd: targetDir,
@@ -372,15 +375,22 @@ async function runParallelSetup(
 			stderr: "ignore",
 		});
 		await install.exited;
+		const duration = ((Date.now() - installStart) / 1000).toFixed(1);
+		debug(`bun install completed in ${duration}s (exit: ${install.exitCode})`);
 		if (install.exitCode !== 0) {
 			throw new Error("Dependency installation failed");
 		}
 		return true;
 	})();
 
+	const remoteStart = Date.now();
 	const remotePromise = createManagedProjectRemote(projectName, undefined, {
 		template: options.template || "hello",
 		usePrebuilt: options.usePrebuilt ?? true,
+	}).then((result) => {
+		const duration = ((Date.now() - remoteStart) / 1000).toFixed(1);
+		debug(`Remote project created in ${duration}s (status: ${result.status})`);
+		return result;
 	});
 
 	// Report URL as soon as remote is ready (don't wait for install)
@@ -435,6 +445,9 @@ async function runParallelSetup(
 		throw new Error("Unexpected state: remote result not fulfilled");
 	}
 
+	const totalDuration = ((Date.now() - setupStart) / 1000).toFixed(1);
+	debug(`Parallel setup completed in ${totalDuration}s`);
+
 	return {
 		installSuccess: true,
 		remoteResult: remoteResult.value,
@@ -973,6 +986,25 @@ export async function createProject(
 	const rendered = renderTemplate(template, { name: projectName });
 	timings.push({ label: "Template load", duration: timerEnd("template-load") });
 
+	// Run preCreate hooks (for interactive secret collection, auto-generation, etc.)
+	if (template.hooks?.preCreate?.length) {
+		timerStart("pre-create-hooks");
+		const hookContext = { projectName, projectDir: targetDir };
+		const hookResult = await runHook(template.hooks.preCreate, hookContext, {
+			interactive,
+			output: reporter,
+		});
+		timings.push({ label: "Pre-create hooks", duration: timerEnd("pre-create-hooks") });
+
+		if (!hookResult.success) {
+			throw new JackError(
+				JackErrorCode.VALIDATION_ERROR,
+				"Project setup incomplete",
+				"Missing required configuration",
+			);
+		}
+	}
+
 	// Handle template-specific secrets
 	const secretsToUse: Record<string, string> = {};
 	if (template.secrets?.length) {
@@ -1018,41 +1050,34 @@ export async function createProject(
 				continue;
 			}
 
-			// Prompt user
+			// Prompt user - single text input, empty/Esc to skip
 			reporter.stop();
-			const { isCancel, select, text } = await import("@clack/prompts");
+			const { isCancel, text } = await import("@clack/prompts");
 			console.error("");
 			console.error(`  ${optionalSecret.description}`);
 			if (optionalSecret.setupUrl) {
-				console.error(`  Setup: ${optionalSecret.setupUrl}`);
+				console.error(`  Get it at: \x1b[36m${optionalSecret.setupUrl}\x1b[0m`);
 			}
 			console.error("");
 
-			const choice = await select({
-				message: `Add ${optionalSecret.name}?`,
-				options: [
-					{ label: "Yes", value: "yes" },
-					{ label: "Skip", value: "skip" },
-				],
+			const value = await text({
+				message: `${optionalSecret.name}:`,
+				placeholder: "paste value or press Esc to skip",
 			});
 
-			if (!isCancel(choice) && choice === "yes") {
-				const value = await text({
-					message: `Enter ${optionalSecret.name}:`,
-				});
-
-				if (!isCancel(value) && value.trim()) {
-					secretsToUse[optionalSecret.name] = value.trim();
-					// Save to global secrets for reuse
-					await saveSecrets([
-						{
-							key: optionalSecret.name,
-							value: value.trim(),
-							source: "optional-template",
-						},
-					]);
-					reporter.success(`Saved ${optionalSecret.name}`);
-				}
+			if (!isCancel(value) && value.trim()) {
+				secretsToUse[optionalSecret.name] = value.trim();
+				// Save to global secrets for reuse
+				await saveSecrets([
+					{
+						key: optionalSecret.name,
+						value: value.trim(),
+						source: "optional-template",
+					},
+				]);
+				reporter.success(`Saved ${optionalSecret.name}`);
+			} else {
+				reporter.info(`Skipped ${optionalSecret.name}`);
 			}
 
 			reporter.start("Creating project...");
@@ -1309,6 +1334,23 @@ export async function createProject(
 				if (!urlShownEarly) {
 					reporter.success(`Deployed: ${workerUrl}`);
 				}
+
+				// Upload source snapshot for forking (prebuilt path needs this too)
+				try {
+					const { createSourceZip } = await import("./zip-packager.ts");
+					const { uploadSourceSnapshot } = await import("./control-plane.ts");
+					const { rm } = await import("node:fs/promises");
+
+					const sourceZipPath = await createSourceZip(targetDir);
+					await uploadSourceSnapshot(remoteResult.projectId, sourceZipPath);
+					await rm(sourceZipPath, { force: true });
+					debug("Source snapshot uploaded for prebuilt project");
+				} catch (err) {
+					debug(
+						"Source snapshot upload failed (prebuilt):",
+						err instanceof Error ? err.message : String(err),
+					);
+				}
 			} else {
 				// Prebuilt not available - fall back to fresh build
 				if (remoteResult.prebuiltFailed) {
@@ -1769,28 +1811,9 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		}
 	}
 
-	if (includeSync && deployMode !== "byo") {
-		const syncConfig = await getSyncConfig();
-		if (syncConfig.enabled && syncConfig.autoSync) {
-			const syncSpin = reporter.spinner("Syncing source to jack storage...");
-			try {
-				const syncResult = await syncToCloud(projectPath);
-				if (syncResult.success) {
-					if (syncResult.filesUploaded > 0 || syncResult.filesDeleted > 0) {
-						syncSpin.success(
-							`Synced source to jack storage (${syncResult.filesUploaded} uploaded, ${syncResult.filesDeleted} removed)`,
-						);
-					} else {
-						syncSpin.success("Source already synced");
-					}
-				}
-			} catch {
-				syncSpin.stop();
-				reporter.warn("Cloud sync failed (deploy succeeded)");
-				reporter.info("Run: jack sync");
-			}
-		}
-	}
+	// Note: Auto-sync to User R2 was removed for managed mode.
+	// Managed projects use control-plane source.zip for clone instead.
+	// BYO users can run 'jack sync' manually if needed.
 
 	// Ensure project is linked locally for discovery
 	try {
@@ -1936,7 +1959,9 @@ export async function getProjectStatus(
 
 /**
  * Scan for stale project paths.
- * Checks for paths in the index that no longer exist on disk or don't have valid links.
+ * Checks for:
+ * 1. Paths in the index that no longer have wrangler config (dir deleted/moved)
+ * 2. Managed projects where the cloud project no longer exists (orphaned links)
  * Returns total project count and stale entries with reasons.
  */
 export async function scanStaleProjects(): Promise<StaleProjectScan> {
@@ -1945,31 +1970,61 @@ export async function scanStaleProjects(): Promise<StaleProjectScan> {
 	const stale: StaleProject[] = [];
 	let totalPaths = 0;
 
+	// Get list of valid managed project IDs (if logged in)
+	let validManagedIds: Set<string> = new Set();
+	try {
+		const { isLoggedIn } = await import("./auth/store.ts");
+		if (await isLoggedIn()) {
+			const managedProjects = await listManagedProjects();
+			validManagedIds = new Set(managedProjects.map((p) => p.id));
+		}
+	} catch {
+		// Control plane unavailable, skip orphan detection
+	}
+
 	for (const projectId of projectIds) {
 		const paths = allPaths[projectId] || [];
 		totalPaths += paths.length;
 
 		for (const projectPath of paths) {
-			// Check if path exists and has valid link
+			// Check if path exists and has valid wrangler config
 			const hasWranglerConfig =
 				existsSync(join(projectPath, "wrangler.jsonc")) ||
 				existsSync(join(projectPath, "wrangler.toml")) ||
 				existsSync(join(projectPath, "wrangler.json"));
 
 			if (!hasWranglerConfig) {
-				// Try to get project name from the path
-				let name = projectPath.split("/").pop() || projectId;
-				try {
-					name = await getProjectNameFromDir(projectPath);
-				} catch {
-					// Use path basename as fallback
-				}
-
+				// Type 1: No wrangler config at path (dir deleted/moved)
+				const name = projectPath.split("/").pop() || projectId;
 				stale.push({
 					name,
-					reason: "worker not deployed",
+					reason: "directory missing or no wrangler config",
 					workerUrl: null,
 				});
+				continue;
+			}
+
+			// Check for Type 2: Managed project link pointing to deleted cloud project
+			try {
+				const link = await readProjectLink(projectPath);
+				if (link?.deploy_mode === "managed" && validManagedIds.size > 0) {
+					if (!validManagedIds.has(link.project_id)) {
+						// Orphaned managed link - cloud project doesn't exist
+						let name = projectPath.split("/").pop() || projectId;
+						try {
+							name = await getProjectNameFromDir(projectPath);
+						} catch {
+							// Use path basename as fallback
+						}
+						stale.push({
+							name,
+							reason: "cloud project deleted",
+							workerUrl: null,
+						});
+					}
+				}
+			} catch {
+				// Can't read link, skip
 			}
 		}
 	}

package/src/lib/project-resolver.ts

@@ -382,7 +382,7 @@ export async function listAllProjects(): Promise<ResolvedProject[]> {
 					!project.sources.controlPlane
 				) {
 					project.status = "error";
-					project.errorMessage = "Project not found in jack cloud. Run: jack unlink && jack ship";
+					project.errorMessage = "Project not found in jack cloud";
 				}
 			}
 		} catch {

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

@@ -155,6 +155,8 @@ export async function createDatabase(
 	let databaseId: string;
 	let created = true;
 
+	let actualDatabaseName = databaseName;
+
 	if (link.deploy_mode === "managed") {
 		// Managed mode: call control plane
 		// Note: Control plane will reuse existing DB if name matches
@@ -163,7 +165,8 @@ export async function createDatabase(
 			bindingName,
 		});
 		databaseId = resource.provider_id;
-		// Control plane always creates for now; could add reuse logic there too
+		// Use the actual name from control plane (may differ from CLI-generated name)
+		actualDatabaseName = resource.resource_name;
 	} else {
 		// BYO mode: use wrangler d1 create (checks for existing first)
 		const result = await createDatabaseViaWrangler(databaseName);
@@ -174,12 +177,12 @@ export async function createDatabase(
 	// Update wrangler.jsonc with the new binding
 	await addD1Binding(wranglerPath, {
 		binding: bindingName,
-		database_name: databaseName,
+		database_name: actualDatabaseName,
 		database_id: databaseId,
 	});
 
 	return {
-		databaseName,
+		databaseName: actualDatabaseName,
 		databaseId,
 		bindingName,
 		created,

package/src/lib/version-check.ts

@@ -7,6 +7,7 @@ import { join } from "node:path";
 import { $ } from "bun";
 import pkg from "../../package.json";
 import { CONFIG_DIR } from "./config.ts";
+import { debug } from "./debug.ts";
 
 const VERSION_CACHE_PATH = join(CONFIG_DIR, "version-cache.json");
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
@@ -123,8 +124,17 @@ export async function performUpdate(): Promise<{
 }> {
 	try {
 		// Run bun add -g to update
+		debug(`Executing: bun add -g ${PACKAGE_NAME}@latest`);
 		const result = await $`bun add -g ${PACKAGE_NAME}@latest`.nothrow().quiet();
 
+		debug(`Exit code: ${result.exitCode}`);
+		if (result.stdout.toString()) {
+			debug(`stdout: ${result.stdout.toString()}`);
+		}
+		if (result.stderr.toString()) {
+			debug(`stderr: ${result.stderr.toString()}`);
+		}
+
 		if (result.exitCode !== 0) {
 			return {
 				success: false,
@@ -133,12 +143,15 @@ export async function performUpdate(): Promise<{
 		}
 
 		// Verify the new version
+		debug("Verifying installed version...");
 		const newVersionResult = await $`bun pm ls -g`.nothrow().quiet();
 		const output = newVersionResult.stdout.toString();
+		debug(`bun pm ls -g output: ${output.slice(0, 500)}`);
 
 		// Try to extract version from output
 		const versionMatch = output.match(/@getjack\/jack@(\d+\.\d+\.\d+)/);
 		const newVersion = versionMatch?.[1];
+		debug(`Extracted version: ${newVersion ?? "not found"}`);
 
 		// Clear version cache so next check gets fresh data
 		try {
@@ -152,6 +165,7 @@ export async function performUpdate(): Promise<{
 			version: newVersion,
 		};
 	} catch (err) {
+		debug(`Update error: ${err instanceof Error ? err.message : String(err)}`);
 		return {
 			success: false,
 			error: err instanceof Error ? err.message : "Unknown error",

package/src/lib/wrangler-config.ts

@@ -457,3 +457,193 @@ function findLineCommentStart(line: string): number {
 
 	return -1;
 }
+
+/**
+ * Remove a D1 database binding from wrangler.jsonc by database_name.
+ * Preserves comments and formatting.
+ *
+ * @returns true if binding was found and removed, false if not found
+ */
+export async function removeD1Binding(configPath: string, databaseName: string): Promise<boolean> {
+	if (!existsSync(configPath)) {
+		throw new Error(`wrangler.jsonc not found at ${configPath}. Cannot remove binding.`);
+	}
+
+	const content = await Bun.file(configPath).text();
+
+	// Parse to understand existing structure
+	const config = parseJsonc<WranglerConfig>(content);
+
+	// Check if d1_databases exists and has entries
+	if (!config.d1_databases || !Array.isArray(config.d1_databases)) {
+		return false;
+	}
+
+	// Find the binding to remove
+	const bindingIndex = config.d1_databases.findIndex((db) => db.database_name === databaseName);
+
+	if (bindingIndex === -1) {
+		return false; // Binding not found
+	}
+
+	// Use text manipulation to remove the binding while preserving formatting
+	const newContent = removeD1DatabaseEntryFromContent(content, databaseName);
+
+	if (newContent === content) {
+		return false; // Nothing changed
+	}
+
+	await Bun.write(configPath, newContent);
+	return true;
+}
+
+/**
+ * Remove a specific D1 database entry from the d1_databases array in content.
+ * Handles comma placement and preserves comments.
+ */
+function removeD1DatabaseEntryFromContent(content: string, databaseName: string): string {
+	// Find the d1_databases array
+	const d1Match = content.match(/"d1_databases"\s*:\s*\[/);
+	if (!d1Match || d1Match.index === undefined) {
+		return content;
+	}
+
+	const arrayStartIndex = d1Match.index + d1Match[0].length;
+	const closingBracketIndex = findMatchingBracket(content, arrayStartIndex - 1, "[", "]");
+
+	if (closingBracketIndex === -1) {
+		return content;
+	}
+
+	const arrayContent = content.slice(arrayStartIndex, closingBracketIndex);
+
+	// Find the object containing this database_name
+	const escapedName = databaseName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const dbNamePattern = new RegExp(`"database_name"\\s*:\\s*"${escapedName}"`);
+
+	const match = dbNamePattern.exec(arrayContent);
+	if (!match) {
+		return content;
+	}
+
+	// Find the enclosing object boundaries
+	const matchPosInArray = match.index;
+	const objectStart = findObjectStartBefore(arrayContent, matchPosInArray);
+	const objectEnd = findObjectEndAfter(arrayContent, matchPosInArray);
+
+	if (objectStart === -1 || objectEnd === -1) {
+		return content;
+	}
+
+	// Determine comma handling
+	let removeStart = objectStart;
+	let removeEnd = objectEnd + 1;
+
+	// Check for trailing comma after the object
+	const afterObject = arrayContent.slice(objectEnd + 1);
+	const trailingCommaMatch = afterObject.match(/^\s*,/);
+
+	// Check for leading comma before the object
+	const beforeObject = arrayContent.slice(0, objectStart);
+	const leadingCommaMatch = beforeObject.match(/,\s*$/);
+
+	if (trailingCommaMatch) {
+		// Remove trailing comma
+		removeEnd = objectEnd + 1 + trailingCommaMatch[0].length;
+	} else if (leadingCommaMatch) {
+		// Remove leading comma
+		removeStart = objectStart - leadingCommaMatch[0].length;
+	}
+
+	// Build new array content
+	const newArrayContent = arrayContent.slice(0, removeStart) + arrayContent.slice(removeEnd);
+
+	// Check if array is now effectively empty (only whitespace/comments)
+	const trimmedArray = newArrayContent.replace(/\/\/[^\n]*/g, "").trim();
+	if (trimmedArray === "" || trimmedArray === "[]") {
+		// Remove the entire d1_databases property
+		return removeD1DatabasesProperty(content, d1Match.index, closingBracketIndex);
+	}
+
+	return content.slice(0, arrayStartIndex) + newArrayContent + content.slice(closingBracketIndex);
+}
+
+/**
+ * Find the start of the object (opening brace) before the given position.
+ */
+function findObjectStartBefore(content: string, fromPos: number): number {
+	let depth = 0;
+	for (let i = fromPos; i >= 0; i--) {
+		const char = content[i];
+		if (char === "}") depth++;
+		if (char === "{") {
+			if (depth === 0) return i;
+			depth--;
+		}
+	}
+	return -1;
+}
+
+/**
+ * Find the end of the object (closing brace) after the given position.
+ */
+function findObjectEndAfter(content: string, fromPos: number): number {
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+
+	for (let i = fromPos; i < content.length; i++) {
+		const char = content[i];
+
+		if (inString) {
+			if (escaped) {
+				escaped = false;
+			} else if (char === "\\") {
+				escaped = true;
+			} else if (char === '"') {
+				inString = false;
+			}
+			continue;
+		}
+
+		if (char === '"') {
+			inString = true;
+			continue;
+		}
+
+		if (char === "{") depth++;
+		if (char === "}") {
+			if (depth === 0) return i;
+			depth--;
+		}
+	}
+	return -1;
+}
+
+/**
+ * Remove the entire d1_databases property when it becomes empty.
+ */
+function removeD1DatabasesProperty(
+	content: string,
+	propertyStart: number,
+	arrayEnd: number,
+): string {
+	let removeStart = propertyStart;
+	let removeEnd = arrayEnd + 1;
+
+	// Look backward for a comma to remove
+	const beforeProperty = content.slice(0, propertyStart);
+	const leadingCommaMatch = beforeProperty.match(/,\s*$/);
+
+	// Look forward for a trailing comma
+	const afterProperty = content.slice(arrayEnd + 1);
+	const trailingCommaMatch = afterProperty.match(/^\s*,/);
+
+	if (leadingCommaMatch) {
+		removeStart = propertyStart - leadingCommaMatch[0].length;
+	} else if (trailingCommaMatch) {
+		removeEnd = arrayEnd + 1 + trailingCommaMatch[0].length;
+	}
+
+	return content.slice(0, removeStart) + content.slice(removeEnd);
+}