@getjack/jack 0.1.6 → 0.1.8

package/package.json

@@ -1,13 +1,16 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.6",
+	"version": "0.1.8",
 	"description": "Ship before you forget why you started. The vibecoder's deployment CLI.",
 	"license": "Apache-2.0",
 	"type": "module",
 	"bin": {
 		"jack": "./src/index.ts"
 	},
-	"files": ["src", "templates"],
+	"files": [
+		"src",
+		"templates"
+	],
 	"engines": {
 		"bun": ">=1.0.0"
 	},
@@ -44,6 +47,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/down.ts

@@ -62,6 +62,7 @@ export interface DownFlags {
 export default async function down(projectName?: string, flags: DownFlags = {}): Promise<void> {
 	try {
 		// Get project name
+		const hasExplicitName = Boolean(projectName);
 		let name = projectName;
 		if (!name) {
 			try {
@@ -74,10 +75,12 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 		}
 
 		// Resolve project from all sources (local link + control plane)
-		const resolved = await resolveProject(name);
+		const resolved = await resolveProject(name, {
+			preferLocalLink: !hasExplicitName,
+		});
 
-		// Read local project link
-		const link = await readProjectLink(process.cwd());
+		// Read local project link (only when no explicit name provided)
+		const link = hasExplicitName ? null : await readProjectLink(process.cwd());
 
 		// Check if found only on control plane (orphaned managed project)
 		if (resolved?.sources.controlPlane && !resolved.sources.filesystem) {
@@ -85,6 +88,20 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			info(`Found "${name}" on jack cloud, linking locally...`);
 		}
 
+
+		// Guard against mismatched resolutions when an explicit name is provided
+		if (hasExplicitName && resolved) {
+			const matches =
+				name === resolved.slug ||
+				name === resolved.name ||
+				name === resolved.remote?.projectId;
+			if (!matches) {
+				error(`Refusing to undeploy '${name}' because it resolves to '${resolved.slug}'.`);
+				info("Use the exact slug/name shown by 'jack info' and try again.");
+				process.exit(1);
+			}
+		}
+
 		if (!resolved && !link) {
 			// Not found anywhere
 			warn(`Project '${name}' not found`);

package/src/commands/mcp.ts

@@ -1,7 +1,13 @@
 import { spawn } from "node:child_process";
+import { rm, mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { error, info, success } from "../lib/output.ts";
 import { startMcpServer } from "../mcp/server.ts";
 
+const cliRoot = fileURLToPath(new URL("../..", import.meta.url));
+
 interface McpOptions {
 	project?: string;
 	debug?: boolean;
@@ -32,10 +38,19 @@ export default async function mcp(subcommand?: string, options: McpOptions = {})
  * Test MCP server by spawning it and sending test requests
  */
 async function testMcpServer(): Promise<void> {
+	const configDir = await mkdtemp(join(tmpdir(), "jack-config-"));
+
 	info("Testing MCP server...\n");
 
-	const proc = spawn("./src/index.ts", ["mcp", "serve"], {
+	const proc = spawn("bun", ["run", "src/index.ts", "mcp", "serve"], {
 		stdio: ["pipe", "pipe", "pipe"],
+		cwd: cliRoot,
+		env: {
+			...process.env,
+			CI: "1",
+			JACK_TELEMETRY_DISABLED: "1",
+			JACK_CONFIG_DIR: configDir,
+		},
 	});
 
 	const results: { test: string; passed: boolean; error?: string }[] = [];
@@ -126,6 +141,7 @@ async function testMcpServer(): Promise<void> {
 		error(`   ✗ Error: ${errorMsg}`);
 	} finally {
 		proc.kill();
+		await rm(configDir, { recursive: true, force: true });
 	}
 
 	// Summary

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/agent-files.ts

@@ -21,7 +21,6 @@ This project is deployed to Cloudflare Workers using jack:
 \`\`\`bash
 jack ship    # Deploy to Cloudflare Workers
 jack logs    # Stream production logs
-jack dev     # Start local development server
 \`\`\`
 
 All deployment is handled by jack. Never run \`wrangler\` commands directly.
@@ -42,7 +41,6 @@ See [AGENTS.md](./AGENTS.md) for complete project context and deployment instruc
 
 - **Deploy**: \`jack ship\` - Deploy to Cloudflare Workers
 - **Logs**: \`jack logs\` - Stream production logs
-- **Dev**: \`jack dev\` - Start local development server
 
 ## Important
 

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(
@@ -158,19 +172,19 @@ export async function buildProject(options: BuildOptions): Promise<BuildOutput>
 	// Check if OpenNext build is needed (Next.js + Cloudflare)
 	const hasOpenNext = await needsOpenNextBuild(projectPath);
 	if (hasOpenNext) {
-		reporter?.start("Building...");
+		reporter?.start("Building assets...");
 		await runOpenNextBuild(projectPath);
 		reporter?.stop();
-		reporter?.success("Built");
+		reporter?.success("Built assets");
 	}
 
 	// Check if Vite build is needed and run it (skip if OpenNext already built)
 	const hasVite = await needsViteBuild(projectPath);
 	if (hasVite && !hasOpenNext) {
-		reporter?.start("Building...");
+		reporter?.start("Building assets...");
 		await runViteBuild(projectPath);
 		reporter?.stop();
-		reporter?.success("Built");
+		reporter?.success("Built assets");
 	}
 
 	// Create unique temp directory for build output
@@ -179,7 +193,7 @@ export async function buildProject(options: BuildOptions): Promise<BuildOutput>
 	await mkdir(outDir, { recursive: true });
 
 	// Run wrangler dry-run to build without deploying
-	reporter?.start("Building worker...");
+	reporter?.start("Bundling runtime...");
 
 	const dryRunResult = await $`wrangler deploy --dry-run --outdir=${outDir}`
 		.cwd(projectPath)
@@ -201,7 +215,7 @@ export async function buildProject(options: BuildOptions): Promise<BuildOutput>
 	}
 
 	reporter?.stop();
-	reporter?.success("Built worker");
+	reporter?.success("Bundled runtime");
 
 	const entrypoint = await resolveEntrypoint(outDir, config.main);
 
@@ -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,120 @@
+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":
+			// Check if this is a Vite + Worker hybrid (has entryPoint)
+			if (entryPoint) {
+				// Hybrid mode: Vite frontend + custom Worker backend
+				return {
+					name: projectName,
+					main: entryPoint,
+					compatibility_date: COMPATIBILITY_DATE,
+					assets: {
+						directory: "./dist",
+						binding: "ASSETS",
+					},
+				};
+			}
+			// 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, "");
+}

package/src/lib/config.ts

@@ -40,7 +40,8 @@ export interface JackConfig {
 	sync?: SyncConfig;
 }
 
-export const CONFIG_DIR = join(homedir(), ".config", "jack");
+const DEFAULT_CONFIG_DIR = join(homedir(), ".config", "jack");
+export const CONFIG_DIR = process.env.JACK_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
 export const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 
 /**

package/src/lib/control-plane.ts

@@ -70,6 +70,12 @@ export interface UserProfile {
 	updated_at: string;
 }
 
+export interface PublishProjectResponse {
+	success: boolean;
+	published_as: string;
+	fork_command: string;
+}
+
 export interface CreateDeploymentRequest {
 	source: string;
 }
@@ -187,6 +193,7 @@ export interface ManagedProject {
 	created_at: string;
 	updated_at: string;
 	tags?: string; // JSON string array from DB, e.g., '["backend", "api"]'
+	owner_username?: string | null;
 }
 
 /**
@@ -430,3 +437,57 @@ export async function getCurrentUserProfile(): Promise<UserProfile | null> {
 		return null;
 	}
 }
+
+export interface SourceSnapshotResponse {
+	success: boolean;
+	source_key: string;
+}
+
+/**
+ * Upload a source snapshot for a project.
+ * Used to enable project forking.
+ */
+export async function uploadSourceSnapshot(
+	projectId: string,
+	sourceZipPath: string,
+): Promise<SourceSnapshotResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const formData = new FormData();
+	const sourceFile = Bun.file(sourceZipPath);
+	formData.append("source", sourceFile);
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/source`, {
+		method: "POST",
+		body: formData,
+	});
+
+	if (!response.ok) {
+		const error = (await response.json().catch(() => ({ message: "Upload failed" }))) as {
+			message?: string;
+		};
+		throw new Error(error.message || `Source upload failed: ${response.status}`);
+	}
+
+	return response.json() as Promise<SourceSnapshotResponse>;
+}
+
+/**
+ * Publish a project to make it forkable by others.
+ */
+export async function publishProject(projectId: string): Promise<PublishProjectResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/publish`, {
+		method: "POST",
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to publish project: ${response.status}`);
+	}
+
+	return response.json() as Promise<PublishProjectResponse>;
+}

package/src/lib/managed-deploy.ts

@@ -6,7 +6,8 @@
 
 import { validateBindings } from "./binding-validator.ts";
 import { buildProject, parseWranglerConfig } from "./build-helper.ts";
-import { createManagedProject, syncProjectTags } from "./control-plane.ts";
+import { createManagedProject, syncProjectTags, uploadSourceSnapshot } from "./control-plane.ts";
+import { debug } from "./debug.ts";
 import { uploadDeployment } from "./deploy-upload.ts";
 import { JackError, JackErrorCode } from "./errors.ts";
 import type { OperationReporter } from "./project-operations.ts";
@@ -48,7 +49,7 @@ export async function createManagedProjectRemote(
 			usePrebuilt: options?.usePrebuilt ?? true,
 		});
 
-		const runjackUrl = `https://${result.project.slug}.runjack.xyz`;
+		const runjackUrl = result.url || `https://${result.project.slug}.runjack.xyz`;
 
 		reporter?.stop();
 		reporter?.success("Created managed project");
@@ -148,6 +149,13 @@ export async function deployCodeToManagedProject(
 			})
 			.catch(() => {});
 
+		// Upload source snapshot for forking (non-fatal, but must await before cleanup)
+		try {
+			await uploadSourceSnapshot(projectId, pkg.sourceZipPath);
+		} catch (err) {
+			debug("Source snapshot upload failed:", err instanceof Error ? err.message : String(err));
+		}
+
 		return {
 			deploymentId: result.id,
 			status: result.status,