@getjack/jack 0.1.16 → 0.1.17

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,
@@ -168,6 +168,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 +321,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 +358,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";
@@ -900,6 +1059,12 @@ export async function createProject(
 		}
 	}
 
+	// 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 +1083,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 +1146,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 +1157,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 +1183,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 +1297,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 +1305,10 @@ 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}`);
+				}
 			} else {
 				// Prebuilt not available - fall back to fresh build
 				if (remoteResult.prebuiltFailed) {
@@ -1226,6 +1418,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 +1442,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 +1520,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 +1719,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);