@getjack/jack 0.1.4 → 0.1.6

package/src/lib/project-operations.ts

@@ -23,27 +23,33 @@ import {
 	runAgentOneShot,
 	validateAgentPaths,
 } from "./agents.ts";
-import { needsViteBuild, runViteBuild } from "./build-helper.ts";
+import { ensureR2Buckets, needsOpenNextBuild, needsViteBuild, runOpenNextBuild, runViteBuild } from "./build-helper.ts";
 import { checkWorkerExists, getAccountId, listD1Databases } from "./cloudflare-api.ts";
 import { getSyncConfig } from "./config.ts";
+import { deleteManagedProject } from "./control-plane.ts";
 import { debug, isDebug } from "./debug.ts";
 import { resolveDeployMode, validateModeAvailability } from "./deploy-mode.ts";
 import { detectSecrets, generateEnvFile, generateSecretsJson } from "./env-parser.ts";
 import { JackError, JackErrorCode } from "./errors.ts";
 import { type HookOutput, runHook } from "./hooks.ts";
 import { loadTemplateKeywords, matchTemplateByIntent } from "./intent.ts";
-import { registerLocalPath } from "./local-paths.ts";
-import { createManagedProjectRemote, deployToManagedProject } from "./managed-deploy.ts";
+import {
+	type ManagedCreateResult,
+	createManagedProjectRemote,
+	deployToManagedProject,
+} from "./managed-deploy.ts";
 import { generateProjectName } from "./names.ts";
-import { filterNewSecrets, promptSaveSecrets } from "./prompts.ts";
-import type { DeployMode, TemplateOrigin } from "./registry.ts";
+import { getAllPaths, registerPath, unregisterPath } from "./paths-index.ts";
 import {
-	getAllProjects,
-	getProject,
-	registerProject,
-	removeProject,
-	updateProject,
-} from "./registry.ts";
+	type DeployMode,
+	type TemplateMetadata as TemplateOrigin,
+	generateByoProjectId,
+	linkProject,
+	readProjectLink,
+	unlinkProject,
+	writeTemplateMetadata,
+} from "./project-link.ts";
+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";
@@ -146,6 +152,90 @@ const noopReporter: OperationReporter = {
 	box() {},
 };
 
+/**
+ * Run bun install and managed project creation in parallel.
+ * Handles partial failures with cleanup.
+ */
+async function runParallelSetup(
+	targetDir: string,
+	projectName: string,
+	options: {
+		template?: string;
+		usePrebuilt?: boolean;
+	},
+): 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");
+			}
+			return true;
+		})(),
+
+		// Create managed project remote (no reporter to avoid spinner conflicts)
+		createManagedProjectRemote(projectName, undefined, {
+			template: options.template || "hello",
+			usePrebuilt: options.usePrebuilt ?? true,
+		}),
+	]);
+
+	const installFailed = installResult.status === "rejected";
+	const remoteFailed = remoteResult.status === "rejected";
+
+	// Handle partial failures
+	if (installFailed && remoteResult.status === "fulfilled") {
+		// Install failed but remote succeeded - cleanup orphan cloud project
+		const remote = remoteResult.value;
+		try {
+			await deleteManagedProject(remote.projectId);
+			debug("Cleaned up orphan cloud project:", remote.projectId);
+		} catch (cleanupErr) {
+			debug("Failed to cleanup orphan cloud project:", cleanupErr);
+		}
+		throw new JackError(
+			JackErrorCode.BUILD_FAILED,
+			"Dependency installation failed",
+			"Run: bun install",
+		);
+	}
+
+	if (!installFailed && remoteResult.status === "rejected") {
+		// Remote failed but install succeeded - throw remote error
+		const error = remoteResult.reason;
+		throw error instanceof Error ? error : new Error(String(error));
+	}
+
+	if (installFailed && remoteFailed) {
+		// Both failed - prioritize install error (more actionable)
+		throw new JackError(
+			JackErrorCode.BUILD_FAILED,
+			"Dependency installation failed",
+			"Run: bun install",
+		);
+	}
+
+	// Both succeeded - TypeScript knows remoteResult.status === "fulfilled" here
+	if (remoteResult.status !== "fulfilled") {
+		// Should never happen, but satisfies TypeScript
+		throw new Error("Unexpected state: remote result not fulfilled");
+	}
+
+	return {
+		installSuccess: true,
+		remoteResult: remoteResult.value,
+	};
+}
+
 const DEFAULT_D1_LIMIT = 10;
 
 async function preflightD1Capacity(
@@ -291,24 +381,9 @@ export async function createProject(
 					const choice = await promptSelect(["Link existing project", "Choose different name"]);
 
 					if (choice === 0) {
-						// User chose to link - cache in registry and proceed
-						await registerProject(projectName, {
-							workerUrl: existingProject.url || null,
-							createdAt: existingProject.createdAt,
-							lastDeployed: existingProject.updatedAt || null,
-							status: existingProject.status === "live" ? "live" : "build_failed",
-							deploy_mode: "managed",
-							remote: existingProject.remote
-								? {
-										project_id: existingProject.remote.projectId,
-										project_slug: existingProject.slug,
-										org_id: existingProject.remote.orgId,
-										runjack_url:
-											existingProject.url || `https://${existingProject.slug}.runjack.xyz`,
-									}
-								: undefined,
-						});
-						reporter.success(`Linked to existing project: ${existingProject.url || projectName}`);
+						// User chose to link - proceed with project creation
+						// The project will be linked locally when files are created
+						reporter.success(`Linking to existing project: ${existingProject.url || projectName}`);
 						// Continue with project creation - user wants to link
 					} else {
 						// User chose different name
@@ -570,15 +645,8 @@ export async function createProject(
 		const validation = await validateAgentPaths();
 
 		if (validation.invalid.length > 0) {
-			reporter.stop();
-			reporter.warn("Some agent paths no longer exist:");
-			for (const { id, path } of validation.invalid) {
-				reporter.info(`  ${id}: ${path}`);
-			}
-			reporter.info("Run: jack agents scan");
-			reporter.start("Creating project...");
-
-			// Filter out invalid agents
+			// Silently filter out agents with missing paths
+			// User can run 'jack agents scan' to see/fix agent config
 			activeAgents = activeAgents.filter(
 				({ id }) => !validation.invalid.some((inv) => inv.id === id),
 			);
@@ -596,30 +664,55 @@ export async function createProject(
 	reporter.stop();
 	reporter.success(`Created ${projectName}/`);
 
-	// Auto-install dependencies
-	reporter.start("Installing dependencies...");
+	// Parallel setup for managed mode: install + remote creation
+	let remoteResult: ManagedCreateResult | undefined;
 
-	const install = Bun.spawn(["bun", "install"], {
-		cwd: targetDir,
-		stdout: "ignore",
-		stderr: "ignore",
-	});
-	await install.exited;
+	if (deployMode === "managed") {
+		// Run install and remote creation in parallel
+		reporter.start("Setting up project...");
+
+		try {
+			const result = await runParallelSetup(targetDir, projectName, {
+				template: resolvedTemplate || "hello",
+				usePrebuilt: true,
+			});
+			remoteResult = result.remoteResult;
+			reporter.stop();
+			reporter.success("Project setup complete");
+		} catch (err) {
+			reporter.stop();
+			if (err instanceof JackError) {
+				reporter.warn(err.suggestion ?? err.message);
+				throw err;
+			}
+			throw err;
+		}
+	} else {
+		// BYO mode: just install dependencies (unchanged from current)
+		reporter.start("Installing dependencies...");
+
+		const install = Bun.spawn(["bun", "install"], {
+			cwd: targetDir,
+			stdout: "ignore",
+			stderr: "ignore",
+		});
+		await install.exited;
+
+		if (install.exitCode !== 0) {
+			reporter.stop();
+			reporter.warn("Failed to install dependencies, run: bun install");
+			throw new JackError(
+				JackErrorCode.BUILD_FAILED,
+				"Dependency installation failed",
+				"Run: bun install",
+				{ exitCode: 0, reported: hasReporter },
+			);
+		}
 
-	if (install.exitCode !== 0) {
 		reporter.stop();
-		reporter.warn("Failed to install dependencies, run: bun install");
-		throw new JackError(
-			JackErrorCode.BUILD_FAILED,
-			"Dependency installation failed",
-			"Run: bun install",
-			{ exitCode: 0, reported: hasReporter },
-		);
+		reporter.success("Dependencies installed");
 	}
 
-	reporter.stop();
-	reporter.success("Dependencies installed");
-
 	// Run pre-deploy hooks
 	if (template.hooks?.preDeploy?.length) {
 		const hookContext = { projectName, projectDir: targetDir };
@@ -685,30 +778,22 @@ export async function createProject(
 
 	// Deploy based on mode
 	if (deployMode === "managed") {
-		// Managed mode: create project and deploy via jack cloud
-		const remoteResult = await createManagedProjectRemote(projectName, reporter, {
-			template: resolvedTemplate || "hello",
-			usePrebuilt: true,
-		});
+		// Managed mode: remote was already created in parallel setup
+		if (!remoteResult) {
+			throw new JackError(
+				JackErrorCode.VALIDATION_ERROR,
+				"Managed project was not created",
+				"This is an internal error - please report it",
+			);
+		}
 
-		// Register project as soon as remote is created
+		// Link project locally and register path
 		try {
-			await registerProject(projectName, {
-				workerUrl: remoteResult.runjackUrl,
-				createdAt: new Date().toISOString(),
-				lastDeployed: remoteResult.status === "live" ? new Date().toISOString() : null,
-				status: remoteResult.status === "live" ? "live" : "created",
-				template: templateOrigin,
-				deploy_mode: "managed",
-				remote: {
-					project_id: remoteResult.projectId,
-					project_slug: remoteResult.projectSlug,
-					org_id: remoteResult.orgId,
-					runjack_url: remoteResult.runjackUrl,
-				},
-			});
+			await linkProject(targetDir, remoteResult.projectId, "managed");
+			await writeTemplateMetadata(targetDir, templateOrigin);
+			await registerPath(remoteResult.projectId, targetDir);
 		} catch (err) {
-			debug("Failed to register managed project:", err);
+			debug("Failed to link managed project:", err);
 		}
 
 		// Check if prebuilt deployment succeeded
@@ -725,38 +810,26 @@ export async function createProject(
 				reporter.info("Pre-built not available, building fresh...");
 			}
 
-			try {
-				await deployToManagedProject(remoteResult.projectId, targetDir, reporter);
-			} catch (err) {
-				try {
-					await updateProject(projectName, {
-						status: "build_failed",
-						workerUrl: remoteResult.runjackUrl,
-					});
-				} catch (updateErr) {
-					debug("Failed to update managed project status:", updateErr);
-				}
-				throw err;
-			}
+			await deployToManagedProject(remoteResult.projectId, targetDir, reporter);
 			workerUrl = remoteResult.runjackUrl;
 			reporter.success(`Created: ${workerUrl}`);
-
-			// Update project status to live after successful fresh build
-			try {
-				await updateProject(projectName, {
-					lastDeployed: new Date().toISOString(),
-					status: "live",
-				});
-			} catch (err) {
-				// Log but don't fail - registry is convenience, not critical path
-				debug("Failed to update managed project status:", err);
-			}
 		}
 	} else {
 		// BYO mode: deploy via wrangler
 
-		// Build first if needed (wrangler needs dist/ for assets)
-		if (await needsViteBuild(targetDir)) {
+		// Build first if needed (wrangler needs built assets)
+		if (await needsOpenNextBuild(targetDir)) {
+			reporter.start("Building...");
+			try {
+				await runOpenNextBuild(targetDir);
+				reporter.stop();
+				reporter.success("Built");
+			} catch (err) {
+				reporter.stop();
+				reporter.error("Build failed");
+				throw err;
+			}
+		} else if (await needsViteBuild(targetDir)) {
 			reporter.start("Building...");
 			try {
 				await runViteBuild(targetDir);
@@ -828,23 +901,16 @@ export async function createProject(
 			reporter.success("Deployed");
 		}
 
-		// Register project with BYO mode
+		// Generate BYO project ID and link locally
+		const byoProjectId = generateByoProjectId();
+
+		// Link project locally and register path
 		try {
-			const accountId = await getAccountId();
-
-			await registerProject(projectName, {
-				workerUrl,
-				createdAt: new Date().toISOString(),
-				lastDeployed: workerUrl ? new Date().toISOString() : null,
-				cloudflare: {
-					accountId,
-					workerId: projectName,
-				},
-				template: templateOrigin,
-				deploy_mode: "byo",
-			});
-		} catch {
-			// Don't fail the creation if registry update fails
+			await linkProject(targetDir, byoProjectId, "byo");
+			await writeTemplateMetadata(targetDir, templateOrigin);
+			await registerPath(byoProjectId, targetDir);
+		} catch (err) {
+			debug("Failed to link BYO project:", err);
 		}
 	}
 
@@ -863,13 +929,6 @@ export async function createProject(
 		);
 	}
 
-	// Auto-register local path for project discovery
-	try {
-		await registerLocalPath(projectName, targetDir);
-	} catch {
-		// Silent fail - registration is best-effort
-	}
-
 	return {
 		projectName,
 		targetDir,
@@ -926,8 +985,8 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 	// Get project name from directory
 	const projectName = await getProjectNameFromDir(projectPath);
 
-	// Get project from registry to check stored mode
-	const project = await getProject(projectName);
+	// Read local project link for stored mode and project ID
+	const link = await readProjectLink(projectPath);
 
 	// Determine effective mode: explicit flag > stored mode > default BYO
 	let deployMode: DeployMode;
@@ -936,7 +995,7 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 	} else if (options.byo) {
 		deployMode = "byo";
 	} else {
-		deployMode = project?.deploy_mode ?? "byo";
+		deployMode = link?.deploy_mode ?? "byo";
 	}
 
 	// Validate mode availability
@@ -951,7 +1010,7 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 	// Deploy based on mode
 	if (deployMode === "managed") {
 		// Managed mode: deploy via jack cloud
-		if (!project?.remote?.project_id) {
+		if (!link?.project_id || link.deploy_mode !== "managed") {
 			throw new JackError(
 				JackErrorCode.VALIDATION_ERROR,
 				"Project not linked to jack cloud",
@@ -960,19 +1019,24 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		}
 
 		// deployToManagedProject now handles both template and code deploy
-		const result = await deployToManagedProject(project.remote.project_id, projectPath, reporter);
-
-		workerUrl = project.remote.runjack_url;
+		await deployToManagedProject(link.project_id, projectPath, reporter);
 
-		// Update lastDeployed in registry (will be persisted below)
-		if (project) {
-			project.lastDeployed = new Date().toISOString();
-		}
+		// Get the URL from the resolver or construct it
+		workerUrl = `https://${projectName}.runjack.xyz`;
 	} else {
 		// BYO mode: deploy via wrangler
 
-		// Build first if needed (wrangler needs dist/ for assets)
-		if (await needsViteBuild(projectPath)) {
+		// Build first if needed (wrangler needs built assets)
+		if (await needsOpenNextBuild(projectPath)) {
+			const buildSpin = reporter.spinner("Building...");
+			try {
+				await runOpenNextBuild(projectPath);
+				buildSpin.success("Built");
+			} catch (err) {
+				buildSpin.error("Build failed");
+				throw err;
+			}
+		} else if (await needsViteBuild(projectPath)) {
 			const buildSpin = reporter.spinner("Building...");
 			try {
 				await runViteBuild(projectPath);
@@ -983,6 +1047,17 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 			}
 		}
 
+		// Ensure R2 buckets exist before deploying (omakase - auto-provision)
+		try {
+			const buckets = await ensureR2Buckets(projectPath);
+			if (buckets.length > 0) {
+				reporter.info(`R2 buckets ready: ${buckets.join(", ")}`);
+			}
+		} catch (err) {
+			// Non-fatal: let wrangler deploy fail with a clearer error if bucket is missing
+			debug("R2 preflight failed:", err);
+		}
+
 		const spin = reporter.spinner("Deploying...");
 		const result = await $`wrangler deploy`.cwd(projectPath).nothrow().quiet();
 
@@ -1021,16 +1096,6 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		}
 	}
 
-	// Update registry
-	try {
-		await registerProject(projectName, {
-			workerUrl,
-			lastDeployed: new Date().toISOString(),
-		});
-	} catch {
-		// Don't fail the deploy if registry update fails
-	}
-
 	if (includeSecrets && interactive) {
 		const detected = await detectSecrets(projectPath);
 		const newSecrets = await filterNewSecrets(detected);
@@ -1063,9 +1128,24 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		}
 	}
 
-	// Auto-register local path for project discovery
+	// Ensure project is linked locally for discovery
 	try {
-		await registerLocalPath(projectName, projectPath);
+		const existingLink = await readProjectLink(projectPath);
+		if (!existingLink) {
+			// Not linked yet - create link
+			if (deployMode === "managed" && link?.project_id) {
+				await linkProject(projectPath, link.project_id, "managed");
+				await registerPath(link.project_id, projectPath);
+			} else {
+				// BYO mode - generate new ID
+				const byoProjectId = generateByoProjectId();
+				await linkProject(projectPath, byoProjectId, "byo");
+				await registerPath(byoProjectId, projectPath);
+			}
+		} else {
+			// Already linked - just ensure path is registered
+			await registerPath(existingLink.project_id, projectPath);
+		}
 	} catch {
 		// Silent fail - registration is best-effort
 	}
@@ -1108,11 +1188,8 @@ export async function getProjectStatus(
 		}
 	}
 
-	const project = await getProject(projectName);
-
-	if (!project) {
-		return null;
-	}
+	// Read local project link
+	const link = await readProjectLink(resolvedPath);
 
 	// Check if local project exists at the resolved path
 	const hasWranglerConfig =
@@ -1122,6 +1199,11 @@ export async function getProjectStatus(
 	const localExists = hasWranglerConfig;
 	const localPath = localExists ? resolvedPath : null;
 
+	// If no link and no local project, return null
+	if (!link && !localExists) {
+		return null;
+	}
+
 	// Check actual deployment status
 	const [workerExists, manifest] = await Promise.all([
 		checkWorkerExists(projectName),
@@ -1131,13 +1213,19 @@ export async function getProjectStatus(
 	const backupFiles = manifest ? manifest.files.length : null;
 	const backupLastSync = manifest ? manifest.lastSync : null;
 
+	// Determine URL based on mode
+	let workerUrl: string | null = null;
+	if (link?.deploy_mode === "managed") {
+		workerUrl = `https://${projectName}.runjack.xyz`;
+	}
+
 	// Get database name on-demand
 	let dbName: string | null = null;
-	if (project.deploy_mode === "managed" && project.remote?.project_id) {
+	if (link?.deploy_mode === "managed") {
 		// For managed projects, fetch from control plane
 		try {
 			const { fetchProjectResources } = await import("./control-plane.ts");
-			const resources = await fetchProjectResources(project.remote.project_id);
+			const resources = await fetchProjectResources(link.project_id);
 			const d1 = resources.find((r) => r.resource_type === "d1");
 			dbName = d1?.resource_name || null;
 		} catch {
@@ -1157,16 +1245,16 @@ export async function getProjectStatus(
 	return {
 		name: projectName,
 		localPath,
-		workerUrl: project.workerUrl,
-		lastDeployed: project.lastDeployed,
-		createdAt: project.createdAt,
-		accountId: project.cloudflare?.accountId ?? null,
-		workerId: project.cloudflare?.workerId ?? null,
+		workerUrl,
+		lastDeployed: link?.linked_at ?? null,
+		createdAt: link?.linked_at ?? null,
+		accountId: null, // No longer stored in registry
+		workerId: projectName,
 		dbName,
-		deployed: workerExists || !!project.workerUrl,
+		deployed: workerExists || !!workerUrl,
 		local: localExists,
 		backedUp,
-		missing: false, // No longer tracking local paths in registry
+		missing: false,
 		backupFiles,
 		backupLastSync,
 	};
@@ -1177,44 +1265,77 @@ export async function getProjectStatus(
 // ============================================================================
 
 /**
- * Scan registry for stale projects.
- * Checks for projects with worker URLs that no longer have deployed workers.
+ * Scan for stale project paths.
+ * Checks for paths in the index that no longer exist on disk or don't have valid links.
  * Returns total project count and stale entries with reasons.
  */
 export async function scanStaleProjects(): Promise<StaleProjectScan> {
-	const projects = await getAllProjects();
-	const projectNames = Object.keys(projects);
+	const allPaths = await getAllPaths();
+	const projectIds = Object.keys(allPaths);
 	const stale: StaleProject[] = [];
+	let totalPaths = 0;
+
+	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
+			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
+				}
 
-	for (const name of projectNames) {
-		const project = projects[name];
-		if (!project) continue;
-
-		// Check if worker URL is set but worker doesn't exist
-		if (project.workerUrl) {
-			const workerExists = await checkWorkerExists(name);
-			if (!workerExists) {
 				stale.push({
 					name,
 					reason: "worker not deployed",
-					workerUrl: project.workerUrl,
+					workerUrl: null,
 				});
 			}
 		}
 	}
 
-	return { total: projectNames.length, stale };
+	return { total: totalPaths, stale };
 }
 
 /**
- * Remove stale registry entries by name
+ * Remove stale project entries by path
+ * Unlinks and unregisters projects.
  * Returns the number of entries removed.
  */
 export async function cleanupStaleProjects(names: string[]): Promise<number> {
 	let removed = 0;
+
+	// Get all paths to find matching projects
+	const allPaths = await getAllPaths();
+
 	for (const name of names) {
-		await removeProject(name);
-		removed += 1;
+		// Find project ID by checking each path
+		for (const [projectId, paths] of Object.entries(allPaths)) {
+			for (const projectPath of paths || []) {
+				const pathName = projectPath.split("/").pop();
+				if (pathName === name) {
+					// Unlink and unregister
+					try {
+						await unlinkProject(projectPath);
+					} catch {
+						// Path may not exist
+					}
+					await unregisterPath(projectId, projectPath);
+					removed += 1;
+				}
+			}
+		}
 	}
+
 	return removed;
 }