@getjack/jack 0.1.16 → 0.1.19

package/src/lib/project-operations.ts

@@ -14,7 +14,7 @@ import {
 	renderTemplate,
 	resolveTemplateWithOrigin,
 } from "../templates/index.ts";
-import type { Template } from "../templates/types.ts";
+import type { EnvVar, Template } from "../templates/types.ts";
 import { generateAgentFiles } from "./agent-files.ts";
 import {
 	getActiveAgents,
@@ -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";
 
 // ============================================================================
@@ -168,6 +167,129 @@ const noopReporter: OperationReporter = {
 	box() {},
 };
 
+/**
+ * Check if an environment variable already exists in a .env file
+ * Returns the existing value if found, null otherwise
+ */
+async function checkEnvVarExists(envPath: string, key: string): Promise<string | null> {
+	if (!existsSync(envPath)) {
+		return null;
+	}
+
+	const content = await Bun.file(envPath).text();
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) {
+			continue;
+		}
+
+		const eqIndex = trimmed.indexOf("=");
+		if (eqIndex === -1) {
+			continue;
+		}
+
+		const lineKey = trimmed.slice(0, eqIndex).trim();
+		if (lineKey === key) {
+			let value = trimmed.slice(eqIndex + 1).trim();
+			// Remove surrounding quotes
+			if (
+				(value.startsWith('"') && value.endsWith('"')) ||
+				(value.startsWith("'") && value.endsWith("'"))
+			) {
+				value = value.slice(1, -1);
+			}
+			return value;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Prompt for environment variables defined in a template
+ * Returns a record of env var name -> value for vars that were provided
+ */
+async function promptEnvVars(
+	envVars: EnvVar[],
+	targetDir: string,
+	reporter: OperationReporter,
+	interactive: boolean,
+): Promise<Record<string, string>> {
+	const result: Record<string, string> = {};
+	const envPath = join(targetDir, ".env");
+
+	for (const envVar of envVars) {
+		// Check if already exists in .env
+		const existingValue = await checkEnvVarExists(envPath, envVar.name);
+		if (existingValue) {
+			reporter.stop();
+			reporter.success(`${envVar.name}: already configured`);
+			reporter.start("Creating project...");
+			result[envVar.name] = existingValue;
+			continue;
+		}
+
+		if (!interactive) {
+			// Non-interactive mode: use default if available, otherwise warn
+			if (envVar.defaultValue !== undefined) {
+				result[envVar.name] = envVar.defaultValue;
+				reporter.stop();
+				reporter.info(`${envVar.name}: using default value`);
+				reporter.start("Creating project...");
+			} else if (envVar.required !== false) {
+				reporter.stop();
+				reporter.warn(`${envVar.name}: required but not set (no default available)`);
+				reporter.start("Creating project...");
+			}
+			continue;
+		}
+
+		// Interactive mode: prompt user
+		reporter.stop();
+		const { isCancel, text } = await import("@clack/prompts");
+
+		console.error("");
+		console.error(`  ${envVar.description}`);
+		if (envVar.setupUrl) {
+			console.error(`  Get it at: ${envVar.setupUrl}`);
+		}
+		if (envVar.example) {
+			console.error(`  Example: ${envVar.example}`);
+		}
+		console.error("");
+
+		const value = await text({
+			message: `${envVar.name}:`,
+			defaultValue: envVar.defaultValue,
+			placeholder: envVar.defaultValue ?? (envVar.example ? `e.g. ${envVar.example}` : undefined),
+		});
+
+		if (isCancel(value)) {
+			// User cancelled - skip this var
+			if (envVar.required !== false) {
+				reporter.warn(`Skipped required env var: ${envVar.name}`);
+			}
+			reporter.start("Creating project...");
+			continue;
+		}
+
+		const trimmedValue = value.trim();
+		if (trimmedValue) {
+			result[envVar.name] = trimmedValue;
+			reporter.success(`Set ${envVar.name}`);
+		} else if (envVar.defaultValue !== undefined) {
+			result[envVar.name] = envVar.defaultValue;
+			reporter.info(`${envVar.name}: using default value`);
+		} else if (envVar.required !== false) {
+			reporter.warn(`Skipped required env var: ${envVar.name}`);
+		}
+
+		reporter.start("Creating project...");
+	}
+
+	return result;
+}
+
 /**
  * Get the wrangler config file path for a project
  * Returns the first found: wrangler.jsonc, wrangler.toml, wrangler.json
@@ -198,9 +320,36 @@ async function runWranglerDeploy(
 	return await $`wrangler deploy ${configArg} ${dryRunArgs}`.cwd(projectPath).nothrow().quiet();
 }
 
+/**
+ * Ensure Cloudflare authentication is in place before BYO operations.
+ * Checks wrangler auth and CLOUDFLARE_API_TOKEN env var.
+ */
+async function ensureCloudflareAuth(
+	interactive: boolean,
+	reporter: OperationReporter,
+): Promise<void> {
+	const { isAuthenticated, ensureAuth } = await import("./wrangler.ts");
+	const cfAuthenticated = await isAuthenticated();
+	const hasApiToken = Boolean(process.env.CLOUDFLARE_API_TOKEN);
+
+	if (!cfAuthenticated && !hasApiToken) {
+		if (interactive) {
+			reporter.info("Cloudflare authentication required");
+			await ensureAuth();
+		} else {
+			throw new JackError(
+				JackErrorCode.AUTH_FAILED,
+				"Not authenticated with Cloudflare",
+				"Run: wrangler login\nOr set CLOUDFLARE_API_TOKEN environment variable",
+			);
+		}
+	}
+}
+
 /**
  * Run bun install and managed project creation in parallel.
  * Handles partial failures with cleanup.
+ * Optionally reports URL early via onRemoteReady callback.
  */
 async function runParallelSetup(
 	targetDir: string,
@@ -208,32 +357,41 @@ async function runParallelSetup(
 	options: {
 		template?: string;
 		usePrebuilt?: boolean;
+		onRemoteReady?: (result: ManagedCreateResult) => void;
 	},
 ): Promise<{
 	installSuccess: boolean;
 	remoteResult: ManagedCreateResult;
 }> {
-	const [installResult, remoteResult] = await Promise.allSettled([
-		// Install dependencies
-		(async () => {
-			const install = Bun.spawn(["bun", "install"], {
-				cwd: targetDir,
-				stdout: "ignore",
-				stderr: "ignore",
-			});
-			await install.exited;
-			if (install.exitCode !== 0) {
-				throw new Error("Dependency installation failed");
+	// Start both operations
+	const installPromise = (async () => {
+		const install = Bun.spawn(["bun", "install", "--prefer-offline"], {
+			cwd: targetDir,
+			stdout: "ignore",
+			stderr: "ignore",
+		});
+		await install.exited;
+		if (install.exitCode !== 0) {
+			throw new Error("Dependency installation failed");
+		}
+		return true;
+	})();
+
+	const remotePromise = createManagedProjectRemote(projectName, undefined, {
+		template: options.template || "hello",
+		usePrebuilt: options.usePrebuilt ?? true,
+	});
+
+	// Report URL as soon as remote is ready (don't wait for install)
+	remotePromise
+		.then((result) => {
+			if (result.status === "live" && options.onRemoteReady) {
+				options.onRemoteReady(result);
 			}
-			return true;
-		})(),
-
-		// Create managed project remote (no reporter to avoid spinner conflicts)
-		createManagedProjectRemote(projectName, undefined, {
-			template: options.template || "hello",
-			usePrebuilt: options.usePrebuilt ?? true,
-		}),
-	]);
+		})
+		.catch(() => {}); // Errors handled below in allSettled
+
+	const [installResult, remoteResult] = await Promise.allSettled([installPromise, remotePromise]);
 
 	const installFailed = installResult.status === "rejected";
 	const remoteFailed = remoteResult.status === "rejected";
@@ -814,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) {
@@ -859,47 +1036,46 @@ 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...");
 		}
 	}
 
+	// Handle environment variables (non-secret configuration)
+	let envVarsToUse: Record<string, string> = {};
+	if (template.envVars?.length) {
+		envVarsToUse = await promptEnvVars(template.envVars, targetDir, reporter, interactive);
+	}
+
 	// Track if we created the directory (for cleanup on failure)
 	let directoryCreated = false;
 
@@ -918,13 +1094,24 @@ export async function createProject(
 		}
 		reporter.start("Creating project...");
 
-		// Write secrets files (.env for Vite, .dev.vars for wrangler local, .secrets.json for wrangler bulk)
-		if (Object.keys(secretsToUse).length > 0) {
-			const envContent = generateEnvFile(secretsToUse);
-			const jsonContent = generateSecretsJson(secretsToUse);
+		// Write secrets and env vars files
+		// - Secrets go to: .env, .dev.vars, .secrets.json (for wrangler bulk upload)
+		// - Env vars go to: .env, .dev.vars only (not secrets.json - they're not secrets)
+		const hasSecrets = Object.keys(secretsToUse).length > 0;
+		const hasEnvVars = Object.keys(envVarsToUse).length > 0;
+
+		if (hasSecrets || hasEnvVars) {
+			// Combine secrets and env vars for .env and .dev.vars
+			const allEnvVars = { ...secretsToUse, ...envVarsToUse };
+			const envContent = generateEnvFile(allEnvVars);
 			await Bun.write(join(targetDir, ".env"), envContent);
 			await Bun.write(join(targetDir, ".dev.vars"), envContent);
-			await Bun.write(join(targetDir, ".secrets.json"), jsonContent);
+
+			// Only write secrets to .secrets.json (for wrangler secret bulk)
+			if (hasSecrets) {
+				const jsonContent = generateSecretsJson(secretsToUse);
+				await Bun.write(join(targetDir, ".secrets.json"), jsonContent);
+			}
 
 			const gitignorePath = join(targetDir, ".gitignore");
 			const gitignoreExists = existsSync(gitignorePath);
@@ -970,6 +1157,7 @@ export async function createProject(
 
 		// Parallel setup for managed mode: install + remote creation
 		let remoteResult: ManagedCreateResult | undefined;
+		let urlShownEarly = false;
 
 		if (deployMode === "managed") {
 			// Run install and remote creation in parallel
@@ -980,11 +1168,22 @@ export async function createProject(
 				const result = await runParallelSetup(targetDir, projectName, {
 					template: resolvedTemplate || "hello",
 					usePrebuilt: templateOrigin.type === "builtin", // Only builtin templates have prebuilt bundles
+					onRemoteReady: (remote) => {
+						// Show URL immediately when prebuilt succeeds
+						reporter.stop();
+						reporter.success(`Live: ${remote.runjackUrl}`);
+						reporter.start("Installing dependencies locally...");
+						urlShownEarly = true;
+					},
 				});
 				remoteResult = result.remoteResult;
 				timings.push({ label: "Parallel setup", duration: timerEnd("parallel-setup") });
 				reporter.stop();
-				reporter.success("Project setup complete");
+				if (urlShownEarly) {
+					reporter.success("Ready for local development");
+				} else {
+					reporter.success("Project setup complete");
+				}
 			} catch (err) {
 				timerEnd("parallel-setup");
 				reporter.stop();
@@ -995,11 +1194,11 @@ export async function createProject(
 				throw err;
 			}
 		} else {
-			// BYO mode: just install dependencies (unchanged from current)
+			// BYO mode: just install dependencies
 			timerStart("bun-install");
 			reporter.start("Installing dependencies...");
 
-			const install = Bun.spawn(["bun", "install"], {
+			const install = Bun.spawn(["bun", "install", "--prefer-offline"], {
 				cwd: targetDir,
 				stdout: "ignore",
 				stderr: "ignore",
@@ -1109,6 +1308,7 @@ export async function createProject(
 				await writeTemplateMetadata(targetDir, templateOrigin);
 				await registerPath(remoteResult.projectId, targetDir);
 			} catch (err) {
+				reporter.warn("Could not save project link (deploy still works)");
 				debug("Failed to link managed project:", err);
 			}
 
@@ -1116,7 +1316,27 @@ export async function createProject(
 			if (remoteResult.status === "live") {
 				// Prebuilt succeeded - skip the fresh build
 				workerUrl = remoteResult.runjackUrl;
-				reporter.success(`Deployed: ${workerUrl}`);
+				// Only show if not already shown by parallel setup
+				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) {
@@ -1226,6 +1446,7 @@ export async function createProject(
 				await writeTemplateMetadata(targetDir, templateOrigin);
 				await registerPath(byoProjectId, targetDir);
 			} catch (err) {
+				reporter.warn("Could not save project link (deploy still works)");
 				debug("Failed to link BYO project:", err);
 			}
 		}
@@ -1249,7 +1470,7 @@ export async function createProject(
 
 			// Show final celebration if there were interactive prompts (URL might have scrolled away)
 			if (hookResult.hadInteractiveActions && reporter.celebrate) {
-				reporter.celebrate("You're live!", [domain]);
+				reporter.celebrate("You're live!", [workerUrl]);
 			}
 		}
 
@@ -1327,6 +1548,57 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 			"No wrangler config found in current directory",
 			"Run: jack new <project-name>",
 		);
+	} else if (hasWranglerConfig && !hasProjectLink) {
+		// Orphaned state: wrangler config exists but no project link
+		// This happens when: linking failed during jack new, user has existing wrangler project,
+		// or project was moved/copied without .jack directory
+		const { isLoggedIn } = await import("./auth/store.ts");
+		const loggedIn = await isLoggedIn();
+
+		if (loggedIn && !options.byo) {
+			// User is logged into Jack Cloud - create managed project
+			const orphanedProjectName = await getProjectNameFromDir(projectPath);
+
+			reporter.info(`Linking "${orphanedProjectName}" to jack cloud...`);
+
+			// Get username for URL construction
+			const { getCurrentUserProfile } = await import("./control-plane.ts");
+			const profile = await getCurrentUserProfile();
+			const ownerUsername = profile?.username ?? undefined;
+
+			// Create managed project on jack cloud
+			const remoteResult = await createManagedProjectRemote(orphanedProjectName, reporter, {
+				usePrebuilt: false,
+			});
+
+			// Link project locally
+			await linkProject(projectPath, remoteResult.projectId, "managed", ownerUsername);
+			await registerPath(remoteResult.projectId, projectPath);
+
+			// Set autoDetectResult so the rest of the flow uses managed mode
+			autoDetectResult = {
+				projectName: orphanedProjectName,
+				projectId: remoteResult.projectId,
+				deployMode: "managed",
+			};
+
+			reporter.success("Linked to jack cloud");
+		} else if (!options.managed) {
+			// BYO path - ensure wrangler auth before proceeding
+			await ensureCloudflareAuth(interactive, reporter);
+
+			// Create BYO link for tracking (non-blocking)
+			const orphanedProjectName = await getProjectNameFromDir(projectPath);
+			const byoProjectId = generateByoProjectId();
+
+			try {
+				await linkProject(projectPath, byoProjectId, "byo");
+				await registerPath(byoProjectId, projectPath);
+				debug("Created BYO project link for orphaned project");
+			} catch (err) {
+				debug("Failed to create BYO project link:", err);
+			}
+		}
 	}
 
 	// Get project name from directory (or auto-detect result)
@@ -1475,6 +1747,9 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 			}
 		}
 
+		// Ensure Cloudflare auth before BYO deploy
+		await ensureCloudflareAuth(interactive, reporter);
+
 		const spin = reporter.spinner("Deploying...");
 		const result = await runWranglerDeploy(projectPath);
 
@@ -1522,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 {
@@ -1689,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> {
@@ -1698,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
 			}
 		}
 	}