@getjack/jack 0.1.19 → 0.1.22

package/src/lib/managed-down.ts

@@ -5,7 +5,11 @@
 
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { deleteManagedProject, exportManagedDatabase } from "./control-plane.ts";
+import {
+	deleteManagedProject,
+	exportManagedDatabase,
+	fetchProjectResources,
+} from "./control-plane.ts";
 import { promptSelect } from "./hooks.ts";
 import { error, info, item, output, success, warn } from "./output.ts";
 
@@ -47,14 +51,29 @@ export async function managedDown(
 		}
 	}
 
-	// Interactive mode
+	// Interactive mode - fetch actual resources
+	let hasDatabase = false;
+	let databaseName: string | null = null;
+	try {
+		const resources = await fetchProjectResources(projectId);
+		const d1Resource = resources.find((r) => r.resource_type === "d1");
+		if (d1Resource) {
+			hasDatabase = true;
+			databaseName = d1Resource.resource_name;
+		}
+	} catch {
+		// If fetch fails, assume no database (safer than showing wrong info)
+	}
+
 	console.error("");
 	info(`Project: ${projectName}`);
 	if (runjackUrl) {
 		item(`URL: ${runjackUrl}`);
 	}
 	item("Mode: jack cloud (managed)");
-	item("Database: managed D1");
+	if (hasDatabase) {
+		item(`Database: ${databaseName ?? "managed D1"}`);
+	}
 	console.error("");
 
 	// Confirm undeploy
@@ -67,49 +86,51 @@ export async function managedDown(
 		return false;
 	}
 
-	// Ask about database export
-	console.error("");
-	info("Database will be deleted with the project");
-
-	console.error("");
-	info("Export database before deleting?");
-	const exportAction = await promptSelect(["Yes", "No"]);
-
-	if (exportAction === 0) {
-		const exportPath = join(process.cwd(), `${projectName}-backup.sql`);
-		output.start(`Exporting database to ${exportPath}...`);
-
-		try {
-			const exportResult = await exportManagedDatabase(projectId);
-
-			// Download the SQL file
-			const response = await fetch(exportResult.download_url);
-			if (!response.ok) {
-				throw new Error(`Failed to download export: ${response.statusText}`);
-			}
-
-			const sqlContent = await response.text();
-			await writeFile(exportPath, sqlContent, "utf-8");
-
-			output.stop();
-			success(`Database exported to ${exportPath}`);
-		} catch (err) {
-			output.stop();
-			error(`Failed to export database: ${err instanceof Error ? err.message : String(err)}`);
-
-			// If export times out, abort
-			if (err instanceof Error && err.message.includes("timed out")) {
-				error("Export timeout - deletion aborted");
-				return false;
-			}
-
-			console.error("");
-			info("Continue without exporting?");
-			const continueAction = await promptSelect(["Yes", "No"]);
+	// Ask about database export (only if database exists)
+	if (hasDatabase) {
+		console.error("");
+		info("Database will be deleted with the project");
 
-			if (continueAction !== 0) {
-				info("Cancelled");
-				return false;
+		console.error("");
+		info("Export database before deleting?");
+		const exportAction = await promptSelect(["Yes", "No"]);
+
+		if (exportAction === 0) {
+			const exportPath = join(process.cwd(), `${projectName}-backup.sql`);
+			output.start(`Exporting database to ${exportPath}...`);
+
+			try {
+				const exportResult = await exportManagedDatabase(projectId);
+
+				// Download the SQL file
+				const response = await fetch(exportResult.download_url);
+				if (!response.ok) {
+					throw new Error(`Failed to download export: ${response.statusText}`);
+				}
+
+				const sqlContent = await response.text();
+				await writeFile(exportPath, sqlContent, "utf-8");
+
+				output.stop();
+				success(`Database exported to ${exportPath}`);
+			} catch (err) {
+				output.stop();
+				error(`Failed to export database: ${err instanceof Error ? err.message : String(err)}`);
+
+				// If export times out, abort
+				if (err instanceof Error && err.message.includes("timed out")) {
+					error("Export timeout - deletion aborted");
+					return false;
+				}
+
+				console.error("");
+				info("Continue without exporting?");
+				const continueAction = await promptSelect(["Yes", "No"]);
+
+				if (continueAction !== 0) {
+					info("Cancelled");
+					return false;
+				}
 			}
 		}
 	}

package/src/lib/progress.ts

@@ -38,6 +38,7 @@ const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "
 export function createProgressTracker(options: ProgressOptions) {
 	const { total, delayMs = 2000, barWidth = 25, label = "Uploading" } = options;
 	const startTime = Date.now();
+	const purple = getRandomPurple(); // Pick color once at start
 	let frame = 0;
 	let intervalId: Timer | null = null;
 	let current = 0;
@@ -55,7 +56,6 @@ export function createProgressTracker(options: ProgressOptions) {
 			);
 		} 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);
@@ -69,7 +69,7 @@ export function createProgressTracker(options: ProgressOptions) {
 	return {
 		start() {
 			render();
-			intervalId = setInterval(render, 80);
+			intervalId = setInterval(render, 150);
 		},
 
 		update(bytes: number) {
@@ -96,6 +96,7 @@ export function createProgressTracker(options: ProgressOptions) {
 export function createUploadProgress(options: UploadProgressOptions) {
 	const { totalSize, delayMs = 2000, barWidth = 25, label = "Uploading" } = options;
 	const startTime = Date.now();
+	const purple = getRandomPurple(); // Pick color once at start
 	let frame = 0;
 	let pulsePos = 0;
 	let intervalId: Timer | null = null;
@@ -113,8 +114,6 @@ export function createUploadProgress(options: UploadProgressOptions) {
 			);
 		} 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);
@@ -139,10 +138,82 @@ export function createUploadProgress(options: UploadProgressOptions) {
 		start() {
 			if (process.stderr.isTTY) {
 				render();
-				intervalId = setInterval(render, 80);
+				intervalId = setInterval(render, 150);
+			}
+		},
+
+		complete() {
+			if (intervalId) {
+				clearInterval(intervalId);
+				intervalId = null;
+			}
+			clearLine();
+		},
+	};
+}
+
+export interface FileCountProgressOptions {
+	delayMs?: number;
+	barWidth?: number;
+	label?: string;
+}
+
+/**
+ * Creates a file-count progress indicator for operations where we know
+ * the total file count and can track per-file progress.
+ *
+ * Shows spinner first, then after delay shows progress bar with file count.
+ */
+export function createFileCountProgress(options: FileCountProgressOptions = {}) {
+	const { delayMs = 2000, barWidth = 25, label = "Packaging" } = options;
+	const startTime = Date.now();
+	const purple = getRandomPurple(); // Pick color once at start
+	let frame = 0;
+	let intervalId: Timer | null = null;
+	let current = 0;
+	let total = 0;
+
+	function render() {
+		const elapsed = Date.now() - startTime;
+
+		clearLine();
+
+		if (elapsed < delayMs) {
+			// Just spinner for first N seconds
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label}...`,
+			);
+		} else if (total > 0) {
+			// Show progress bar with file count after delay
+			const pct = Math.min(Math.round((current / total) * 100), 100);
+			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} ${colors.dim}(${current}/${total} files)${colors.reset}`,
+			);
+		} else {
+			// No total yet, just show spinner
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label}...`,
+			);
+		}
+	}
+
+	return {
+		start() {
+			if (process.stderr.isTTY) {
+				render();
+				intervalId = setInterval(render, 150);
 			}
 		},
 
+		update(currentFile: number, totalFiles: number) {
+			current = currentFile;
+			total = totalFiles;
+		},
+
 		complete() {
 			if (intervalId) {
 				clearInterval(intervalId);

package/src/lib/project-list.ts

@@ -338,9 +338,14 @@ export function formatErrorSection(
 	);
 
 	for (const item of items) {
-		lines.push(formatProjectLine(item, { indent: 4, tagColorMap }));
+		// Don't show errorMessage inline - we'll show a summary hint below
+		lines.push(formatProjectLine(item, { indent: 4, tagColorMap, showUrl: false }));
 	}
 
+	// Add hint for resolving errors
+	lines.push("");
+	lines.push(`    ${colors.dim}Run 'jack projects cleanup' to remove stale links${colors.reset}`);
+
 	return lines.join("\n");
 }
 

package/src/lib/project-operations.ts

@@ -363,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,
@@ -371,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)
@@ -434,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,
@@ -811,43 +825,19 @@ export async function createProject(
 			reporter.stop();
 			reporter.success("Name available");
 		} else {
-			// Slug not available - check if it's the user's own project (for linking flow)
+			// Slug not available - check if it's the user's own project
 			const { checkAvailability } = await import("./project-resolver.ts");
 			const { existingProject } = await checkAvailability(projectName);
 			timings.push({ label: "Slug check", duration: timerEnd("slug-check") });
 			reporter.stop();
 
 			if (existingProject?.sources.controlPlane && !existingProject.sources.filesystem) {
-				// It's the user's project on jack cloud but not locally - offer to link
-				if (interactive) {
-					const { promptSelect } = await import("./hooks.ts");
-					console.error("");
-					console.error(`  Project "${projectName}" exists on jack cloud but not locally.`);
-					console.error("");
-
-					const choice = await promptSelect(["Link existing project", "Choose different name"]);
-
-					if (choice === 0) {
-						// User chose to link - proceed with project creation
-						reporter.success(`Linking to existing project: ${existingProject.url || projectName}`);
-						// Continue with project creation - user wants to link
-					} else {
-						// User chose different name
-						throw new JackError(
-							JackErrorCode.VALIDATION_ERROR,
-							`Project "${projectName}" already exists on jack cloud`,
-							`Try a different name: jack new ${projectName}-2`,
-							{ exitCode: 0, reported: true },
-						);
-					}
-				} else {
-					// Non-interactive mode - fail with clear message
-					throw new JackError(
-						JackErrorCode.VALIDATION_ERROR,
-						`Project "${projectName}" already exists on jack cloud`,
-						`Try a different name: jack new ${projectName}-2`,
-					);
-				}
+				// User's project exists on jack cloud but not locally - suggest clone
+				throw new JackError(
+					JackErrorCode.VALIDATION_ERROR,
+					`Project "${projectName}" already exists on jack cloud`,
+					`To download it: jack clone ${projectName}`,
+				);
 			} else if (existingProject) {
 				// Project exists in registry with local path - it's truly taken by user
 				throw new JackError(

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/zip-packager.ts

@@ -48,17 +48,23 @@ export interface ManifestData {
 	};
 }
 
+export interface ZipProgressCallback {
+	(current: number, total: number): void;
+}
+
 /**
  * Creates a ZIP archive from source directory
  * @param outputPath - Absolute path for output ZIP file
  * @param sourceDir - Absolute path to directory to archive
  * @param files - Optional list of specific files to include (relative to sourceDir)
+ * @param onProgress - Optional callback for file-count progress updates
  * @returns Promise that resolves when ZIP is created
  */
 async function createZipArchive(
 	outputPath: string,
 	sourceDir: string,
 	files?: string[],
+	onProgress?: ZipProgressCallback,
 ): Promise<void> {
 	return new Promise((resolve, reject) => {
 		const output = createWriteStream(outputPath);
@@ -70,13 +76,16 @@ async function createZipArchive(
 		archive.pipe(output);
 
 		if (files) {
-			// Add specific files
-			for (const file of files) {
+			// Add specific files with progress tracking
+			const total = files.length;
+			for (let i = 0; i < files.length; i++) {
+				const file = files[i];
 				const filePath = join(sourceDir, file);
 				archive.file(filePath, { name: file });
+				onProgress?.(i + 1, total);
 			}
 		} else {
-			// Add entire directory
+			// Add entire directory (no per-file progress available)
 			archive.directory(sourceDir, false);
 		}
 
@@ -219,18 +228,38 @@ function extractBindingsFromConfig(config?: WranglerConfig): ManifestData["bindi
 	return Object.keys(bindings).length > 0 ? bindings : undefined;
 }
 
+export interface PackageOptions {
+	projectPath: string;
+	buildOutput: BuildOutput;
+	config?: WranglerConfig;
+	onProgress?: ZipProgressCallback;
+}
+
 /**
  * Packages a built project for deployment to jack cloud
- * @param projectPath - Absolute path to project directory
- * @param buildOutput - Build output from buildProject()
- * @param config - Optional wrangler config to extract binding intent
+ * @param options - Package options including paths, build output, config, and optional progress callback
  * @returns Package result with ZIP paths and cleanup function
  */
+export async function packageForDeploy(options: PackageOptions): Promise<ZipPackageResult>;
+/**
+ * @deprecated Use options object instead
+ */
 export async function packageForDeploy(
 	projectPath: string,
 	buildOutput: BuildOutput,
 	config?: WranglerConfig,
+): Promise<ZipPackageResult>;
+export async function packageForDeploy(
+	optionsOrPath: PackageOptions | string,
+	buildOutputArg?: BuildOutput,
+	configArg?: WranglerConfig,
 ): Promise<ZipPackageResult> {
+	// Support both old and new signatures
+	const options: PackageOptions =
+		typeof optionsOrPath === "string"
+			? { projectPath: optionsOrPath, buildOutput: buildOutputArg!, config: configArg }
+			: optionsOrPath;
+	const { projectPath, buildOutput, config, onProgress } = options;
 	// Create temp directory for package artifacts
 	const packageId = `jack-package-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
 	const packageDir = join(tmpdir(), packageId);
@@ -247,7 +276,7 @@ export async function packageForDeploy(
 	// 2. Create source.zip from project files (filtered)
 	const projectFiles = await scanProjectFiles(projectPath);
 	const sourceFiles = projectFiles.map((f) => f.path);
-	await createZipArchive(sourceZipPath, projectPath, sourceFiles);
+	await createZipArchive(sourceZipPath, projectPath, sourceFiles, onProgress);
 
 	// 3. Create manifest.json
 	const manifest: ManifestData = {

package/src/templates/index.ts

@@ -10,7 +10,7 @@ import type { Template } from "./types";
 // Resolve templates directory relative to this file (src/templates -> templates)
 const TEMPLATES_DIR = join(dirname(dirname(import.meta.dir)), "templates");
 
-export const BUILTIN_TEMPLATES = ["hello", "miniapp", "api", "nextjs"];
+export const BUILTIN_TEMPLATES = ["hello", "miniapp", "api", "nextjs", "saas"];
 
 /**
  * Resolved template with origin tracking for lineage

package/src/templates/types.ts

@@ -11,6 +11,7 @@ export type HookAction =
 			message: string;
 			validate?: "json" | "accountAssociation";
 			required?: boolean;
+			secret?: boolean; // Mask input (for sensitive values like API keys)
 			successMessage?: string;
 			writeJson?: {
 				path: string;
@@ -31,9 +32,24 @@ export type HookAction =
 			key: string;
 			message?: string;
 			setupUrl?: string;
+			onMissing?: "fail" | "prompt" | "generate";
+			promptMessage?: string;
+			generateCommand?: string;
+	  }
+	| {
+			action: "stripe-setup";
+			message?: string;
+			plans: Array<{
+				name: string;
+				priceKey: string; // Secret key to store price ID (e.g., "STRIPE_PRO_PRICE_ID")
+				amount: number; // in cents
+				interval: "month" | "year";
+				description?: string;
+			}>;
 	  };
 
 export interface TemplateHooks {
+	preCreate?: HookAction[];
 	preDeploy?: HookAction[];
 	postDeploy?: HookAction[];
 }