@getjack/jack 0.1.17 → 0.1.19

package/package.json

@@ -1,16 +1,13 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.17",
+	"version": "0.1.19",
 	"description": "Ship before you forget why you started. The vibecoder's deployment CLI.",
 	"license": "Apache-2.0",
 	"type": "module",
 	"bin": {
 		"jack": "./src/index.ts"
 	},
-	"files": [
-		"src",
-		"templates"
-	],
+	"files": ["src", "templates"],
 	"engines": {
 		"bun": ">=1.0.0"
 	},

package/src/commands/clone.ts

@@ -1,13 +1,14 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { isCancel, select } from "@clack/prompts";
-import { fetchProjectTags } from "../lib/control-plane.ts";
+import { downloadProjectSource, fetchProjectTags } from "../lib/control-plane.ts";
 import { formatSize } from "../lib/format.ts";
 import { box, error, info, spinner, success } from "../lib/output.ts";
 import { registerPath } from "../lib/paths-index.ts";
 import { linkProject, updateProjectLink } from "../lib/project-link.ts";
 import { resolveProject } from "../lib/project-resolver.ts";
 import { cloneFromCloud, getRemoteManifest } from "../lib/storage/index.ts";
+import { extractZipToDirectory } from "../lib/zip-utils.ts";
 
 export interface CloneFlags {
 	as?: string;
@@ -53,53 +54,74 @@ export default async function clone(projectName?: string, flags: CloneFlags = {}
 		}
 	}
 
-	// Fetch remote manifest
-	const spin = spinner(`Fetching from jack-storage/${projectName}/...`);
-	const manifest = await getRemoteManifest(projectName);
+	// Check if this is a managed project (has source in control-plane)
+	const spin = spinner(`Looking up ${projectName}...`);
+	let project: Awaited<ReturnType<typeof resolveProject>> = null;
 
-	if (!manifest) {
-		spin.error(`Project not found: ${projectName}`);
-		process.exit(1);
+	try {
+		project = await resolveProject(projectName);
+	} catch {
+		// Not found on control-plane, will fall back to User R2
 	}
 
-	// Show file count and size
-	const totalSize = manifest.files.reduce((sum, f) => sum + f.size, 0);
-	spin.success(`Found ${manifest.files.length} file(s) (${formatSize(totalSize)})`);
+	// Managed mode: download from control-plane
+	if (project?.sources.controlPlane && project.remote?.projectId) {
+		spin.success("Found on jack cloud");
+
+		const downloadSpin = spinner("Downloading from jack cloud...");
+		try {
+			const sourceZip = await downloadProjectSource(projectName);
+			const fileCount = await extractZipToDirectory(sourceZip, targetDir);
+			downloadSpin.success(`Restored ${fileCount} file(s) to ./${flags.as ?? projectName}/`);
+		} catch (err) {
+			downloadSpin.error("Download failed");
+			const message = err instanceof Error ? err.message : "Could not download project source";
+			error(message);
+			process.exit(1);
+		}
 
-	// Download files
-	const downloadSpin = spinner("Downloading...");
-	const result = await cloneFromCloud(projectName, targetDir);
+		// Link to control-plane
+		await linkProject(targetDir, project.remote.projectId, "managed");
+		await registerPath(project.remote.projectId, targetDir);
 
-	if (!result.success) {
-		downloadSpin.error("Clone failed");
-		error(result.error || "Could not download project files");
-		info("Check your network connection and try again");
-		process.exit(1);
-	}
+		// Fetch and restore tags from control plane
+		try {
+			const remoteTags = await fetchProjectTags(project.remote.projectId);
+			if (remoteTags.length > 0) {
+				await updateProjectLink(targetDir, { tags: remoteTags });
+				info(`Restored ${remoteTags.length} tag(s)`);
+			}
+		} catch {
+			// Silent fail - tag restoration is non-critical
+		}
+	} else {
+		// BYO mode: use existing User R2 flow
+		spin.stop();
+		const fetchSpin = spinner(`Fetching from jack-storage/${projectName}/...`);
+		const manifest = await getRemoteManifest(projectName);
+
+		if (!manifest) {
+			fetchSpin.error(`Project not found: ${projectName}`);
+			info("For BYO projects, run 'jack sync' first to backup your project.");
+			process.exit(1);
+		}
 
-	downloadSpin.success(`Restored to ./${flags.as ?? projectName}/`);
+		// Show file count and size
+		const totalSize = manifest.files.reduce((sum, f) => sum + f.size, 0);
+		fetchSpin.success(`Found ${manifest.files.length} file(s) (${formatSize(totalSize)})`);
 
-	// Link project to control plane if it's a managed project
-	try {
-		const project = await resolveProject(projectName);
-		if (project?.sources.controlPlane && project.remote?.projectId) {
-			// Managed project - link with control plane project ID
-			await linkProject(targetDir, project.remote.projectId, "managed");
-			await registerPath(project.remote.projectId, targetDir);
-
-			// Fetch and restore tags from control plane
-			try {
-				const remoteTags = await fetchProjectTags(project.remote.projectId);
-				if (remoteTags.length > 0) {
-					await updateProjectLink(targetDir, { tags: remoteTags });
-					info(`Restored ${remoteTags.length} tag(s)`);
-				}
-			} catch {
-				// Silent fail - tag restoration is non-critical
-			}
+		// Download files
+		const downloadSpin = spinner("Downloading...");
+		const result = await cloneFromCloud(projectName, targetDir);
+
+		if (!result.success) {
+			downloadSpin.error("Clone failed");
+			error(result.error || "Could not download project files");
+			info("Check your network connection and try again");
+			process.exit(1);
 		}
-	} catch {
-		// Not a control plane project or offline - continue without linking
+
+		downloadSpin.success(`Restored to ./${flags.as ?? projectName}/`);
 	}
 
 	// Show next steps

package/src/commands/init.ts

@@ -12,6 +12,12 @@ import { ensureAuth, ensureWrangler, isAuthenticated } from "../lib/wrangler.ts"
 export async function isInitialized(): Promise<boolean> {
 	const config = await readConfig();
 	if (!config?.initialized) return false;
+
+	// Check Jack Cloud auth first (most common path)
+	const { isLoggedIn } = await import("../lib/auth/store.ts");
+	if (await isLoggedIn()) return true;
+
+	// Fall back to wrangler/Cloudflare auth (BYO mode)
 	return await isAuthenticated();
 }
 

package/src/commands/services.ts

@@ -277,6 +277,12 @@ async function dbExport(options: ServiceOptions): Promise<void> {
  */
 async function dbDelete(options: ServiceOptions): Promise<void> {
 	const projectName = await resolveProjectName(options);
+	const projectDir = process.cwd();
+
+	// Check deploy mode
+	const link = await readProjectLink(projectDir);
+	const isManaged = link?.deploy_mode === "managed";
+
 	const dbInfo = await resolveDatabaseInfo(projectName);
 
 	if (!dbInfo) {
@@ -314,14 +320,80 @@ async function dbDelete(options: ServiceOptions): Promise<void> {
 		return;
 	}
 
-	// Delete database
 	outputSpinner.start("Deleting database...");
+
+	// Track binding_name from control plane for matching in wrangler.jsonc
+	let controlPlaneBindingName: string | null = null;
+
 	try {
-		await deleteDatabase(dbInfo.name);
+		if (isManaged && link) {
+			// Managed mode: delete via control plane
+			const { fetchProjectResources, deleteProjectResource } = await import(
+				"../lib/control-plane.ts"
+			);
+
+			// Find the resource ID for this database
+			const resources = await fetchProjectResources(link.project_id);
+			const d1Resource = resources.find(
+				(r) => r.resource_type === "d1" && r.resource_name === dbInfo.name,
+			);
+
+			if (d1Resource) {
+				// Save binding_name for wrangler.jsonc cleanup
+				controlPlaneBindingName = d1Resource.binding_name;
+				// Delete via control plane (which also deletes from Cloudflare)
+				await deleteProjectResource(link.project_id, d1Resource.id);
+			} else {
+				// Resource not in control plane - fall back to wrangler for cleanup
+				await deleteDatabase(dbInfo.name);
+			}
+		} else {
+			// BYO mode: delete via wrangler directly
+			await deleteDatabase(dbInfo.name);
+		}
+
+		// Remove binding from wrangler.jsonc (both modes)
+		// Note: We need to find the LOCAL database_name from wrangler.jsonc,
+		// which may differ from the control plane's resource_name
+		const { removeD1Binding, getExistingD1Bindings } = await import("../lib/wrangler-config.ts");
+		const configPath = join(projectDir, "wrangler.jsonc");
+
+		let bindingRemoved = false;
+		try {
+			// Find the binding by matching (in order of reliability):
+			// 1. binding name (e.g., "DB") - if control plane provided it
+			// 2. database_id (provider_id from control plane)
+			// 3. database_name
+			// 4. If managed mode and we successfully deleted, remove first D1 binding
+			const existingBindings = await getExistingD1Bindings(configPath);
+			let bindingToRemove = existingBindings.find(
+				(b) =>
+					(controlPlaneBindingName && b.binding === controlPlaneBindingName) ||
+					b.database_id === dbInfo.id ||
+					b.database_name === dbInfo.name,
+			);
+
+			// Fallback: if managed mode and we deleted from control plane,
+			// remove the first D1 binding (binding_name may be null for older DBs)
+			if (!bindingToRemove && isManaged && existingBindings.length > 0) {
+				bindingToRemove = existingBindings[0];
+			}
+
+			if (bindingToRemove) {
+				bindingRemoved = await removeD1Binding(configPath, bindingToRemove.database_name);
+			}
+		} catch (bindingErr) {
+			// Log but don't fail - the database is already deleted
+			// The user can manually clean up wrangler.jsonc if needed
+		}
+
 		outputSpinner.stop();
 
 		console.error("");
 		success("Database deleted");
+		if (bindingRemoved) {
+			item("Binding removed from wrangler.jsonc");
+		}
 		console.error("");
 	} catch (err) {
 		outputSpinner.stop();
@@ -332,10 +404,11 @@ async function dbDelete(options: ServiceOptions): Promise<void> {
 }
 
 /**
- * Parse --name flag from args
- * Supports: --name foo, --name=foo
+ * Parse --name flag or positional arg from args
+ * Supports: --name foo, --name=foo, or first positional arg
  */
 function parseNameFlag(args: string[]): string | undefined {
+	// Check --name flag first (takes priority)
 	for (let i = 0; i < args.length; i++) {
 		const arg = args[i];
 		if (arg === "--name" && args[i + 1]) {
@@ -345,6 +418,14 @@ function parseNameFlag(args: string[]): string | undefined {
 			return arg.slice("--name=".length);
 		}
 	}
+
+	// Fall back to first positional argument (non-flag)
+	for (const arg of args) {
+		if (!arg.startsWith("-")) {
+			return arg;
+		}
+	}
+
 	return undefined;
 }
 

package/src/commands/sync.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { getSyncConfig } from "../lib/config.ts";
 import { error, info, spinner, success, warn } from "../lib/output.ts";
+import { readProjectLink } from "../lib/project-link.ts";
 import { syncToCloud } from "../lib/storage/index.ts";
 
 export interface SyncFlags {
@@ -25,6 +26,14 @@ export default async function sync(flags: SyncFlags = {}): Promise<void> {
 		process.exit(1);
 	}
 
+	// Check if this is a managed project
+	const link = await readProjectLink(process.cwd());
+	if (link?.deploy_mode === "managed") {
+		info("Managed projects are automatically backed up to jack cloud during deploy.");
+		info("Use 'jack clone <project>' on another machine to restore.");
+		return;
+	}
+
 	// Check if sync is enabled
 	const syncConfig = await getSyncConfig();
 	if (!syncConfig.enabled) {

package/src/commands/update.ts

@@ -2,6 +2,7 @@
  * jack update - Self-update to the latest version
  */
 
+import { debug } from "../lib/debug.ts";
 import { error, info, success, warn } from "../lib/output.ts";
 import {
 	checkForUpdate,
@@ -13,8 +14,13 @@ import {
 export default async function update(): Promise<void> {
 	const currentVersion = getCurrentVersion();
 
+	debug("Update check started");
+	debug(`Current version: ${currentVersion}`);
+	debug(`Exec path: ${process.argv[1]}`);
+
 	// Check if running via bunx
 	if (isRunningViaBunx()) {
+		debug("Detected bunx execution");
 		info(`Running via bunx (current: v${currentVersion})`);
 		info("bunx automatically uses cached packages.");
 		info("To get the latest version, run:");
@@ -28,7 +34,9 @@ export default async function update(): Promise<void> {
 	info(`Current version: v${currentVersion}`);
 
 	// Check for updates
+	debug("Fetching latest version from npm...");
 	const latestVersion = await checkForUpdate();
+	debug(`Latest version from npm: ${latestVersion ?? "none (you're up to date)"}`);
 
 	if (!latestVersion) {
 		success("You're on the latest version!");
@@ -38,7 +46,9 @@ export default async function update(): Promise<void> {
 	info(`New version available: v${latestVersion}`);
 	info("Updating...");
 
+	debug("Running: bun add -g @getjack/jack@latest");
 	const result = await performUpdate();
+	debug(`Update result: ${JSON.stringify(result)}`);
 
 	if (result.success) {
 		success(`Updated to v${result.version ?? latestVersion}`);

package/src/lib/control-plane.ts

@@ -371,6 +371,46 @@ export async function createProjectResource(
 	return data.resource;
 }
 
+export interface DeleteResourceResponse {
+	success: boolean;
+	resource_id: string;
+	deleted_at: string;
+}
+
+/**
+ * Delete a resource from a managed project.
+ * Uses DELETE /v1/projects/:id/resources/:id endpoint.
+ */
+export async function deleteProjectResource(
+	projectId: string,
+	resourceId: string,
+): Promise<DeleteResourceResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/${projectId}/resources/${resourceId}`,
+		{ method: "DELETE" },
+	);
+
+	// Handle 404 gracefully - resource may already be deleted
+	if (response.status === 404) {
+		return {
+			success: true,
+			resource_id: resourceId,
+			deleted_at: new Date().toISOString(),
+		};
+	}
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to delete resource: ${response.status}`);
+	}
+
+	return response.json() as Promise<DeleteResourceResponse>;
+}
+
 /**
  * Sync project tags to the control plane.
  * Fire-and-forget: errors are logged but not thrown.
@@ -580,3 +620,25 @@ export async function publishProject(projectId: string): Promise<PublishProjectR
 
 	return response.json() as Promise<PublishProjectResponse>;
 }
+
+/**
+ * Download the source snapshot for a project.
+ * Returns the zip file contents as a Buffer.
+ * Used by jack clone to restore managed projects.
+ */
+export async function downloadProjectSource(slug: string): Promise<Buffer> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/by-slug/${encodeURIComponent(slug)}/source`,
+	);
+
+	if (!response.ok) {
+		if (response.status === 404) {
+			throw new Error("Project source not found. Deploy first with 'jack ship'.");
+		}
+		throw new Error(`Failed to download source: ${response.status}`);
+	}
+
+	return Buffer.from(await response.arrayBuffer());
+}

package/src/lib/managed-deploy.ts

@@ -4,12 +4,15 @@
  * Isolates managed deployment logic from BYO (wrangler) path.
  */
 
+import { stat } from "node:fs/promises";
 import { validateBindings } from "./binding-validator.ts";
 import { buildProject, parseWranglerConfig } from "./build-helper.ts";
 import { createManagedProject, syncProjectTags, uploadSourceSnapshot } from "./control-plane.ts";
 import { debug } from "./debug.ts";
 import { uploadDeployment } from "./deploy-upload.ts";
 import { JackError, JackErrorCode } from "./errors.ts";
+import { formatSize } from "./format.ts";
+import { createUploadProgress } from "./progress.ts";
 import type { OperationReporter } from "./project-operations.ts";
 import { getProjectTags } from "./tags.ts";
 import { Events, track } from "./telemetry.ts";
@@ -120,7 +123,28 @@ export async function deployCodeToManagedProject(
 		reporter?.success("Packaged artifacts");
 
 		// Step 4: Upload to control plane
-		reporter?.start("Uploading to jack cloud...");
+		// Calculate total upload size for progress display
+		const fileSizes = await Promise.all([
+			stat(pkg.bundleZipPath).then((s) => s.size),
+			stat(pkg.sourceZipPath).then((s) => s.size),
+			stat(pkg.manifestPath).then((s) => s.size),
+			pkg.schemaPath ? stat(pkg.schemaPath).then((s) => s.size) : Promise.resolve(0),
+			pkg.secretsPath ? stat(pkg.secretsPath).then((s) => s.size) : Promise.resolve(0),
+			pkg.assetsZipPath ? stat(pkg.assetsZipPath).then((s) => s.size) : Promise.resolve(0),
+		]);
+		const totalUploadSize = fileSizes.reduce((sum, size) => sum + size, 0);
+		debug(`Upload size: ${formatSize(totalUploadSize)}`);
+
+		// Stop the reporter spinner - we'll use our own progress display
+		reporter?.stop();
+
+		// Use custom progress with pulsing bar (since fetch doesn't support upload progress)
+		const uploadProgress = createUploadProgress({
+			totalSize: totalUploadSize,
+			label: "Uploading to jack cloud",
+		});
+		uploadProgress.start();
+
 		const result = await uploadDeployment({
 			projectId,
 			bundleZipPath: pkg.bundleZipPath,
@@ -132,7 +156,7 @@ export async function deployCodeToManagedProject(
 			assetManifest: pkg.assetManifest ?? undefined,
 		});
 
-		reporter?.stop();
+		uploadProgress.complete();
 		reporter?.success("Deployed to jack cloud");
 
 		// Track success

package/src/lib/output.ts

@@ -2,6 +2,19 @@ import yoctoSpinner from "yocto-spinner";
 
 const isColorEnabled = !process.env.NO_COLOR && process.stderr.isTTY !== false;
 
+/**
+ * ANSI color codes for terminal output
+ */
+export const colors = {
+	green: isColorEnabled ? "\x1b[32m" : "",
+	red: isColorEnabled ? "\x1b[31m" : "",
+	yellow: isColorEnabled ? "\x1b[33m" : "",
+	cyan: isColorEnabled ? "\x1b[36m" : "",
+	dim: isColorEnabled ? "\x1b[90m" : "",
+	bold: isColorEnabled ? "\x1b[1m" : "",
+	reset: isColorEnabled ? "\x1b[0m" : "",
+};
+
 let currentSpinner: ReturnType<typeof yoctoSpinner> | null = null;
 
 /**
@@ -95,8 +108,10 @@ export function item(message: string): void {
 	console.error(`  ${message}`);
 }
 
-// Random neon purple for cyberpunk styling
-function getRandomPurple(): string {
+/**
+ * Random neon purple for cyberpunk styling
+ */
+export function getRandomPurple(): string {
 	const purples = [177, 165, 141, 129];
 	const colorCode = purples[Math.floor(Math.random() * purples.length)];
 	return `\x1b[38;5;${colorCode}m`;
@@ -117,12 +132,15 @@ export function box(title: string, lines: string[]): void {
 	const fill = "▓".repeat(innerWidth);
 	const gradient = "░".repeat(innerWidth);
 
+	// Pad plain text first, then apply colors (ANSI codes break padEnd calculation)
 	const pad = (text: string) => `  ${text.padEnd(maxLen)}  `;
+	const padTitle = (text: string) =>
+		`  ${bold}${text}${reset}${purple}${" ".repeat(maxLen - text.length)}  `;
 
 	console.error("");
 	console.error(`  ${purple}╔${bar}╗${reset}`);
 	console.error(`  ${purple}║${fill}║${reset}`);
-	console.error(`  ${purple}║${pad(bold + title + reset + purple)}║${reset}`);
+	console.error(`  ${purple}║${padTitle(title)}║${reset}`);
 	console.error(`  ${purple}║${"─".repeat(innerWidth)}║${reset}`);
 	for (const line of lines) {
 		console.error(`  ${purple}║${pad(line)}║${reset}`);

package/src/lib/progress.ts

@@ -0,0 +1,160 @@
+/**
+ * Progress tracker with delayed bar display
+ * Shows a simple spinner initially, then reveals a progress bar
+ * after a configurable delay (aligned with SPIRIT.md principles)
+ */
+
+import { formatSize } from "./format.ts";
+import { colors, getRandomPurple } from "./output.ts";
+
+export interface ProgressOptions {
+	total: number;
+	delayMs?: number;
+	barWidth?: number;
+	label?: string;
+}
+
+export interface UploadProgressOptions {
+	totalSize: number;
+	delayMs?: number;
+	barWidth?: number;
+	label?: string;
+}
+
+const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+/**
+ * Creates a progress tracker that shows a spinner initially,
+ * then reveals a progress bar after a delay.
+ *
+ * Usage:
+ *   const progress = createProgressTracker({ total: fileSize });
+ *   progress.start();
+ *   // ... during upload
+ *   progress.update(bytesUploaded);
+ *   // ... when done
+ *   progress.complete();
+ */
+export function createProgressTracker(options: ProgressOptions) {
+	const { total, delayMs = 2000, barWidth = 25, label = "Uploading" } = options;
+	const startTime = Date.now();
+	let frame = 0;
+	let intervalId: Timer | null = null;
+	let current = 0;
+
+	function render() {
+		const elapsed = Date.now() - startTime;
+		const pct = Math.min(Math.round((current / total) * 100), 100);
+
+		clearLine();
+
+		if (elapsed < delayMs) {
+			// Just spinner for first N seconds
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label}...`,
+			);
+		} else {
+			// Show progress bar after delay
+			const purple = getRandomPurple();
+			const filled = Math.round((pct / 100) * barWidth);
+			const empty = barWidth - filled;
+			const bar = "▓".repeat(filled) + "░".repeat(empty);
+
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label} ${purple}[${bar}]${colors.reset} ${pct}% ${colors.dim}(${formatSize(current)} / ${formatSize(total)})${colors.reset}`,
+			);
+		}
+	}
+
+	return {
+		start() {
+			render();
+			intervalId = setInterval(render, 80);
+		},
+
+		update(bytes: number) {
+			current = bytes;
+		},
+
+		complete() {
+			if (intervalId) {
+				clearInterval(intervalId);
+				intervalId = null;
+			}
+			clearLine();
+		},
+	};
+}
+
+/**
+ * Creates an upload progress indicator for operations where we know the total
+ * size but can't track byte-level progress (e.g., fetch uploads).
+ *
+ * Shows spinner first, then after delay shows an animated bar with size info.
+ * The bar pulses to indicate activity without false progress claims.
+ */
+export function createUploadProgress(options: UploadProgressOptions) {
+	const { totalSize, delayMs = 2000, barWidth = 25, label = "Uploading" } = options;
+	const startTime = Date.now();
+	let frame = 0;
+	let pulsePos = 0;
+	let intervalId: Timer | null = null;
+
+	function render() {
+		const elapsed = Date.now() - startTime;
+		const elapsedSec = (elapsed / 1000).toFixed(1);
+
+		clearLine();
+
+		if (elapsed < delayMs) {
+			// Just spinner for first N seconds
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label}...`,
+			);
+		} else {
+			// Show pulsing bar after delay (indicates activity without false progress)
+			const purple = getRandomPurple();
+
+			// Create pulsing effect - a bright section that moves across the bar
+			const pulseWidth = 5;
+			pulsePos = (pulsePos + 1) % (barWidth + pulseWidth);
+
+			let bar = "";
+			for (let i = 0; i < barWidth; i++) {
+				const distFromPulse = Math.abs(i - pulsePos);
+				if (distFromPulse < pulseWidth) {
+					bar += "▓";
+				} else {
+					bar += "░";
+				}
+			}
+
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label} ${purple}[${bar}]${colors.reset} ${colors.dim}${formatSize(totalSize)} • ${elapsedSec}s${colors.reset}`,
+			);
+		}
+	}
+
+	return {
+		start() {
+			if (process.stderr.isTTY) {
+				render();
+				intervalId = setInterval(render, 80);
+			}
+		},
+
+		complete() {
+			if (intervalId) {
+				clearInterval(intervalId);
+				intervalId = null;
+			}
+			clearLine();
+		},
+	};
+}
+
+function clearLine() {
+	if (process.stderr.isTTY) {
+		process.stderr.write("\r\x1b[K");
+	}
+}

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";
 
 // ============================================================================
@@ -973,6 +972,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 +1036,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 +1320,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 +1797,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 +1945,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 +1956,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/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);
+}

package/src/lib/zip-packager.ts

@@ -6,6 +6,8 @@ import { join, relative } from "node:path";
 import archiver from "archiver";
 import { type AssetManifest, computeAssetHash } from "./asset-hash.ts";
 import type { BuildOutput, WranglerConfig } from "./build-helper.ts";
+import { debug } from "./debug.ts";
+import { formatSize } from "./format.ts";
 import { scanProjectFiles } from "./storage/file-filter.ts";
 
 export interface ZipPackageResult {
@@ -82,6 +84,42 @@ async function createZipArchive(
 	});
 }
 
+/**
+ * Creates source.zip from project files without building.
+ * Used for prebuilt deployments that skip the full package flow.
+ * @param projectPath - Absolute path to project directory
+ * @returns Path to the created source.zip (caller responsible for cleanup)
+ */
+export async function createSourceZip(projectPath: string): Promise<string> {
+	const packageDir = join(tmpdir(), `jack-source-${Date.now()}`);
+	await mkdir(packageDir, { recursive: true });
+
+	const sourceZipPath = join(packageDir, "source.zip");
+	const projectFiles = await scanProjectFiles(projectPath);
+
+	// Debug output for source file statistics
+	const totalSize = projectFiles.reduce((sum, f) => sum + f.size, 0);
+	const largest =
+		projectFiles.length > 0
+			? projectFiles.reduce((max, f) => (f.size > max.size ? f : max), projectFiles[0])
+			: null;
+
+	debug(`Source: ${projectFiles.length} files, ${formatSize(totalSize)} uncompressed`);
+	if (largest) {
+		debug(`Largest: ${largest.path} (${formatSize(largest.size)})`);
+	}
+
+	const sourceFiles = projectFiles.map((f) => f.path);
+	await createZipArchive(sourceZipPath, projectPath, sourceFiles);
+
+	// Debug output for compression statistics
+	const zipStats = await stat(sourceZipPath);
+	const ratio = totalSize > 0 ? ((1 - zipStats.size / totalSize) * 100).toFixed(0) : 0;
+	debug(`Compressed: ${formatSize(zipStats.size)} (${ratio}% reduction)`);
+
+	return sourceZipPath;
+}
+
 /**
  * Recursively collects all file paths in a directory
  */

package/src/lib/zip-utils.ts

@@ -0,0 +1,38 @@
+/**
+ * Zip utility functions for extracting zip archives
+ */
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { unzipSync } from "fflate";
+
+/**
+ * Extract a zip buffer to a target directory.
+ * Creates directories as needed and writes files preserving relative paths.
+ *
+ * @param zipBuffer - The zip file contents as a Buffer
+ * @param targetDir - The directory to extract files to
+ * @returns The number of files extracted
+ */
+export async function extractZipToDirectory(zipBuffer: Buffer, targetDir: string): Promise<number> {
+	const unzipped = unzipSync(new Uint8Array(zipBuffer));
+	let fileCount = 0;
+
+	for (const [path, content] of Object.entries(unzipped)) {
+		// Skip directories (they end with /)
+		if (path.endsWith("/")) continue;
+
+		// Security: prevent path traversal by removing any .. segments
+		const normalizedPath = path.replace(/\.\./g, "");
+		const fullPath = join(targetDir, normalizedPath);
+
+		// Ensure directory exists
+		await mkdir(dirname(fullPath), { recursive: true });
+
+		// Write file
+		await writeFile(fullPath, content);
+		fileCount++;
+	}
+
+	return fileCount;
+}