@getjack/jack 0.1.6 → 0.1.7

package/src/lib/project-operations.ts

@@ -23,8 +23,22 @@ import {
 	runAgentOneShot,
 	validateAgentPaths,
 } from "./agents.ts";
-import { ensureR2Buckets, needsOpenNextBuild, needsViteBuild, runOpenNextBuild, runViteBuild } from "./build-helper.ts";
+import {
+	checkWranglerVersion,
+	getWranglerVersion,
+	needsOpenNextBuild,
+	needsViteBuild,
+	parseWranglerConfig,
+	runOpenNextBuild,
+	runViteBuild,
+} from "./build-helper.ts";
 import { checkWorkerExists, getAccountId, listD1Databases } from "./cloudflare-api.ts";
+import {
+	generateWranglerConfig,
+	getDefaultProjectName,
+	slugify,
+	writeWranglerConfig,
+} from "./config-generator.ts";
 import { getSyncConfig } from "./config.ts";
 import { deleteManagedProject } from "./control-plane.ts";
 import { debug, isDebug } from "./debug.ts";
@@ -40,6 +54,7 @@ import {
 } from "./managed-deploy.ts";
 import { generateProjectName } from "./names.ts";
 import { getAllPaths, registerPath, unregisterPath } from "./paths-index.ts";
+import { detectProjectType, validateProject } from "./project-detection.ts";
 import {
 	type DeployMode,
 	type TemplateMetadata as TemplateOrigin,
@@ -83,6 +98,7 @@ export interface DeployOptions {
 	includeSync?: boolean;
 	managed?: boolean; // Force managed deploy mode
 	byo?: boolean; // Force BYO deploy mode
+	dryRun?: boolean; // Stop before actual deployment
 }
 
 export interface DeployResult {
@@ -293,6 +309,213 @@ async function preflightD1Capacity(
 	}
 }
 
+// ============================================================================
+// Auto-detect Flow for Ship Command
+// ============================================================================
+
+interface AutoDetectResult {
+	projectName: string;
+	projectId: string | null; // null when dry run (no cloud project created)
+	deployMode: DeployMode;
+}
+
+/**
+ * Run the auto-detect flow when no wrangler config exists.
+ * Detects project type, prompts user for confirmation, generates config,
+ * and creates managed project on jack cloud.
+ *
+ * @param dryRun - If true, skip cloud project creation and linking
+ */
+async function runAutoDetectFlow(
+	projectPath: string,
+	reporter: OperationReporter,
+	interactive: boolean,
+	dryRun = false,
+): Promise<AutoDetectResult> {
+	// Step 1: Validate project (file count, size limits)
+	const validation = await validateProject(projectPath);
+	if (!validation.valid) {
+		track(Events.AUTO_DETECT_REJECTED, { reason: "validation_failed" });
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			validation.error || "Project validation failed",
+		);
+	}
+
+	// Step 2: Detect project type
+	const detection = detectProjectType(projectPath);
+
+	// Step 3: Handle unsupported frameworks
+	if (detection.unsupportedFramework) {
+		track(Events.AUTO_DETECT_FAILED, {
+			reason: "unsupported_framework",
+			framework: detection.unsupportedFramework,
+		});
+
+		// Use the detailed error message from detection (includes setup instructions)
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			detection.error || `${detection.unsupportedFramework} is not yet supported`,
+		);
+	}
+
+	// Step 4: Handle unknown project type
+	if (detection.type === "unknown") {
+		track(Events.AUTO_DETECT_FAILED, { reason: "unknown_type" });
+
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			"Could not detect project type\n\nSupported types:\n  - Vite (React, Vue, etc.)\n  - Hono API\n  - SvelteKit (with @sveltejs/adapter-cloudflare)\n\nTo deploy manually, create a wrangler.jsonc file.\nDocs: https://docs.getjack.org/guides/manual-setup",
+		);
+	}
+
+	// Step 5: Handle detection errors (e.g., missing adapter)
+	if (detection.error) {
+		track(Events.AUTO_DETECT_FAILED, {
+			reason: "detection_error",
+			type: detection.type,
+		});
+		throw new JackError(JackErrorCode.VALIDATION_ERROR, detection.error);
+	}
+
+	// Step 6: Detection succeeded - show what was detected
+	const typeLabels: Record<string, string> = {
+		vite: "Vite",
+		hono: "Hono API",
+		sveltekit: "SvelteKit",
+	};
+	const typeLabel = typeLabels[detection.type] || detection.type;
+	const configInfo = detection.configFile || detection.entryPoint || "";
+	reporter.info(`Detected: ${typeLabel} project${configInfo ? ` (${configInfo})` : ""}`);
+
+	// Step 7: Fetch username for URL preview (skip for dry run)
+	let ownerUsername: string | null = null;
+	if (!dryRun) {
+		const { getCurrentUserProfile } = await import("./control-plane.ts");
+		const profile = await getCurrentUserProfile();
+		ownerUsername = profile?.username ?? null;
+	}
+
+	// Step 8: Get default project name and prompt user
+	const defaultName = getDefaultProjectName(projectPath);
+
+	if (!interactive) {
+		// Non-interactive mode - use defaults
+		const projectName = defaultName;
+		const runjackUrl = ownerUsername
+			? `https://${ownerUsername}-${projectName}.runjack.xyz`
+			: `https://${projectName}.runjack.xyz`;
+
+		reporter.info(`Project name: ${projectName}`);
+		reporter.info(`Will deploy to: ${runjackUrl}`);
+
+		// Generate and write wrangler config
+		const wranglerConfig = generateWranglerConfig(
+			detection.type,
+			projectName,
+			detection.entryPoint,
+		);
+		writeWranglerConfig(projectPath, wranglerConfig);
+		reporter.success("Created wrangler.jsonc");
+
+		// Skip cloud creation and linking for dry run
+		if (dryRun) {
+			track(Events.AUTO_DETECT_SUCCESS, { type: detection.type });
+			return {
+				projectName,
+				projectId: null,
+				deployMode: "managed",
+			};
+		}
+
+		// Create managed project on jack cloud
+		const remoteResult = await createManagedProjectRemote(projectName, reporter, {
+			usePrebuilt: false,
+		});
+
+		// Link project locally (include username for correct URL display)
+		await linkProject(projectPath, remoteResult.projectId, "managed", ownerUsername ?? undefined);
+		await registerPath(remoteResult.projectId, projectPath);
+
+		track(Events.AUTO_DETECT_SUCCESS, { type: detection.type });
+
+		return {
+			projectName,
+			projectId: remoteResult.projectId,
+			deployMode: "managed",
+		};
+	}
+
+	// Interactive mode - prompt for project name
+	const { input } = await import("@inquirer/prompts");
+
+	console.error("");
+	const projectName = await input({
+		message: "Project name:",
+		default: defaultName,
+	});
+
+	const slugifiedName = slugify(projectName.trim());
+	const runjackUrl = ownerUsername
+		? `https://${ownerUsername}-${slugifiedName}.runjack.xyz`
+		: `https://${slugifiedName}.runjack.xyz`;
+
+	// Confirmation prompt
+	console.error("");
+	console.error("  This will:");
+	console.error("    - Create wrangler.jsonc");
+	console.error("    - Create project on jack cloud");
+	console.error(`    - Deploy to ${runjackUrl}`);
+	console.error("");
+
+	const { promptSelect } = await import("./hooks.ts");
+	const choice = await promptSelect(["Continue", "Cancel"]);
+
+	if (choice !== 0) {
+		track(Events.AUTO_DETECT_REJECTED, { reason: "user_cancelled" });
+		throw new JackError(JackErrorCode.VALIDATION_ERROR, "Deployment cancelled", undefined, {
+			exitCode: 0,
+			reported: true,
+		});
+	}
+
+	// Generate and write wrangler config
+	const wranglerConfig = generateWranglerConfig(
+		detection.type,
+		slugifiedName,
+		detection.entryPoint,
+	);
+	writeWranglerConfig(projectPath, wranglerConfig);
+	reporter.success("Created wrangler.jsonc");
+
+	// Skip cloud creation and linking for dry run
+	if (dryRun) {
+		track(Events.AUTO_DETECT_SUCCESS, { type: detection.type });
+		return {
+			projectName: slugifiedName,
+			projectId: null,
+			deployMode: "managed",
+		};
+	}
+
+	// Create managed project on jack cloud
+	const remoteResult = await createManagedProjectRemote(slugifiedName, reporter, {
+		usePrebuilt: false,
+	});
+
+	// Link project locally (include username for correct URL display)
+	await linkProject(projectPath, remoteResult.projectId, "managed", ownerUsername ?? undefined);
+	await registerPath(remoteResult.projectId, projectPath);
+
+	track(Events.AUTO_DETECT_SUCCESS, { type: detection.type });
+
+	return {
+		projectName: slugifiedName,
+		projectId: remoteResult.projectId,
+		deployMode: "managed",
+	};
+}
+
 // ============================================================================
 // Create Project Operation
 // ============================================================================
@@ -674,7 +897,7 @@ export async function createProject(
 		try {
 			const result = await runParallelSetup(targetDir, projectName, {
 				template: resolvedTemplate || "hello",
-				usePrebuilt: true,
+				usePrebuilt: templateOrigin.type === "builtin", // Only builtin templates have prebuilt bundles
 			});
 			remoteResult = result.remoteResult;
 			reporter.stop();
@@ -787,9 +1010,14 @@ export async function createProject(
 			);
 		}
 
+		// Fetch username for link storage
+		const { getCurrentUserProfile } = await import("./control-plane.ts");
+		const profile = await getCurrentUserProfile();
+		const ownerUsername = profile?.username ?? undefined;
+
 		// Link project locally and register path
 		try {
-			await linkProject(targetDir, remoteResult.projectId, "managed");
+			await linkProject(targetDir, remoteResult.projectId, "managed", ownerUsername);
 			await writeTemplateMetadata(targetDir, templateOrigin);
 			await registerPath(remoteResult.projectId, targetDir);
 		} catch (err) {
@@ -957,6 +1185,7 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		interactive: interactiveOption,
 		includeSecrets = false,
 		includeSync = false,
+		dryRun = false,
 	} = options;
 	const reporter = providedReporter ?? noopReporter;
 	const hasReporter = Boolean(providedReporter);
@@ -974,7 +1203,14 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		existsSync(join(projectPath, "wrangler.jsonc")) ||
 		existsSync(join(projectPath, "wrangler.json"));
 
-	if (!hasWranglerConfig) {
+	// Check for existing project link
+	const hasProjectLink = existsSync(join(projectPath, ".jack", "project.json"));
+
+	// Auto-detect flow: no wrangler config and no project link
+	let autoDetectResult: AutoDetectResult | null = null;
+	if (!hasWranglerConfig && !hasProjectLink) {
+		autoDetectResult = await runAutoDetectFlow(projectPath, reporter, interactive, dryRun);
+	} else if (!hasWranglerConfig) {
 		throw new JackError(
 			JackErrorCode.PROJECT_NOT_FOUND,
 			"No wrangler config found in current directory",
@@ -982,18 +1218,20 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		);
 	}
 
-	// Get project name from directory
-	const projectName = await getProjectNameFromDir(projectPath);
+	// Get project name from directory (or auto-detect result)
+	const projectName = autoDetectResult?.projectName ?? (await getProjectNameFromDir(projectPath));
 
 	// Read local project link for stored mode and project ID
 	const link = await readProjectLink(projectPath);
 
-	// Determine effective mode: explicit flag > stored mode > default BYO
+	// Determine effective mode: explicit flag > auto-detect > stored mode > default BYO
 	let deployMode: DeployMode;
 	if (options.managed) {
 		deployMode = "managed";
 	} else if (options.byo) {
 		deployMode = "byo";
+	} else if (autoDetectResult) {
+		deployMode = autoDetectResult.deployMode;
 	} else {
 		deployMode = link?.deploy_mode ?? "byo";
 	}
@@ -1010,7 +1248,11 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 	// Deploy based on mode
 	if (deployMode === "managed") {
 		// Managed mode: deploy via jack cloud
-		if (!link?.project_id || link.deploy_mode !== "managed") {
+		// Use autoDetectResult.projectId if available, otherwise require existing link
+		const managedProjectId = autoDetectResult?.projectId ?? link?.project_id;
+
+		// For dry run, skip the project ID check since we didn't create a cloud project
+		if (!dryRun && (!managedProjectId || (!autoDetectResult && link?.deploy_mode !== "managed"))) {
 			throw new JackError(
 				JackErrorCode.VALIDATION_ERROR,
 				"Project not linked to jack cloud",
@@ -1018,11 +1260,43 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 			);
 		}
 
+		// Dry run: build for validation then stop before actual deployment
+		// (deployToManagedProject handles its own build, so only build here for dry-run)
+		if (dryRun) {
+			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);
+					buildSpin.success("Built");
+				} catch (err) {
+					buildSpin.error("Build failed");
+					throw err;
+				}
+			}
+			reporter.success("Dry run complete - config generated, build verified");
+			return {
+				workerUrl: null,
+				projectName,
+				deployMode,
+			};
+		}
+
 		// deployToManagedProject now handles both template and code deploy
-		await deployToManagedProject(link.project_id, projectPath, reporter);
+		await deployToManagedProject(managedProjectId as string, projectPath, reporter);
 
-		// Get the URL from the resolver or construct it
-		workerUrl = `https://${projectName}.runjack.xyz`;
+		// Construct URL with username if available
+		workerUrl = link?.owner_username
+			? `https://${link.owner_username}-${projectName}.runjack.xyz`
+			: `https://${projectName}.runjack.xyz`;
 	} else {
 		// BYO mode: deploy via wrangler
 
@@ -1047,15 +1321,32 @@ 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(", ")}`);
+		// Dry run: stop before actual deployment
+		if (dryRun) {
+			reporter.success("Dry run complete - build verified");
+			return {
+				workerUrl: null,
+				projectName,
+				deployMode,
+			};
+		}
+
+		// Check wrangler version for auto-provisioning (KV/R2/D1 without IDs)
+		const config = await parseWranglerConfig(projectPath);
+		const needsAutoProvision =
+			config.kv_namespaces?.some((kv) => !kv.id) ||
+			config.r2_buckets?.some((r2) => r2.bucket_name?.startsWith("jack-template-")) ||
+			config.d1_databases?.some((d1) => !d1.database_id);
+
+		if (needsAutoProvision) {
+			try {
+				const wranglerVersion = await getWranglerVersion();
+				checkWranglerVersion(wranglerVersion);
+			} catch (err) {
+				if (err instanceof JackError) {
+					throw err;
+				}
 			}
-		} 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...");
@@ -1134,7 +1425,11 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		if (!existingLink) {
 			// Not linked yet - create link
 			if (deployMode === "managed" && link?.project_id) {
-				await linkProject(projectPath, link.project_id, "managed");
+				// Fetch username for link storage
+				const { getCurrentUserProfile } = await import("./control-plane.ts");
+				const profile = await getCurrentUserProfile();
+				const ownerUsername = profile?.username ?? undefined;
+				await linkProject(projectPath, link.project_id, "managed", ownerUsername);
 				await registerPath(link.project_id, projectPath);
 			} else {
 				// BYO mode - generate new ID
@@ -1216,7 +1511,9 @@ export async function getProjectStatus(
 	// Determine URL based on mode
 	let workerUrl: string | null = null;
 	if (link?.deploy_mode === "managed") {
-		workerUrl = `https://${projectName}.runjack.xyz`;
+		workerUrl = link.owner_username
+			? `https://${link.owner_username}-${projectName}.runjack.xyz`
+			: `https://${projectName}.runjack.xyz`;
 	}
 
 	// Get database name on-demand

package/src/lib/project-resolver.ts

@@ -121,11 +121,15 @@ function fromManagedProject(managed: ManagedProject): ResolvedProject {
 		}
 	}
 
+	const url = managed.owner_username
+		? `https://${managed.owner_username}-${managed.slug}.runjack.xyz`
+		: `https://${managed.slug}.runjack.xyz`;
+
 	return {
 		name: managed.name,
 		slug: managed.slug,
 		status,
-		url: `https://${managed.slug}.runjack.xyz`,
+		url,
 		errorMessage: managed.status === "error" ? "deployment failed" : undefined,
 		sources: {
 			controlPlane: true,

package/src/lib/storage/file-filter.ts

@@ -25,6 +25,7 @@ export const DEFAULT_INCLUDES: string[] = [
 	"*.mjs",
 	"*.cjs",
 	"*.json",
+	"*.jsonc",
 	"*.toml",
 	"*.md",
 	"*.css",
@@ -48,6 +49,10 @@ export const DEFAULT_EXCLUDES: string[] = [
 	".DS_Store",
 	"dist/**",
 	"build/**",
+	".next/**",
+	".nuxt/**",
+	".output/**",
+	".svelte-kit/**",
 	"coverage/**",
 	".wrangler/**",
 	"*.lock",

package/src/lib/telemetry.ts

@@ -28,6 +28,10 @@ export const Events = {
 	MANAGED_DEPLOY_STARTED: "managed_deploy_started",
 	MANAGED_DEPLOY_COMPLETED: "managed_deploy_completed",
 	MANAGED_DEPLOY_FAILED: "managed_deploy_failed",
+	// Auto-detect events
+	AUTO_DETECT_SUCCESS: "auto_detect_success",
+	AUTO_DETECT_FAILED: "auto_detect_failed",
+	AUTO_DETECT_REJECTED: "auto_detect_rejected",
 } as const;
 
 type EventName = (typeof Events)[keyof typeof Events];

package/src/lib/zip-packager.ts

@@ -42,6 +42,7 @@ export interface ManifestData {
 		};
 		vars?: Record<string, string>;
 		r2?: Array<{ binding: string; bucket_name: string }>;
+		kv?: Array<{ binding: string }>;
 	};
 }
 
@@ -169,6 +170,13 @@ function extractBindingsFromConfig(config?: WranglerConfig): ManifestData["bindi
 		}));
 	}
 
+	// Extract KV namespace bindings
+	if (config.kv_namespaces && config.kv_namespaces.length > 0) {
+		bindings.kv = config.kv_namespaces.map((kv) => ({
+			binding: kv.binding,
+		}));
+	}
+
 	// Return undefined if no bindings were extracted
 	return Object.keys(bindings).length > 0 ? bindings : undefined;
 }

package/src/templates/index.ts

@@ -1,6 +1,8 @@
 import { existsSync } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { unzipSync } from "fflate";
+import { getControlApiUrl } from "../lib/control-plane.ts";
 import { parseJsonc } from "../lib/jsonc.ts";
 import type { TemplateMetadata as TemplateOrigin } from "../lib/project-link.ts";
 import type { Template } from "./types";
@@ -97,8 +99,118 @@ async function loadTemplate(name: string): Promise<Template> {
 	};
 }
 
+// Internal files that should be excluded from templates
+const INTERNAL_FILES = [".jack.json", ".jack/template.json"];
+
+/**
+ * Extract zip buffer to file map, excluding internal files
+ */
+function extractZipToFiles(zipData: ArrayBuffer): Record<string, string> {
+	const files: Record<string, string> = {};
+	const unzipped = unzipSync(new Uint8Array(zipData));
+
+	for (const [path, content] of Object.entries(unzipped)) {
+		// Skip directories (they have zero-length content or end with /)
+		if (content.length === 0 || path.endsWith("/")) continue;
+
+		// Skip internal files
+		if (path && !INTERNAL_FILES.includes(path)) {
+			files[path] = new TextDecoder().decode(content);
+		}
+	}
+
+	return files;
+}
+
+/**
+ * Read metadata from extracted files (before they're filtered)
+ */
+function extractMetadataFromZip(zipData: ArrayBuffer): Record<string, unknown> {
+	const unzipped = unzipSync(new Uint8Array(zipData));
+
+	for (const [path, content] of Object.entries(unzipped)) {
+		// Skip directories
+		if (content.length === 0 || path.endsWith("/")) continue;
+
+		if (path === ".jack.json") {
+			return parseJsonc(new TextDecoder().decode(content));
+		}
+	}
+
+	return {};
+}
+
+/**
+ * Fetch a published template from jack cloud (public endpoint, no auth)
+ */
+async function fetchPublishedTemplate(username: string, slug: string): Promise<Template> {
+	const response = await fetch(
+		`${getControlApiUrl()}/v1/projects/${encodeURIComponent(username)}/${encodeURIComponent(slug)}/source`,
+	);
+
+	if (!response.ok) {
+		if (response.status === 404) {
+			throw new Error(
+				`Template not found: ${username}/${slug}\n\nMake sure the project exists and is published with: jack publish`,
+			);
+		}
+		throw new Error(`Failed to fetch template: ${response.status}`);
+	}
+
+	const zipData = await response.arrayBuffer();
+	const metadata = extractMetadataFromZip(zipData);
+	const files = extractZipToFiles(zipData);
+
+	return {
+		description: (metadata.description as string) || `Fork of ${username}/${slug}`,
+		secrets: (metadata.secrets as string[]) || [],
+		optionalSecrets: metadata.optionalSecrets as Template["optionalSecrets"],
+		capabilities: metadata.capabilities as Template["capabilities"],
+		requires: metadata.requires as Template["requires"],
+		hooks: metadata.hooks as Template["hooks"],
+		agentContext: metadata.agentContext as Template["agentContext"],
+		intent: metadata.intent as Template["intent"],
+		files,
+	};
+}
+
+/**
+ * Fetch user's own project as a template (authenticated)
+ */
+async function fetchUserTemplate(slug: string): Promise<Template | null> {
+	const { authFetch } = await import("../lib/auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/me/projects/${encodeURIComponent(slug)}/source`,
+	);
+
+	if (response.status === 404) {
+		return null; // Not found, will try other sources
+	}
+
+	if (!response.ok) {
+		throw new Error(`Failed to fetch your project: ${response.status}`);
+	}
+
+	const zipData = await response.arrayBuffer();
+	const metadata = extractMetadataFromZip(zipData);
+	const files = extractZipToFiles(zipData);
+
+	return {
+		description: (metadata.description as string) || `Your project: ${slug}`,
+		secrets: (metadata.secrets as string[]) || [],
+		optionalSecrets: metadata.optionalSecrets as Template["optionalSecrets"],
+		capabilities: metadata.capabilities as Template["capabilities"],
+		requires: metadata.requires as Template["requires"],
+		hooks: metadata.hooks as Template["hooks"],
+		agentContext: metadata.agentContext as Template["agentContext"],
+		intent: metadata.intent as Template["intent"],
+		files,
+	};
+}
+
 /**
- * Resolve template by name or GitHub URL
+ * Resolve template by name
  */
 export async function resolveTemplate(template?: string): Promise<Template> {
 	// No template → hello (omakase default)
@@ -111,14 +223,26 @@ export async function resolveTemplate(template?: string): Promise<Template> {
 		return loadTemplate(template);
 	}
 
-	// GitHub: user/repo or full URL → fetch from network
+	// username/slug format - fetch from jack cloud
 	if (template.includes("/")) {
-		const { fetchFromGitHub } = await import("../lib/github");
-		return fetchFromGitHub(template);
+		const [username, slug] = template.split("/", 2);
+		return fetchPublishedTemplate(username, slug);
+	}
+
+	// Try as user's own project first
+	try {
+		const userTemplate = await fetchUserTemplate(template);
+		if (userTemplate) {
+			return userTemplate;
+		}
+	} catch (_err) {
+		// If auth fails or project not found, fall through to error
 	}
 
 	// Unknown template
-	throw new Error(`Unknown template: ${template}\n\nAvailable: ${BUILTIN_TEMPLATES.join(", ")}`);
+	throw new Error(
+		`Unknown template: ${template}\n\nAvailable built-in templates: ${BUILTIN_TEMPLATES.join(", ")}\nOr use username/slug format for published projects`,
+	);
 }
 
 /**
@@ -131,9 +255,15 @@ export async function resolveTemplateWithOrigin(
 	const templateName = templateOption || "hello";
 
 	// Determine origin type
-	const isGitHub = templateName.includes("/");
+	let originType: "builtin" | "user" | "published" = "builtin";
+	if (templateOption?.includes("/")) {
+		originType = "published";
+	} else if (templateOption && !BUILTIN_TEMPLATES.includes(templateOption)) {
+		originType = "user";
+	}
+
 	const origin: TemplateOrigin = {
-		type: isGitHub ? "github" : "builtin",
+		type: originType,
 		name: templateName,
 	};