@getjack/jack 0.1.2 → 0.1.4

package/src/lib/project-operations.ts

@@ -8,28 +8,46 @@
 import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { $ } from "bun";
-import { renderTemplate, resolveTemplate } from "../templates/index.ts";
+import {
+	BUILTIN_TEMPLATES,
+	type ResolvedTemplate,
+	renderTemplate,
+	resolveTemplateWithOrigin,
+} from "../templates/index.ts";
 import type { Template } from "../templates/types.ts";
 import { generateAgentFiles } from "./agent-files.ts";
-import { getActiveAgents, validateAgentPaths } from "./agents.ts";
-import { getAccountId } from "./cloudflare-api.ts";
-import { checkWorkerExists } from "./cloudflare-api.ts";
+import {
+	getActiveAgents,
+	getAgentDefinition,
+	getOneShotAgent,
+	runAgentOneShot,
+	validateAgentPaths,
+} from "./agents.ts";
+import { needsViteBuild, runViteBuild } from "./build-helper.ts";
+import { checkWorkerExists, getAccountId, listD1Databases } from "./cloudflare-api.ts";
 import { getSyncConfig } from "./config.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 { generateProjectName } from "./names.ts";
 import { filterNewSecrets, promptSaveSecrets } from "./prompts.ts";
+import type { DeployMode, TemplateOrigin } from "./registry.ts";
 import {
 	getAllProjects,
 	getProject,
-	getProjectDatabaseName,
 	registerProject,
 	removeProject,
+	updateProject,
 } from "./registry.ts";
-import { applySchema, getD1DatabaseName, hasD1Config } from "./schema.ts";
-import { getSavedSecrets } from "./secrets.ts";
+import { applySchema, getD1Bindings, getD1DatabaseName, hasD1Config } from "./schema.ts";
+import { getSavedSecrets, saveSecrets } from "./secrets.ts";
 import { getProjectNameFromDir, getRemoteManifest, syncToCloud } from "./storage/index.ts";
+import { Events, track } from "./telemetry.ts";
 
 // ============================================================================
 // Type Definitions
@@ -37,14 +55,18 @@ import { getProjectNameFromDir, getRemoteManifest, syncToCloud } from "./storage
 
 export interface CreateProjectOptions {
 	template?: string;
+	intent?: string;
 	reporter?: OperationReporter;
 	interactive?: boolean;
+	managed?: boolean; // Force managed deploy mode
+	byo?: boolean; // Force BYO deploy mode
 }
 
 export interface CreateProjectResult {
 	projectName: string;
 	targetDir: string;
 	workerUrl: string | null;
+	deployMode: DeployMode; // The deploy mode used
 }
 
 export interface DeployOptions {
@@ -53,12 +75,15 @@ export interface DeployOptions {
 	interactive?: boolean;
 	includeSecrets?: boolean;
 	includeSync?: boolean;
+	managed?: boolean; // Force managed deploy mode
+	byo?: boolean; // Force BYO deploy mode
 }
 
 export interface DeployResult {
 	workerUrl: string | null;
 	projectName: string;
 	deployOutput?: string;
+	deployMode: DeployMode; // The deploy mode used
 }
 
 export interface ProjectStatus {
@@ -80,7 +105,7 @@ export interface ProjectStatus {
 
 export interface StaleProject {
 	name: string;
-	reason: "local folder deleted" | "undeployed from cloud";
+	reason: "worker not deployed";
 	workerUrl: string | null;
 }
 
@@ -93,6 +118,7 @@ export interface OperationSpinner {
 	success(message: string): void;
 	error(message: string): void;
 	stop(): void;
+	text?: string;
 }
 
 export interface OperationReporter extends HookOutput {
@@ -120,6 +146,63 @@ const noopReporter: OperationReporter = {
 	box() {},
 };
 
+const DEFAULT_D1_LIMIT = 10;
+
+async function preflightD1Capacity(
+	projectDir: string,
+	reporter: OperationReporter,
+	interactive: boolean,
+): Promise<void> {
+	const bindings = await getD1Bindings(projectDir);
+	const needsCreate = bindings.some((binding) => !binding.database_id && binding.database_name);
+	if (!needsCreate) {
+		return;
+	}
+
+	let databases: Array<{ name?: string; uuid?: string }>;
+	try {
+		databases = await listD1Databases();
+	} catch (err) {
+		reporter.warn("Could not check D1 limits before deploy");
+		if (err instanceof Error) {
+			reporter.info(err.message);
+		}
+		return;
+	}
+
+	const count = databases.length;
+	if (count < DEFAULT_D1_LIMIT) {
+		return;
+	}
+
+	reporter.warn(`D1 limit likely reached: ${count} databases`);
+	reporter.info("Delete old D1 databases with: wrangler d1 list / wrangler d1 delete <name>");
+	reporter.info("Or reuse an existing database by setting database_id in wrangler.jsonc");
+
+	if (!interactive) {
+		return;
+	}
+
+	const { promptSelect } = await import("./hooks.ts");
+	console.error("");
+	console.error(
+		`  You have ${count} D1 databases. If your limit is ${DEFAULT_D1_LIMIT}, deploy may fail.`,
+	);
+	console.error("");
+	console.error("  Continue anyway?");
+
+	const choice = await promptSelect(["Yes", "No"]);
+
+	if (choice !== 0) {
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			"D1 limit likely reached",
+			"Delete old D1 databases or reuse an existing database_id",
+			{ exitCode: 0, reported: true },
+		);
+	}
+}
+
 // ============================================================================
 // Create Project Operation
 // ============================================================================
@@ -138,11 +221,20 @@ export async function createProject(
 	name?: string,
 	options: CreateProjectOptions = {},
 ): Promise<CreateProjectResult> {
-	const { template: templateOption, reporter: providedReporter, interactive: interactiveOption } =
-		options;
+	const {
+		template: templateOption,
+		intent: intentPhrase,
+		reporter: providedReporter,
+		interactive: interactiveOption,
+	} = options;
 	const reporter = providedReporter ?? noopReporter;
 	const hasReporter = Boolean(providedReporter);
-	const isCi = process.env.CI === "true" || process.env.CI === "1";
+	// CI mode: JACK_CI env or standard CI env
+	const isCi =
+		process.env.JACK_CI === "1" ||
+		process.env.JACK_CI === "true" ||
+		process.env.CI === "true" ||
+		process.env.CI === "1";
 	const interactive = interactiveOption ?? !isCi;
 
 	// Check if jack init was run (throws if not)
@@ -152,24 +244,195 @@ export async function createProject(
 		throw new JackError(JackErrorCode.VALIDATION_ERROR, "jack is not set up yet", "Run: jack init");
 	}
 
+	// Resolve deploy mode (omakase: logged in => managed, logged out => BYO)
+	const deployMode = await resolveDeployMode({
+		managed: options.managed,
+		byo: options.byo,
+	});
+	const modeError = await validateModeAvailability(deployMode);
+	if (modeError) {
+		throw new JackError(JackErrorCode.VALIDATION_ERROR, modeError);
+	}
+
+	// Close the "Starting..." spinner from new.ts
+	reporter.stop();
+	reporter.success("Initialized");
+
 	// Generate or use provided name
+	const nameWasProvided = name !== undefined;
 	const projectName = name ?? generateProjectName();
 	const targetDir = resolve(projectName);
 
 	// Check directory doesn't exist
 	if (existsSync(targetDir)) {
-		throw new JackError(
-			JackErrorCode.VALIDATION_ERROR,
-			`Directory ${projectName} already exists`,
-		);
+		throw new JackError(JackErrorCode.VALIDATION_ERROR, `Directory ${projectName} already exists`);
+	}
+
+	// Early slug availability check for managed mode (only if user provided explicit name)
+	// Skip for auto-generated names - collision is rare, control plane will catch it anyway
+	if (deployMode === "managed" && nameWasProvided) {
+		reporter.start("Checking name availability...");
+		const { checkAvailability } = await import("./project-resolver.ts");
+		const { available, existingProject } = await checkAvailability(projectName);
+		reporter.stop();
+		if (available) {
+			reporter.success("Name available");
+		}
+
+		if (!available && existingProject) {
+			// Project exists remotely but not locally - offer to link
+			if (existingProject.sources.controlPlane && !existingProject.sources.filesystem) {
+				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 - 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}`);
+						// 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`,
+					);
+				}
+			} else {
+				// Project exists in registry with local path - it's truly taken
+				throw new JackError(
+					JackErrorCode.VALIDATION_ERROR,
+					`Project "${projectName}" already exists`,
+					`Try a different name: jack new ${projectName}-2`,
+				);
+			}
+		}
 	}
 
 	reporter.start("Creating project...");
 
-	// Load template
+	// Intent-based template matching
+	let resolvedTemplate = templateOption;
+
+	if (intentPhrase && !templateOption) {
+		reporter.start("Matching intent to template...");
+
+		const templates = await loadTemplateKeywords();
+		const matches = matchTemplateByIntent(intentPhrase, templates);
+
+		reporter.stop();
+
+		if (matches.length === 0) {
+			// Track no match
+			track(Events.INTENT_NO_MATCH, {});
+
+			// No match - prompt user to choose
+			if (interactive) {
+				const { select } = await import("@clack/prompts");
+				console.error("");
+				console.error(`  No template matched for: "${intentPhrase}"`);
+				console.error("");
+
+				const choice = await select({
+					message: "Select a template:",
+					options: BUILTIN_TEMPLATES.map((t, i) => ({ value: t, label: `${i + 1}. ${t}` })),
+				});
+
+				if (typeof choice !== "string") {
+					throw new JackError(JackErrorCode.VALIDATION_ERROR, "No template selected", undefined, {
+						exitCode: 0,
+						reported: true,
+					});
+				}
+				resolvedTemplate = choice;
+			} else {
+				throw new JackError(
+					JackErrorCode.VALIDATION_ERROR,
+					`No template matched intent: "${intentPhrase}"`,
+					`Available templates: ${BUILTIN_TEMPLATES.join(", ")}`,
+				);
+			}
+		} else if (matches.length === 1) {
+			resolvedTemplate = matches[0]?.template;
+			reporter.success(`Matched template: ${resolvedTemplate}`);
+
+			// Track single match
+			track(Events.INTENT_MATCHED, {
+				template: resolvedTemplate,
+				match_count: 1,
+			});
+		} else {
+			// Track multiple matches
+			track(Events.INTENT_MATCHED, {
+				template: matches[0]?.template,
+				match_count: matches.length,
+			});
+
+			// Multiple matches
+			if (interactive) {
+				const { select } = await import("@clack/prompts");
+				console.error("");
+				console.error(`  Multiple templates matched: "${intentPhrase}"`);
+				console.error("");
+
+				const matchedNames = matches.map((m) => m.template);
+				const choice = await select({
+					message: "Select a template:",
+					options: matchedNames.map((t, i) => ({ value: t, label: `${i + 1}. ${t}` })),
+				});
+
+				if (typeof choice !== "string") {
+					throw new JackError(JackErrorCode.VALIDATION_ERROR, "No template selected", undefined, {
+						exitCode: 0,
+						reported: true,
+					});
+				}
+				resolvedTemplate = choice;
+			} else {
+				resolvedTemplate = matches[0]?.template;
+				reporter.info(`Multiple matches, using: ${resolvedTemplate}`);
+			}
+		}
+
+		reporter.start("Creating project...");
+	}
+
+	// Load template with origin tracking for lineage
 	let template: Template;
+	let templateOrigin: TemplateOrigin;
 	try {
-		template = await resolveTemplate(templateOption);
+		const resolved = await resolveTemplateWithOrigin(resolvedTemplate);
+		template = resolved.template;
+		templateOrigin = resolved.origin;
 	} catch (err) {
 		reporter.stop();
 		const message = err instanceof Error ? err.message : String(err);
@@ -208,11 +471,75 @@ export async function createProject(
 		reporter.start("Creating project...");
 	}
 
+	// Handle optional secrets (only in interactive mode)
+	if (template.optionalSecrets?.length && interactive) {
+		const saved = await getSavedSecrets();
+
+		for (const optionalSecret of template.optionalSecrets) {
+			// Skip if already saved
+			const savedValue = saved[optionalSecret.name];
+			if (savedValue) {
+				secretsToUse[optionalSecret.name] = savedValue;
+				reporter.stop();
+				reporter.success(`Using saved secret: ${optionalSecret.name}`);
+				reporter.start("Creating project...");
+				continue;
+			}
+
+			// Prompt user
+			reporter.stop();
+			const { input, select } = await import("@inquirer/prompts");
+			console.error("");
+			console.error(`  ${optionalSecret.description}`);
+			if (optionalSecret.setupUrl) {
+				console.error(`  Setup: ${optionalSecret.setupUrl}`);
+			}
+			console.error("");
+			console.error("  Esc to skip\n");
+
+			const choice = await select({
+				message: `Add ${optionalSecret.name}?`,
+				choices: [
+					{ name: "1. Yes", value: "yes" },
+					{ name: "2. Skip", value: "skip" },
+				],
+			});
+
+			if (choice === "yes") {
+				const value = await input({
+					message: `Enter ${optionalSecret.name}:`,
+				});
+
+				if (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}`);
+				}
+			}
+
+			reporter.start("Creating project...");
+		}
+	}
+
 	// Write all template files
 	for (const [filePath, content] of Object.entries(rendered.files)) {
 		await Bun.write(join(targetDir, filePath), content);
 	}
 
+	// Preflight: check D1 capacity before spending time on installs (BYO only)
+	reporter.stop();
+	if (deployMode === "byo") {
+		await preflightD1Capacity(targetDir, reporter, interactive);
+	}
+	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);
@@ -309,113 +636,219 @@ export async function createProject(
 		}
 	}
 
-	// For Vite projects, build first
-	const hasVite = existsSync(join(targetDir, "vite.config.ts"));
-	if (hasVite) {
-		reporter.start("Building...");
+	// One-shot agent customization if intent was provided
+	if (intentPhrase) {
+		const oneShotAgent = await getOneShotAgent();
+
+		if (oneShotAgent) {
+			const agentDefinition = getAgentDefinition(oneShotAgent);
+			const agentLabel = agentDefinition?.name ?? oneShotAgent;
+			reporter.info(`Customizing with ${agentLabel}`);
+			reporter.info(`Intent: ${intentPhrase}`);
+			const debugEnabled = isDebug();
+			const customizationSpinner = debugEnabled ? null : reporter.spinner("Customizing...");
+
+			// Track customization start
+			track(Events.INTENT_CUSTOMIZATION_STARTED, { agent: oneShotAgent });
+
+			const result = await runAgentOneShot(oneShotAgent, targetDir, intentPhrase, {
+				info: reporter.info,
+				warn: reporter.warn,
+				status: customizationSpinner
+					? (message) => {
+							customizationSpinner.text = message;
+						}
+					: undefined,
+			});
 
-		const buildResult = await $`npx vite build`.cwd(targetDir).nothrow().quiet();
-		if (buildResult.exitCode !== 0) {
-			reporter.stop();
-			reporter.error("Build failed");
-			throw new JackError(
-				JackErrorCode.BUILD_FAILED,
-				"Build failed",
-				undefined,
-				{ exitCode: 0, stderr: buildResult.stderr.toString(), reported: hasReporter },
-			);
+			if (customizationSpinner) {
+				customizationSpinner.stop();
+			}
+			if (result.success) {
+				reporter.success("Project customized");
+				// Track successful customization
+				track(Events.INTENT_CUSTOMIZATION_COMPLETED, { agent: oneShotAgent });
+			} else {
+				reporter.warn(`Customization skipped: ${result.error ?? "unknown error"}`);
+				// Track failed customization
+				track(Events.INTENT_CUSTOMIZATION_FAILED, {
+					agent: oneShotAgent,
+					error_type: "agent_error",
+				});
+			}
+		} else {
+			reporter.info?.("No compatible agent for customization (Claude Code or Codex required)");
 		}
-
-		reporter.stop();
-		reporter.success("Built");
 	}
 
-	// Deploy
-	reporter.start("Deploying...");
+	let workerUrl: string | null = null;
 
-	const deployResult = await $`wrangler deploy`.cwd(targetDir).nothrow().quiet();
+	// 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,
+		});
 
-	if (deployResult.exitCode !== 0) {
-		reporter.stop();
-		reporter.error("Deploy failed");
-		throw new JackError(
-			JackErrorCode.DEPLOY_FAILED,
-			"Deploy failed",
-			undefined,
-			{ exitCode: 0, stderr: deployResult.stderr.toString(), reported: hasReporter },
-		);
-	}
+		// Register project as soon as remote is created
+		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,
+				},
+			});
+		} catch (err) {
+			debug("Failed to register managed project:", err);
+		}
+
+		// Check if prebuilt deployment succeeded
+		if (remoteResult.status === "live") {
+			// Prebuilt succeeded - skip the fresh build
+			workerUrl = remoteResult.runjackUrl;
+			reporter.success(`Deployed: ${workerUrl}`);
+		} else {
+			// Prebuilt not available - fall back to fresh build
+			if (remoteResult.prebuiltFailed) {
+				// Show debug info about why prebuilt failed
+				const errorDetail = remoteResult.prebuiltError ? ` (${remoteResult.prebuiltError})` : "";
+				debug(`Prebuilt failed${errorDetail}`);
+				reporter.info("Pre-built not available, building fresh...");
+			}
 
-	// Apply schema.sql after deploy
-	if (await hasD1Config(targetDir)) {
-		const dbName = await getD1DatabaseName(targetDir);
-		if (dbName) {
 			try {
-				await applySchema(dbName, targetDir);
+				await deployToManagedProject(remoteResult.projectId, targetDir, reporter);
 			} catch (err) {
-				reporter.warn(`Schema application failed: ${err}`);
-				reporter.info("Run manually: bun run db:migrate");
+				try {
+					await updateProject(projectName, {
+						status: "build_failed",
+						workerUrl: remoteResult.runjackUrl,
+					});
+				} catch (updateErr) {
+					debug("Failed to update managed project status:", updateErr);
+				}
+				throw err;
+			}
+			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
 
-	// Push secrets to Cloudflare
-	const secretsJsonPath = join(targetDir, ".secrets.json");
-	if (existsSync(secretsJsonPath)) {
-		reporter.start("Configuring secrets...");
+		// Build first if needed (wrangler needs dist/ for assets)
+		if (await needsViteBuild(targetDir)) {
+			reporter.start("Building...");
+			try {
+				await runViteBuild(targetDir);
+				reporter.stop();
+				reporter.success("Built");
+			} catch (err) {
+				reporter.stop();
+				reporter.error("Build failed");
+				throw err;
+			}
+		}
 
-		const secretsResult = await $`wrangler secret bulk .secrets.json`
-			.cwd(targetDir)
-			.nothrow()
-			.quiet();
+		reporter.start("Deploying...");
 
-		if (secretsResult.exitCode !== 0) {
-			reporter.stop();
-			reporter.warn("Failed to push secrets to Cloudflare");
-			reporter.info("Run manually: wrangler secret bulk .secrets.json");
-		} else {
+		const deployResult = await $`wrangler deploy`.cwd(targetDir).nothrow().quiet();
+
+		if (deployResult.exitCode !== 0) {
 			reporter.stop();
-			reporter.success("Secrets configured");
+			reporter.error("Deploy failed");
+			throw new JackError(JackErrorCode.DEPLOY_FAILED, "Deploy failed", undefined, {
+				exitCode: 0,
+				stderr: deployResult.stderr.toString(),
+				reported: hasReporter,
+			});
 		}
-	}
 
-	// Parse URL from output
-	const deployOutput = deployResult.stdout.toString();
-	const urlMatch = deployOutput.match(/https:\/\/[\w-]+\.[\w-]+\.workers\.dev/);
-	const workerUrl = urlMatch ? urlMatch[0] : null;
+		// Apply schema.sql after deploy
+		if (await hasD1Config(targetDir)) {
+			const dbName = await getD1DatabaseName(targetDir);
+			if (dbName) {
+				try {
+					await applySchema(dbName, targetDir);
+				} catch (err) {
+					reporter.warn(`Schema application failed: ${err}`);
+					reporter.info("Run manually: bun run db:migrate");
+				}
+			}
+		}
 
-	reporter.stop();
-	if (workerUrl) {
-		reporter.success(`Live: ${workerUrl}`);
-	} else {
-		reporter.success("Deployed");
-	}
+		// Push secrets to Cloudflare
+		const secretsJsonPath = join(targetDir, ".secrets.json");
+		if (existsSync(secretsJsonPath)) {
+			reporter.start("Configuring secrets...");
 
-	// Register project in registry
-	try {
-		const accountId = await getAccountId();
-		const dbName = await getD1DatabaseName(targetDir);
+			const secretsResult = await $`wrangler secret bulk .secrets.json`
+				.cwd(targetDir)
+				.nothrow()
+				.quiet();
 
-		await registerProject(projectName, {
-			localPath: targetDir,
-			workerUrl,
-			createdAt: new Date().toISOString(),
-			lastDeployed: workerUrl ? new Date().toISOString() : null,
-			cloudflare: {
-				accountId,
-				workerId: projectName,
-			},
-			resources: {
-				services: {
-					db: dbName,
+			if (secretsResult.exitCode !== 0) {
+				reporter.stop();
+				reporter.warn("Failed to push secrets to Cloudflare");
+				reporter.info("Run manually: wrangler secret bulk .secrets.json");
+			} else {
+				reporter.stop();
+				reporter.success("Secrets configured");
+			}
+		}
+
+		// Parse URL from output
+		const deployOutput = deployResult.stdout.toString();
+		const urlMatch = deployOutput.match(/https:\/\/[\w-]+\.[\w-]+\.workers\.dev/);
+		workerUrl = urlMatch ? urlMatch[0] : null;
+
+		reporter.stop();
+		if (workerUrl) {
+			reporter.success(`Live: ${workerUrl}`);
+		} else {
+			reporter.success("Deployed");
+		}
+
+		// Register project with BYO mode
+		try {
+			const accountId = await getAccountId();
+
+			await registerProject(projectName, {
+				workerUrl,
+				createdAt: new Date().toISOString(),
+				lastDeployed: workerUrl ? new Date().toISOString() : null,
+				cloudflare: {
+					accountId,
+					workerId: projectName,
 				},
-			},
-		});
-	} catch {
-		// Don't fail the creation if registry update fails
+				template: templateOrigin,
+				deploy_mode: "byo",
+			});
+		} catch {
+			// Don't fail the creation if registry update fails
+		}
 	}
 
-	// Run post-deploy hooks
+	// Run post-deploy hooks (for both modes)
 	if (template.hooks?.postDeploy?.length && workerUrl) {
 		const domain = workerUrl.replace(/^https?:\/\//, "");
 		await runHook(
@@ -430,10 +863,18 @@ 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,
 		workerUrl,
+		deployMode,
 	};
 }
 
@@ -460,7 +901,12 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 	} = options;
 	const reporter = providedReporter ?? noopReporter;
 	const hasReporter = Boolean(providedReporter);
-	const isCi = process.env.CI === "true" || process.env.CI === "1";
+	// CI mode: JACK_CI env or standard CI env
+	const isCi =
+		process.env.JACK_CI === "1" ||
+		process.env.JACK_CI === "true" ||
+		process.env.CI === "true" ||
+		process.env.CI === "1";
 	const interactive = interactiveOption ?? !isCi;
 
 	// Check for wrangler config
@@ -477,55 +923,93 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		);
 	}
 
-	// For Vite projects, build first
-	const isViteProject =
-		existsSync(join(projectPath, "vite.config.ts")) ||
-		existsSync(join(projectPath, "vite.config.js")) ||
-		existsSync(join(projectPath, "vite.config.mjs"));
+	// Get project name from directory
+	const projectName = await getProjectNameFromDir(projectPath);
 
-	if (isViteProject) {
-		const buildSpin = reporter.spinner("Building...");
-		const buildResult = await $`npx vite build`.cwd(projectPath).nothrow().quiet();
+	// Get project from registry to check stored mode
+	const project = await getProject(projectName);
 
-		if (buildResult.exitCode !== 0) {
-			buildSpin.error("Build failed");
-			throw new JackError(JackErrorCode.BUILD_FAILED, "Build failed", undefined, {
-				exitCode: buildResult.exitCode ?? 1,
-				stderr: buildResult.stderr.toString(),
-				reported: hasReporter,
-			});
-		}
-		buildSpin.success("Built");
+	// Determine effective mode: explicit flag > stored mode > default BYO
+	let deployMode: DeployMode;
+	if (options.managed) {
+		deployMode = "managed";
+	} else if (options.byo) {
+		deployMode = "byo";
+	} else {
+		deployMode = project?.deploy_mode ?? "byo";
 	}
 
-	// Deploy
-	const spin = reporter.spinner("Deploying...");
-	const result = await $`wrangler deploy`.cwd(projectPath).nothrow().quiet();
-
-	if (result.exitCode !== 0) {
-		spin.error("Deploy failed");
-		throw new JackError(JackErrorCode.DEPLOY_FAILED, "Deploy failed", undefined, {
-			exitCode: result.exitCode ?? 1,
-			stderr: result.stderr.toString(),
-			reported: hasReporter,
-		});
+	// Validate mode availability
+	const modeError = await validateModeAvailability(deployMode);
+	if (modeError) {
+		throw new JackError(JackErrorCode.VALIDATION_ERROR, modeError);
 	}
 
-	// Parse URL from output
-	const deployOutput = result.stdout.toString();
-	const urlMatch = deployOutput.match(/https:\/\/[\w-]+\.[\w-]+\.workers\.dev/);
-	const workerUrl = urlMatch ? urlMatch[0] : null;
-	const projectName = await getProjectNameFromDir(projectPath);
+	let workerUrl: string | null = null;
+	let deployOutput: string | undefined;
 
-	if (workerUrl) {
-		spin.success(`Live: ${workerUrl}`);
+	// Deploy based on mode
+	if (deployMode === "managed") {
+		// Managed mode: deploy via jack cloud
+		if (!project?.remote?.project_id) {
+			throw new JackError(
+				JackErrorCode.VALIDATION_ERROR,
+				"Project not linked to jack cloud",
+				"Create a new managed project or use --byo",
+			);
+		}
+
+		// deployToManagedProject now handles both template and code deploy
+		const result = await deployToManagedProject(project.remote.project_id, projectPath, reporter);
+
+		workerUrl = project.remote.runjack_url;
+
+		// Update lastDeployed in registry (will be persisted below)
+		if (project) {
+			project.lastDeployed = new Date().toISOString();
+		}
 	} else {
-		spin.success("Deployed");
+		// BYO mode: deploy via wrangler
+
+		// Build first if needed (wrangler needs dist/ for assets)
+		if (await needsViteBuild(projectPath)) {
+			const buildSpin = reporter.spinner("Building...");
+			try {
+				await runViteBuild(projectPath);
+				buildSpin.success("Built");
+			} catch (err) {
+				buildSpin.error("Build failed");
+				throw err;
+			}
+		}
+
+		const spin = reporter.spinner("Deploying...");
+		const result = await $`wrangler deploy`.cwd(projectPath).nothrow().quiet();
+
+		if (result.exitCode !== 0) {
+			spin.error("Deploy failed");
+			throw new JackError(JackErrorCode.DEPLOY_FAILED, "Deploy failed", undefined, {
+				exitCode: result.exitCode ?? 1,
+				stderr: result.stderr.toString(),
+				reported: hasReporter,
+			});
+		}
+
+		// Parse URL from output
+		deployOutput = result.stdout.toString();
+		const urlMatch = deployOutput.match(/https:\/\/[\w-]+\.[\w-]+\.workers\.dev/);
+		workerUrl = urlMatch ? urlMatch[0] : null;
+
+		if (workerUrl) {
+			spin.success(`Live: ${workerUrl}`);
+		} else {
+			spin.success("Deployed");
+		}
 	}
 
-	// Apply schema if needed
+	// Apply schema if needed (BYO only - managed projects have their own DB)
 	let dbName: string | null = null;
-	if (await hasD1Config(projectPath)) {
+	if (deployMode === "byo" && (await hasD1Config(projectPath))) {
 		dbName = await getD1DatabaseName(projectPath);
 		if (dbName) {
 			try {
@@ -540,14 +1024,8 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 	// Update registry
 	try {
 		await registerProject(projectName, {
-			localPath: projectPath,
 			workerUrl,
 			lastDeployed: new Date().toISOString(),
-			resources: {
-				services: {
-					db: dbName,
-				},
-			},
 		});
 	} catch {
 		// Don't fail the deploy if registry update fails
@@ -585,10 +1063,18 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		}
 	}
 
+	// Auto-register local path for project discovery
+	try {
+		await registerLocalPath(projectName, projectPath);
+	} catch {
+		// Silent fail - registration is best-effort
+	}
+
 	return {
 		workerUrl,
 		projectName,
 		deployOutput: workerUrl ? undefined : deployOutput,
+		deployMode,
 	};
 }
 
@@ -602,7 +1088,7 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
  * Extracted from commands/projects.ts infoProject to enable programmatic status checks.
  *
  * @param name - Project name (auto-detected from cwd if not provided)
- * @param projectPath - Project path (defaults to cwd)
+ * @param projectPath - Project path (defaults to cwd, used for local status checks)
  * @returns Project status or null if not found
  */
 export async function getProjectStatus(
@@ -610,11 +1096,12 @@ export async function getProjectStatus(
 	projectPath?: string,
 ): Promise<ProjectStatus | null> {
 	let projectName = name;
+	const resolvedPath = projectPath ?? process.cwd();
 
 	// If no name provided, try to get from project path or cwd
 	if (!projectName) {
 		try {
-			projectName = await getProjectNameFromDir(projectPath ?? process.cwd());
+			projectName = await getProjectNameFromDir(resolvedPath);
 		} catch {
 			// Could not determine project name
 			return null;
@@ -627,8 +1114,15 @@ export async function getProjectStatus(
 		return null;
 	}
 
-	// Check actual status
-	const localExists = project.localPath ? existsSync(project.localPath) : false;
+	// Check if local project exists at the resolved path
+	const hasWranglerConfig =
+		existsSync(join(resolvedPath, "wrangler.jsonc")) ||
+		existsSync(join(resolvedPath, "wrangler.toml")) ||
+		existsSync(join(resolvedPath, "wrangler.json"));
+	const localExists = hasWranglerConfig;
+	const localPath = localExists ? resolvedPath : null;
+
+	// Check actual deployment status
 	const [workerExists, manifest] = await Promise.all([
 		checkWorkerExists(projectName),
 		getRemoteManifest(projectName),
@@ -637,113 +1131,54 @@ export async function getProjectStatus(
 	const backupFiles = manifest ? manifest.files.length : null;
 	const backupLastSync = manifest ? manifest.lastSync : null;
 
+	// Get database name on-demand
+	let dbName: string | null = null;
+	if (project.deploy_mode === "managed" && project.remote?.project_id) {
+		// For managed projects, fetch from control plane
+		try {
+			const { fetchProjectResources } = await import("./control-plane.ts");
+			const resources = await fetchProjectResources(project.remote.project_id);
+			const d1 = resources.find((r) => r.resource_type === "d1");
+			dbName = d1?.resource_name || null;
+		} catch {
+			// Ignore errors, dbName stays null
+		}
+	} else if (localExists) {
+		// For BYO, parse from wrangler config
+		try {
+			const { parseWranglerResources } = await import("./resources.ts");
+			const resources = await parseWranglerResources(resolvedPath);
+			dbName = resources.d1?.name || null;
+		} catch {
+			// Ignore errors, dbName stays null
+		}
+	}
+
 	return {
 		name: projectName,
-		localPath: project.localPath,
+		localPath,
 		workerUrl: project.workerUrl,
 		lastDeployed: project.lastDeployed,
 		createdAt: project.createdAt,
-		accountId: project.cloudflare.accountId,
-		workerId: project.cloudflare.workerId,
-		dbName: getProjectDatabaseName(project),
+		accountId: project.cloudflare?.accountId ?? null,
+		workerId: project.cloudflare?.workerId ?? null,
+		dbName,
 		deployed: workerExists || !!project.workerUrl,
 		local: localExists,
 		backedUp,
-		missing: project.localPath ? !localExists : false,
+		missing: false, // No longer tracking local paths in registry
 		backupFiles,
 		backupLastSync,
 	};
 }
 
-// ============================================================================
-// List All Projects Operation
-// ============================================================================
-
-/**
- * List all projects with status information
- *
- * Extracted from commands/projects.ts listProjects to enable programmatic project listing.
- *
- * @param filter - Filter projects by status
- * @returns Array of project statuses
- */
-export async function listAllProjects(
-	filter?: "all" | "local" | "deployed" | "cloud",
-): Promise<ProjectStatus[]> {
-	const projects = await getAllProjects();
-	const projectNames = Object.keys(projects);
-
-	if (projectNames.length === 0) {
-		return [];
-	}
-
-	// Determine status for each project
-	const statuses: ProjectStatus[] = await Promise.all(
-		projectNames.map(async (name) => {
-			const project = projects[name];
-			if (!project) {
-				return null;
-			}
-
-			const local = project.localPath ? existsSync(project.localPath) : false;
-			const missing = project.localPath ? !local : false;
-
-			// Check if deployed
-			let deployed = false;
-			if (project.workerUrl) {
-				deployed = true;
-			} else {
-				deployed = await checkWorkerExists(name);
-			}
-
-			// Check if backed up
-			const manifest = await getRemoteManifest(name);
-			const backedUp = manifest !== null;
-			const backupFiles = manifest ? manifest.files.length : null;
-			const backupLastSync = manifest ? manifest.lastSync : null;
-
-			return {
-				name,
-				localPath: project.localPath,
-				workerUrl: project.workerUrl,
-				lastDeployed: project.lastDeployed,
-				createdAt: project.createdAt,
-				accountId: project.cloudflare.accountId,
-				workerId: project.cloudflare.workerId,
-				dbName: getProjectDatabaseName(project),
-				local,
-				deployed,
-				backedUp,
-				missing,
-				backupFiles,
-				backupLastSync,
-			};
-		}),
-	).then((results) => results.filter((s): s is ProjectStatus => s !== null));
-
-	// Apply filter
-	if (!filter || filter === "all") {
-		return statuses;
-	}
-
-	switch (filter) {
-		case "local":
-			return statuses.filter((s) => s.local);
-		case "deployed":
-			return statuses.filter((s) => s.deployed);
-		case "cloud":
-			return statuses.filter((s) => s.backedUp);
-		default:
-			return statuses;
-	}
-}
-
 // ============================================================================
 // Cleanup Operations
 // ============================================================================
 
 /**
- * Scan registry for stale projects
+ * Scan registry for stale projects.
+ * Checks for projects with worker URLs that no longer have deployed workers.
  * Returns total project count and stale entries with reasons.
  */
 export async function scanStaleProjects(): Promise<StaleProjectScan> {
@@ -755,21 +1190,13 @@ export async function scanStaleProjects(): Promise<StaleProjectScan> {
 		const project = projects[name];
 		if (!project) continue;
 
-		if (project.localPath && !existsSync(project.localPath)) {
-			stale.push({
-				name,
-				reason: "local folder deleted",
-				workerUrl: project.workerUrl,
-			});
-			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: "undeployed from cloud",
+					reason: "worker not deployed",
 					workerUrl: project.workerUrl,
 				});
 			}