@getjack/jack 0.1.34 → 0.1.35

package/README.md

@@ -27,7 +27,8 @@ But first: config files, deployment setup, secret management, debugging infrastr
 jack removes the friction between your idea and a live URL.
 
 ```bash
-bunx @getjack/jack new my-app   # → deployed. live. done.
+curl -fsSL docs.getjack.org/install.sh | bash
+jack new my-app   # → deployed. live. done.
 ```
 
 That's it. Write code. Ship again with `jack ship`. Stay in flow.
@@ -51,15 +52,14 @@ That's it. Write code. Ship again with `jack ship`. Stay in flow.
 ## Quick Start
 
 ```bash
-# One command to create and deploy
-bunx @getjack/jack new my-app
+# Install (CLI + MCP for your AI editor)
+curl -fsSL docs.getjack.org/install.sh | bash
 
-# Or install globally
-bun add -g @getjack/jack
+# Create and deploy
 jack new my-app
 ```
 
-You'll need [Bun](https://bun.sh) and a Cloudflare account (free tier works).
+Or try without installing: `npx -y @getjack/jack new my-app`
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.34",
+	"version": "0.1.35",
 	"description": "Ship before you forget why you started. The vibecoder's deployment CLI.",
 	"license": "Apache-2.0",
 	"type": "module",

package/src/commands/down.ts

@@ -16,6 +16,7 @@ import { unregisterPath } from "../lib/paths-index.ts";
 import { type LocalProjectLink, readProjectLink, unlinkProject } from "../lib/project-link.ts";
 import { resolveProject } from "../lib/project-resolver.ts";
 import { parseWranglerResources } from "../lib/resources.ts";
+import { deleteProject } from "../lib/services/project-delete.ts";
 import { deleteCloudProject, getProjectNameFromDir } from "../lib/storage/index.ts";
 
 /**
@@ -124,10 +125,33 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 				process.exit(1);
 			}
 
-			// Route to managed deletion flow
-			const deleteSuccess = await managedDown({ projectId, runjackUrl, localPath }, name, flags);
-			if (!deleteSuccess) {
-				process.exit(0); // User cancelled
+			if (flags.force) {
+				// Force mode: full teardown via shared service
+				const projectDir = resolved?.localPath ?? process.cwd();
+				console.error("");
+				info(`Undeploying '${name}'`);
+				console.error("");
+
+				output.start("Undeploying from jack cloud...");
+				const result = await deleteProject(projectDir, { exportDatabase: false });
+				output.stop();
+
+				for (const w of result.warnings) {
+					warn(w);
+				}
+
+				console.error("");
+				success(`'${name}' undeployed`);
+				if (result.databaseDeleted) {
+					info("Database and all resources were deleted");
+				}
+				console.error("");
+			} else {
+				// Interactive mode: use managedDown with prompts
+				const deleteSuccess = await managedDown({ projectId, runjackUrl, localPath }, name, flags);
+				if (!deleteSuccess) {
+					process.exit(0); // User cancelled
+				}
 			}
 
 			// Clean up local tracking state (only if project has local path)
@@ -162,19 +186,27 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			return;
 		}
 
-		// Force mode - quick deletion without prompts
+		// Force mode - full teardown (worker + database) without prompts
 		if (flags.force) {
 			console.error("");
 			info(`Undeploying '${name}'`);
 			console.error("");
 
 			output.start("Undeploying...");
-			await deleteWorker(name);
+			const forceResult = await deleteProject(resolved?.localPath ?? process.cwd(), {
+				exportDatabase: false,
+			});
 			output.stop();
 
+			for (const w of forceResult.warnings) {
+				warn(w);
+			}
+
 			console.error("");
 			success(`'${name}' undeployed`);
-			info("Databases and backups were not affected");
+			if (forceResult.databaseDeleted && forceResult.databaseName) {
+				info(`Database '${forceResult.databaseName}' was also deleted`);
+			}
 			console.error("");
 			return;
 		}

package/src/commands/link.ts

@@ -47,10 +47,8 @@ export default async function link(projectName?: string, flags: LinkFlags = {}):
 	}
 
 	// Check for wrangler config
-	const hasWranglerConfig =
-		existsSync("wrangler.jsonc") || existsSync("wrangler.json") || existsSync("wrangler.toml");
-
-	if (!hasWranglerConfig) {
+	const { hasWranglerConfig } = await import("../lib/wrangler-config.ts");
+	if (!hasWranglerConfig(process.cwd())) {
 		error("No wrangler config found");
 		console.error("");
 		info("Jack needs a wrangler.toml or wrangler.jsonc to deploy.");

package/src/commands/logs.ts

@@ -80,10 +80,8 @@ export default async function logs(options: LogsOptions = {}): Promise<void> {
 	}
 
 	// BYOC requires a wrangler config in the working directory.
-	const hasWranglerJson = existsSync("wrangler.jsonc") || existsSync("wrangler.json");
-	const hasWranglerToml = existsSync("wrangler.toml");
-
-	if (!hasWranglerJson && !hasWranglerToml) {
+	const { hasWranglerConfig } = await import("../lib/wrangler-config.ts");
+	if (!hasWranglerConfig(process.cwd())) {
 		output.error("No wrangler config found");
 		output.info("Run this from a jack project directory");
 		process.exit(1);

package/src/commands/mcp.ts

@@ -126,18 +126,17 @@ async function parseWranglerBindings(cwd: string): Promise<{
 	kv: string[];
 } | null> {
 	try {
-		const jsoncPath = join(cwd, "wrangler.jsonc");
-		const tomlPath = join(cwd, "wrangler.toml");
+		const { findWranglerConfig } = await import("../lib/wrangler-config.ts");
+		const { parseJsonc } = await import("../lib/jsonc.ts");
+		const configPath = findWranglerConfig(cwd);
+		if (!configPath) return null;
+
+		const content = await readFile(configPath, "utf-8");
 
 		let config: Record<string, unknown> | null = null;
 
-		if (existsSync(jsoncPath)) {
-			const content = await readFile(jsoncPath, "utf-8");
-			const jsonContent = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
-			config = JSON.parse(jsonContent);
-		} else if (existsSync(tomlPath)) {
+		if (configPath.endsWith(".toml")) {
 			// For toml, just check for key patterns — not worth a full parser here
-			const content = await readFile(tomlPath, "utf-8");
 			return {
 				databases: content.includes("d1_databases") ? ["(see wrangler.toml)"] : [],
 				buckets: content.includes("r2_buckets") ? ["(see wrangler.toml)"] : [],
@@ -147,6 +146,7 @@ async function parseWranglerBindings(cwd: string): Promise<{
 			};
 		}
 
+		config = parseJsonc<Record<string, unknown>>(content);
 		if (!config) return null;
 
 		const databases =
@@ -198,8 +198,10 @@ async function outputProjectContext(): Promise<void> {
 
 		// --- Section 1: Project identity ---
 		const lines = [`# Jack Project: ${name}`, ""];
-		if (link.deploy_mode === "managed" && link.owner_username) {
-			lines.push(`- **URL:** https://${link.owner_username}-${name}.runjack.xyz`);
+		if (link.deploy_mode === "managed") {
+			const { buildManagedUrl } = await import("../lib/project-link.ts");
+			const url = await buildManagedUrl(name, link.owner_username, cwd);
+			lines.push(`- **URL:** ${url}`);
 		}
 		lines.push(`- **Project ID:** ${link.project_id}`);
 		lines.push(

package/src/commands/services.ts

@@ -517,8 +517,10 @@ async function dbDelete(options: ServiceOptions): Promise<void> {
 		// Remove binding from wrangler.jsonc (both modes)
 		// Note: We need to find the LOCAL database_name from wrangler.jsonc,
 		// which may differ from the control plane's resource_name
-		const { removeD1Binding, getExistingD1Bindings } = await import("../lib/wrangler-config.ts");
-		const configPath = join(projectDir, "wrangler.jsonc");
+		const { removeD1Binding, getExistingD1Bindings, findWranglerConfig } = await import(
+			"../lib/wrangler-config.ts"
+		);
+		const configPath = findWranglerConfig(projectDir) ?? join(projectDir, "wrangler.jsonc");
 
 		let bindingRemoved = false;
 		try {

package/src/commands/sync.ts

@@ -1,4 +1,3 @@
-import { existsSync } from "node:fs";
 import { getSyncConfig } from "../lib/config.ts";
 import { error, info, spinner, success, warn } from "../lib/output.ts";
 import { readProjectLink } from "../lib/project-link.ts";
@@ -10,17 +9,17 @@ export interface SyncFlags {
 	force?: boolean;
 }
 
-function hasWranglerConfig(): boolean {
-	return (
-		existsSync("./wrangler.toml") || existsSync("./wrangler.jsonc") || existsSync("./wrangler.json")
-	);
+import { hasWranglerConfig } from "../lib/wrangler-config.ts";
+
+function hasWranglerConfigInCwd(): boolean {
+	return hasWranglerConfig(process.cwd());
 }
 
 export default async function sync(flags: SyncFlags = {}): Promise<void> {
 	const { verbose = false, dryRun = false, force = false } = flags;
 
 	// Check for wrangler config
-	if (!hasWranglerConfig()) {
+	if (!hasWranglerConfigInCwd()) {
 		error("Not in a project directory");
 		info("Run jack new <name> to create a project");
 		process.exit(1);

package/src/lib/auth/client.ts

@@ -110,9 +110,12 @@ export async function getValidAccessToken(): Promise<string | null> {
 }
 
 export async function authFetch(url: string, options: RequestInit = {}): Promise<Response> {
-	const token = await getValidAccessToken();
+	let token = await getValidAccessToken();
 	if (!token) {
-		throw new Error("Not authenticated. Run 'jack login' or set JACK_API_TOKEN.");
+		// Auto-trigger login flow (works in both CLI and MCP contexts —
+		// all output goes to stderr, interactive prompts auto-skip when not TTY)
+		const { requireAuthOrLogin } = await import("./guard.ts");
+		token = await requireAuthOrLogin();
 	}
 
 	return fetch(url, {

package/src/lib/binding-validator.ts

@@ -20,6 +20,7 @@ export const SUPPORTED_BINDINGS = [
 	"r2_buckets",
 	"kv_namespaces",
 	"vectorize",
+	"durable_objects",
 ] as const;
 
 /**
@@ -27,7 +28,6 @@ export const SUPPORTED_BINDINGS = [
  * These will cause validation errors if present in wrangler config.
  */
 export const UNSUPPORTED_BINDINGS = [
-	"durable_objects",
 	"queues",
 	"services",
 	"hyperdrive",
@@ -39,7 +39,6 @@ export const UNSUPPORTED_BINDINGS = [
  * Human-readable names for unsupported bindings.
  */
 const BINDING_DISPLAY_NAMES: Record<string, string> = {
-	durable_objects: "Durable Objects",
 	queues: "Queues",
 	services: "Service Bindings",
 	hyperdrive: "Hyperdrive",
@@ -71,11 +70,48 @@ 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, KV, Vectorize, 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, Vectorize, Durable Objects, vars.\n  Fix: Remove ${binding} from wrangler.jsonc, or use 'wrangler deploy' for full control.`,
 			);
 		}
 	}
 
+	// Validate Durable Object constraints
+	if (config.durable_objects?.bindings?.length) {
+		const doBindings = config.durable_objects.bindings;
+
+		// Max 3 DO classes per project (free tier)
+		if (doBindings.length > 3) {
+			errors.push(
+				`✗ Too many Durable Object classes (${doBindings.length}).\n  Free tier allows max 3 DO classes per project.\n  Fix: Remove unused DO classes from wrangler.jsonc.`,
+			);
+		}
+
+		// Only allow new_sqlite_classes (not legacy new_classes)
+		if (config.migrations?.length) {
+			for (const migration of config.migrations) {
+				if ((migration as Record<string, unknown>).new_classes) {
+					errors.push(
+						"✗ Only new_sqlite_classes migrations are supported.\n  Fix: Replace new_classes with new_sqlite_classes in wrangler.jsonc.",
+					);
+				}
+			}
+		}
+
+		// Reject __JACK_ prefixed binding or class names
+		for (const dob of doBindings) {
+			if (dob.name.startsWith("__JACK_")) {
+				errors.push(
+					`✗ Binding name "${dob.name}" uses reserved __JACK_ prefix.\n  Fix: Use a different binding name.`,
+				);
+			}
+			if (dob.class_name.startsWith("__JACK_")) {
+				errors.push(
+					`✗ Class name "${dob.class_name}" uses reserved __JACK_ prefix.\n  Fix: Use a different class name.`,
+				);
+			}
+		}
+	}
+
 	// Validate assets directory if configured
 	const assetsValidation = validateAssetsDirectory(config, projectPath);
 	if (!assetsValidation.valid) {

package/src/lib/build-helper.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { mkdir, readFile, readdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
@@ -6,19 +6,7 @@ import { $ } from "bun";
 import { JackError, JackErrorCode } from "./errors.ts";
 import { parseJsonc } from "./jsonc.ts";
 import type { OperationReporter } from "./project-operations.ts";
-
-/**
- * Get the wrangler config file path for a project
- */
-function getWranglerConfigPath(projectPath: string): string | null {
-	const configs = ["wrangler.jsonc", "wrangler.toml", "wrangler.json"];
-	for (const config of configs) {
-		if (existsSync(join(projectPath, config))) {
-			return config;
-		}
-	}
-	return null;
-}
+import { findWranglerConfig } from "./wrangler-config.ts";
 
 export interface BuildOutput {
 	outDir: string;
@@ -64,8 +52,19 @@ export interface WranglerConfig {
 		dimensions?: number;
 		metric?: "cosine" | "euclidean" | "dot-product";
 	}>;
+	durable_objects?: {
+		bindings: Array<{
+			name: string;
+			class_name: string;
+		}>;
+	};
+	migrations?: Array<{
+		tag: string;
+		new_sqlite_classes?: string[];
+		deleted_classes?: string[];
+		renamed_classes?: Array<{ from: string; to: string }>;
+	}>;
 	// Unsupported bindings (for validation)
-	durable_objects?: unknown;
 	queues?: unknown;
 	services?: unknown;
 	hyperdrive?: unknown;
@@ -79,12 +78,12 @@ export interface WranglerConfig {
  * @returns Parsed wrangler configuration
  */
 export async function parseWranglerConfig(projectPath: string): Promise<WranglerConfig> {
-	const wranglerPath = join(projectPath, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectPath);
 
-	if (!existsSync(wranglerPath)) {
+	if (!wranglerPath) {
 		throw new JackError(
 			JackErrorCode.VALIDATION_ERROR,
-			"wrangler.jsonc not found",
+			"wrangler config not found",
 			"Ensure your project has a wrangler.jsonc configuration file",
 		);
 	}
@@ -214,7 +213,7 @@ export async function buildProject(options: BuildOptions): Promise<BuildOutput>
 	// Run wrangler dry-run to build without deploying
 	reporter?.start("Bundling runtime...");
 
-	const configFile = getWranglerConfigPath(projectPath);
+	const configFile = findWranglerConfig(projectPath);
 	const configArg = configFile ? ["--config", configFile] : [];
 	const dryRunResult = await $`wrangler deploy ${configArg} --dry-run --outdir=${outDir}`
 		.cwd(projectPath)

package/src/lib/control-plane.ts

@@ -528,6 +528,7 @@ export async function rollbackDeployment(
 	return response.json() as Promise<RollbackResponse>;
 }
 
+
 /**
  * Create a resource for a managed project.
  * Uses POST /v1/projects/:id/resources/:type endpoint.

package/src/lib/do-config.ts

@@ -0,0 +1,110 @@
+/**
+ * Durable Objects prerequisite auto-fix.
+ *
+ * Ensures wrangler.jsonc has nodejs_compat and migrations for all
+ * declared DO classes, modifying the file in place when needed.
+ */
+
+import type { WranglerConfig } from "./build-helper.ts";
+import { addSectionBeforeClosingBrace, findMatchingBracket } from "./jsonc-edit.ts";
+
+/**
+ * Ensure `compatibility_flags` includes `"nodejs_compat"`.
+ * Adds the flag (or the entire section) if missing.
+ *
+ * @returns true if the file was modified
+ */
+export async function ensureNodejsCompat(
+	configPath: string,
+	config: WranglerConfig,
+): Promise<boolean> {
+	const flags = config.compatibility_flags ?? [];
+	if (flags.includes("nodejs_compat")) return false;
+
+	let content = await Bun.file(configPath).text();
+
+	if (config.compatibility_flags) {
+		// Array exists but missing nodejs_compat — append to it
+		const match = content.match(/"compatibility_flags"\s*:\s*\[/);
+		if (!match || match.index === undefined) {
+			throw new Error("compatibility_flags exists in parsed config but not found in raw JSONC");
+		}
+
+		const arrayOpen = match.index + match[0].length;
+		const closingBracket = findMatchingBracket(content, arrayOpen - 1, "[", "]");
+		if (closingBracket === -1) {
+			throw new Error("Could not find closing bracket for compatibility_flags array");
+		}
+
+		const inner = content.slice(arrayOpen, closingBracket).trim();
+		const insertion = inner.length > 0 ? `, "nodejs_compat"` : `"nodejs_compat"`;
+
+		content = content.slice(0, closingBracket) + insertion + content.slice(closingBracket);
+	} else {
+		// No compatibility_flags at all — add the section
+		content = addSectionBeforeClosingBrace(content, `"compatibility_flags": ["nodejs_compat"]`);
+	}
+
+	await Bun.write(configPath, content);
+	return true;
+}
+
+/**
+ * Ensure every declared DO class has a corresponding migration entry
+ * with `new_sqlite_classes`. Only adds — never modifies existing migrations.
+ *
+ * @returns names of classes that were auto-migrated (empty = nothing done)
+ */
+export async function ensureMigrations(
+	configPath: string,
+	config: WranglerConfig,
+): Promise<string[]> {
+	const bindings = config.durable_objects?.bindings;
+	if (!bindings?.length) return [];
+
+	const declaredClasses = bindings.map((b) => b.class_name);
+
+	// Collect classes already covered by existing migrations
+	const coveredClasses = new Set<string>();
+	if (config.migrations) {
+		for (const m of config.migrations) {
+			for (const c of m.new_sqlite_classes ?? []) coveredClasses.add(c);
+		}
+	}
+
+	const uncovered = declaredClasses.filter((c) => !coveredClasses.has(c));
+	if (uncovered.length === 0) return [];
+
+	let content = await Bun.file(configPath).text();
+
+	if (!config.migrations?.length) {
+		// No migrations section — create one
+		const migrationJson = JSON.stringify(
+			[{ tag: "v1", new_sqlite_classes: uncovered }],
+			null,
+			"\t\t",
+		).replace(/\n/g, "\n\t");
+
+		content = addSectionBeforeClosingBrace(content, `"migrations": ${migrationJson}`);
+	} else {
+		// Migrations exist — append a new step
+		const match = content.match(/"migrations"\s*:\s*\[/);
+		if (!match || match.index === undefined) {
+			throw new Error("migrations exists in parsed config but not found in raw JSONC");
+		}
+
+		const arrayOpen = match.index + match[0].length;
+		const closingBracket = findMatchingBracket(content, arrayOpen - 1, "[", "]");
+		if (closingBracket === -1) {
+			throw new Error("Could not find closing bracket for migrations array");
+		}
+
+		const nextTag = `v${config.migrations.length + 1}`;
+		const stepJson = JSON.stringify({ tag: nextTag, new_sqlite_classes: uncovered });
+
+		content = `${content.slice(0, closingBracket)},\n\t\t${stepJson}${content.slice(closingBracket)}`;
+	}
+
+	await Bun.write(configPath, content);
+	return uncovered;
+}

package/src/lib/do-export-validator.ts

@@ -0,0 +1,26 @@
+/**
+ * Validates that declared DO classes are actually exported from the built JS.
+ */
+
+import { join } from "node:path";
+
+/**
+ * Check built JS exports against declared DO class names.
+ *
+ * Uses Bun's transpiler to scan exports without executing the code.
+ *
+ * @returns class names NOT found in exports (empty = all good)
+ */
+export async function validateDoExports(
+	outDir: string,
+	entrypoint: string,
+	classNames: string[],
+): Promise<string[]> {
+	const filePath = join(outDir, entrypoint);
+	const code = await Bun.file(filePath).text();
+
+	const transpiler = new Bun.Transpiler({ loader: "js" });
+	const { exports } = transpiler.scan(code);
+
+	return classNames.filter((name) => !exports.includes(name));
+}