@getjack/jack 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.5",
+	"version": "0.1.7",
 	"description": "Ship before you forget why you started. The vibecoder's deployment CLI.",
 	"license": "Apache-2.0",
 	"type": "module",
@@ -44,6 +44,7 @@
 		"@inquirer/prompts": "^7.0.0",
 		"@modelcontextprotocol/sdk": "^1.25.1",
 		"archiver": "^7.0.1",
+		"fflate": "^0.8.2",
 		"human-id": "^4.1.3",
 		"meow": "^14.0.0",
 		"yocto-spinner": "^1.0.0",

package/src/commands/login.ts

@@ -1,6 +1,12 @@
+import { input } from "@inquirer/prompts";
 import { type DeviceAuthResponse, pollDeviceToken, startDeviceAuth } from "../lib/auth/client.ts";
 import { type AuthCredentials, saveCredentials } from "../lib/auth/store.ts";
-import { error, info, spinner, success } from "../lib/output.ts";
+import {
+	checkUsernameAvailable,
+	getCurrentUserProfile,
+	setUsername,
+} from "../lib/control-plane.ts";
+import { error, info, spinner, success, warn } from "../lib/output.ts";
 
 interface LoginOptions {
 	/** Skip the initial "Logging in..." message (used when called from auto-login) */
@@ -69,6 +75,9 @@ export default async function login(options: LoginOptions = {}): Promise<void> {
 
 				console.error("");
 				success(`Logged in as ${tokens.user.email}`);
+
+				// Prompt for username if not set
+				await promptForUsername(tokens.user.email);
 				return;
 			}
 		} catch (err) {
@@ -86,3 +95,117 @@ export default async function login(options: LoginOptions = {}): Promise<void> {
 function sleep(ms: number): Promise<void> {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
+
+async function promptForUsername(email: string): Promise<void> {
+	// Skip in non-TTY environments
+	if (!process.stdout.isTTY) {
+		return;
+	}
+
+	const spin = spinner("Checking account...");
+
+	try {
+		const profile = await getCurrentUserProfile();
+		spin.stop();
+
+		// If user already has a username, skip
+		if (profile?.username) {
+			return;
+		}
+
+		console.error("");
+		info("Choose a username for your jack cloud account.");
+		info("URLs will look like: alice-vibes.runjack.xyz");
+		console.error("");
+
+		// Generate suggestions from $USER env var and email
+		const suggestions = generateUsernameSuggestions(email);
+
+		let username: string | null = null;
+
+		while (!username) {
+			// Show suggestions if available
+			if (suggestions.length > 0) {
+				info(`Suggestions: ${suggestions.join(", ")}`);
+			}
+
+			const inputUsername = await input({
+				message: "Username:",
+				default: suggestions[0],
+				validate: (value) => {
+					if (!value || value.length < 3) {
+						return "Username must be at least 3 characters";
+					}
+					if (value.length > 39) {
+						return "Username must be 39 characters or less";
+					}
+					if (value !== value.toLowerCase()) {
+						return "Username must be lowercase";
+					}
+					if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]{1,2}$/.test(value)) {
+						return "Use only lowercase letters, numbers, and hyphens";
+					}
+					return true;
+				},
+			});
+
+			// Check availability
+			const checkSpin = spinner("Checking availability...");
+			const availability = await checkUsernameAvailable(inputUsername);
+			checkSpin.stop();
+
+			if (!availability.available) {
+				warn(availability.error || `Username "${inputUsername}" is already taken. Try another.`);
+				continue;
+			}
+
+			// Try to set the username
+			const setSpin = spinner("Setting username...");
+			try {
+				await setUsername(inputUsername);
+				setSpin.stop();
+				username = inputUsername;
+				success(`Username set to "${username}"`);
+			} catch (err) {
+				setSpin.stop();
+				warn(err instanceof Error ? err.message : "Failed to set username");
+			}
+		}
+	} catch (err) {
+		spin.stop();
+		// Non-fatal - user can set username later
+		warn("Could not set username. You can set it later.");
+	}
+}
+
+function generateUsernameSuggestions(email: string): string[] {
+	const suggestions: string[] = [];
+
+	// Try $USER environment variable first
+	const envUser = process.env.USER || process.env.USERNAME;
+	if (envUser) {
+		const normalized = normalizeToUsername(envUser);
+		if (normalized && normalized.length >= 3) {
+			suggestions.push(normalized);
+		}
+	}
+
+	// Try email local part
+	const emailLocal = email.split("@")[0];
+	if (emailLocal) {
+		const normalized = normalizeToUsername(emailLocal);
+		if (normalized && normalized.length >= 3 && !suggestions.includes(normalized)) {
+			suggestions.push(normalized);
+		}
+	}
+
+	return suggestions.slice(0, 3); // Max 3 suggestions
+}
+
+function normalizeToUsername(input: string): string {
+	return input
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+		.slice(0, 39);
+}

package/src/commands/projects.ts

@@ -183,7 +183,11 @@ function renderGroupedView(items: ProjectListItem[]): void {
 
 		console.error("");
 		console.error(
-			formatCloudSection(sorted, { limit: CLOUD_LIMIT, total: groups.cloudOnly.length, tagColorMap }),
+			formatCloudSection(sorted, {
+				limit: CLOUD_LIMIT,
+				total: groups.cloudOnly.length,
+				tagColorMap,
+			}),
 		);
 	}
 

package/src/commands/publish.ts

@@ -0,0 +1,50 @@
+import { getCurrentUserProfile, publishProject } from "../lib/control-plane.ts";
+import { output, spinner } from "../lib/output.ts";
+import { readProjectLink } from "../lib/project-link.ts";
+
+export default async function publish(): Promise<void> {
+	// Check we're in a project directory
+	const link = await readProjectLink(process.cwd());
+	if (!link) {
+		output.error("Not in a jack project directory");
+		output.info("Run this command from a directory with a .jack folder");
+		process.exit(1);
+	}
+
+	if (link.deploy_mode !== "managed") {
+		output.error("Only managed projects can be published");
+		output.info("Projects deployed with BYOC (bring your own cloud) cannot be published");
+		process.exit(1);
+	}
+
+	if (!link.project_id) {
+		output.error("Project not linked to jack cloud");
+		output.info("Run: jack ship (to deploy and link the project)");
+		process.exit(1);
+	}
+
+	// Check user has username
+	const profile = await getCurrentUserProfile();
+	if (!profile?.username) {
+		output.error("You need a username to publish projects");
+		output.info("Run: jack login (to set up your username)");
+		process.exit(1);
+	}
+
+	const spin = spinner("Publishing project...");
+
+	try {
+		const result = await publishProject(link.project_id);
+		spin.stop();
+		output.success(`Published as ${result.published_as}`);
+
+		console.error("");
+		output.info("Others can now fork your project:");
+		output.info(`  ${result.fork_command}`);
+	} catch (err) {
+		spin.stop();
+		const message = err instanceof Error ? err.message : "Unknown error";
+		output.error(`Publish failed: ${message}`);
+		process.exit(1);
+	}
+}

package/src/commands/ship.ts

@@ -3,7 +3,7 @@ import { output, spinner } from "../lib/output.ts";
 import { deployProject } from "../lib/project-operations.ts";
 
 export default async function ship(
-	options: { managed?: boolean; byo?: boolean } = {},
+	options: { managed?: boolean; byo?: boolean; dryRun?: boolean } = {},
 ): Promise<void> {
 	const isCi = process.env.CI === "true" || process.env.CI === "1";
 	try {
@@ -20,10 +20,11 @@ export default async function ship(
 				box: output.box,
 			},
 			interactive: !isCi,
-			includeSecrets: true,
-			includeSync: true,
+			includeSecrets: !options.dryRun,
+			includeSync: !options.dryRun,
 			managed: options.managed,
 			byo: options.byo,
+			dryRun: options.dryRun,
 		});
 
 		if (!result.workerUrl && result.deployOutput) {

package/src/index.ts

@@ -25,6 +25,7 @@ const cli = meow(
     down [name]         Undeploy from cloud
     ls                  List all projects
     info [name]         Show project details
+    publish             Make your project forkable by others
 
   Cloud & Sync
     clone <project>     Pull from cloud backup
@@ -206,6 +207,7 @@ try {
 			)({
 				managed: cli.flags.managed,
 				byo: cli.flags.byo,
+				dryRun: cli.flags.dryRun,
 			});
 			break;
 		}
@@ -264,6 +266,11 @@ try {
 			await withTelemetry("down", down)(args[0], { force: cli.flags.force });
 			break;
 		}
+		case "publish": {
+			const { default: publish } = await import("./commands/publish.ts");
+			await withTelemetry("publish", publish)();
+			break;
+		}
 		case "open": {
 			const { default: open } = await import("./commands/open.ts");
 			await withTelemetry("open", open)(args[0], { dash: cli.flags.dash, logs: cli.flags.logs });

package/src/lib/binding-validator.ts

@@ -12,14 +12,20 @@ import type { WranglerConfig } from "./build-helper.ts";
 /**
  * Bindings supported by jack cloud managed deployments.
  */
-export const SUPPORTED_BINDINGS = ["d1_databases", "ai", "assets", "vars", "r2_buckets"] as const;
+export const SUPPORTED_BINDINGS = [
+	"d1_databases",
+	"ai",
+	"assets",
+	"vars",
+	"r2_buckets",
+	"kv_namespaces",
+] as const;
 
 /**
  * Bindings not yet supported by jack cloud.
  * These will cause validation errors if present in wrangler config.
  */
 export const UNSUPPORTED_BINDINGS = [
-	"kv_namespaces",
 	"durable_objects",
 	"queues",
 	"services",
@@ -33,7 +39,6 @@ export const UNSUPPORTED_BINDINGS = [
  * Human-readable names for unsupported bindings.
  */
 const BINDING_DISPLAY_NAMES: Record<string, string> = {
-	kv_namespaces: "KV Namespaces",
 	durable_objects: "Durable Objects",
 	queues: "Queues",
 	services: "Service Bindings",
@@ -67,7 +72,7 @@ export function validateBindings(
 		if (value !== undefined && value !== null) {
 			const displayName = BINDING_DISPLAY_NAMES[binding] || binding;
 			errors.push(
-				`✗ ${displayName} not supported in managed deploy.\n  Managed deploy supports: D1, AI, Assets, R2, vars.\n  Fix: Remove ${binding} from wrangler.jsonc, or use 'wrangler deploy' for full control.`,
+				`✗ ${displayName} not supported in managed deploy.\n  Managed deploy supports: D1, AI, Assets, R2, KV, vars.\n  Fix: Remove ${binding} from wrangler.jsonc, or use 'wrangler deploy' for full control.`,
 			);
 		}
 	}

package/src/lib/build-helper.ts

@@ -1,4 +1,4 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, readFile, readdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
@@ -40,8 +40,11 @@ export interface WranglerConfig {
 		binding: string;
 		bucket_name: string;
 	}>;
+	kv_namespaces?: Array<{
+		binding: string;
+		id?: string; // Optional - wrangler auto-provisions if missing
+	}>;
 	// Unsupported bindings (for validation)
-	kv_namespaces?: unknown;
 	durable_objects?: unknown;
 	queues?: unknown;
 	services?: unknown;
@@ -103,9 +106,20 @@ export async function needsOpenNextBuild(projectPath: string): Promise<boolean>
  * @throws JackError if build fails
  */
 export async function runViteBuild(projectPath: string): Promise<void> {
-	// Jack controls the build for managed projects (omakase)
-	// Users wanting tsc can run `bun run build` manually before shipping
-	const buildResult = await $`bunx vite build`.cwd(projectPath).nothrow().quiet();
+	// Use local vite if installed to avoid module resolution issues
+	// bunx vite installs to temp dir, but vite.config.js may require('vite') from node_modules
+	// Don't use project's build script - it might do more than just vite build (e.g., Tauri)
+	let buildCommand: string[];
+
+	if (existsSync(join(projectPath, "node_modules", ".bin", "vite"))) {
+		// Local vite installed - use it directly
+		buildCommand = ["bun", "run", "vite", "build"];
+	} else {
+		// Fallback to bunx
+		buildCommand = ["bunx", "vite", "build"];
+	}
+
+	const buildResult = await $`${buildCommand}`.cwd(projectPath).nothrow().quiet();
 
 	if (buildResult.exitCode !== 0) {
 		throw new JackError(
@@ -258,42 +272,50 @@ async function resolveEntrypoint(outDir: string, main?: string): Promise<string>
 }
 
 /**
- * Ensures R2 buckets exist for BYO deploy.
- * Creates buckets via wrangler if they don't exist.
- * @param projectPath - Absolute path to project directory
- * @returns Array of bucket names that were created or already existed
+ * Gets the installed wrangler version.
+ * @returns Version string (e.g., "4.55.0")
  */
-export async function ensureR2Buckets(projectPath: string): Promise<string[]> {
-	const config = await parseWranglerConfig(projectPath);
-
-	if (!config.r2_buckets || config.r2_buckets.length === 0) {
-		return [];
+export async function getWranglerVersion(): Promise<string> {
+	const result = await $`wrangler --version`.nothrow().quiet();
+	if (result.exitCode !== 0) {
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			"wrangler not found",
+			"Install wrangler: npm install -g wrangler",
+		);
 	}
+	// Parse "wrangler 4.55.0" -> "4.55.0"
+	const match = result.stdout.toString().match(/(\d+\.\d+\.\d+)/);
+	return match?.[1] ?? "0.0.0";
+}
 
-	const results: string[] = [];
-
-	for (const bucket of config.r2_buckets) {
-		const bucketName = bucket.bucket_name;
-
-		// Try to create the bucket (wrangler handles "already exists" gracefully)
-		const result = await $`wrangler r2 bucket create ${bucketName}`
-			.cwd(projectPath)
-			.nothrow()
-			.quiet();
-
-		// Exit code 0 = created, non-zero with "already exists" = fine
-		const stderr = result.stderr.toString();
-		if (result.exitCode === 0 || stderr.includes("already exists")) {
-			results.push(bucketName);
-		} else {
-			throw new JackError(
-				JackErrorCode.RESOURCE_ERROR,
-				`Failed to create R2 bucket: ${bucketName}`,
-				"Check your Cloudflare account has R2 enabled",
-				{ stderr },
-			);
-		}
-	}
+const MIN_WRANGLER_VERSION = "4.45.0";
 
-	return results;
+/**
+ * Checks if wrangler version meets minimum requirement for auto-provisioning.
+ * @throws JackError if version is too old
+ */
+export function checkWranglerVersion(version: string): void {
+	const parts = version.split(".").map(Number);
+	const minParts = MIN_WRANGLER_VERSION.split(".").map(Number);
+
+	const major = parts[0] ?? 0;
+	const minor = parts[1] ?? 0;
+	const patch = parts[2] ?? 0;
+	const minMajor = minParts[0] ?? 0;
+	const minMinor = minParts[1] ?? 0;
+	const minPatch = minParts[2] ?? 0;
+
+	const isValid =
+		major > minMajor ||
+		(major === minMajor && minor > minMinor) ||
+		(major === minMajor && minor === minMinor && patch >= minPatch);
+
+	if (!isValid) {
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			`wrangler ${MIN_WRANGLER_VERSION}+ required (found ${version})`,
+			"Run: npm install -g wrangler@latest",
+		);
+	}
 }

package/src/lib/config-generator.ts

@@ -0,0 +1,107 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export type ProjectType = "nextjs" | "vite" | "hono" | "sveltekit" | "worker" | "unknown";
+
+export interface WranglerConfig {
+	name: string;
+	main?: string;
+	compatibility_date: string;
+	assets?: {
+		directory: string;
+		binding?: string;
+	};
+}
+
+const COMPATIBILITY_DATE = "2024-12-01";
+
+export function generateWranglerConfig(
+	projectType: ProjectType,
+	projectName: string,
+	entryPoint?: string,
+): WranglerConfig {
+	switch (projectType) {
+		case "nextjs":
+			return {
+				name: projectName,
+				main: ".open-next/worker.js",
+				compatibility_date: COMPATIBILITY_DATE,
+				assets: {
+					directory: ".open-next/assets",
+					binding: "ASSETS",
+				},
+			};
+
+		case "vite":
+			// Pure Vite SPAs use assets-only mode (no worker entry)
+			// Cloudflare auto-generates a worker that serves static files
+			return {
+				name: projectName,
+				compatibility_date: COMPATIBILITY_DATE,
+				assets: {
+					directory: "./dist",
+				},
+			};
+
+		case "hono":
+			return {
+				name: projectName,
+				main: entryPoint || "src/index.ts",
+				compatibility_date: COMPATIBILITY_DATE,
+			};
+
+		case "sveltekit":
+			return {
+				name: projectName,
+				compatibility_date: COMPATIBILITY_DATE,
+				assets: {
+					directory: "./.svelte-kit/cloudflare",
+				},
+			};
+
+		default:
+			return {
+				name: projectName,
+				main: entryPoint || "src/index.ts",
+				compatibility_date: COMPATIBILITY_DATE,
+			};
+	}
+}
+
+export function writeWranglerConfig(projectPath: string, config: WranglerConfig): void {
+	const header = "// wrangler.jsonc (auto-generated by jack)\n";
+	const json = JSON.stringify(config, null, 2);
+	const content = `${header}${json}\n`;
+	const filePath = path.join(projectPath, "wrangler.jsonc");
+	fs.writeFileSync(filePath, content, "utf-8");
+}
+
+export function getDefaultProjectName(projectPath: string): string {
+	const packageJsonPath = path.join(projectPath, "package.json");
+
+	if (fs.existsSync(packageJsonPath)) {
+		try {
+			const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+			if (packageJson.name && typeof packageJson.name === "string") {
+				const slugified = slugify(packageJson.name);
+				if (slugified) {
+					return slugified;
+				}
+			}
+		} catch {
+			// Fall through to folder name
+		}
+	}
+
+	const folderName = path.basename(path.resolve(projectPath));
+	return slugify(folderName) || "my-project";
+}
+
+export function slugify(name: string): string {
+	return name
+		.toLowerCase()
+		.replace(/[\s_]+/g, "-")
+		.replace(/[^a-z0-9-]/g, "")
+		.replace(/-+/g, "-")
+		.replace(/^-+|-+$/g, "");
+}