@getjack/jack 0.1.33 → 0.1.35

package/src/lib/hooks.ts

@@ -533,8 +533,7 @@ const actionHandlers: {
 					const { isCancel, text } = await import("@clack/prompts");
 					const value = await text({ message: promptMsg });
 
-					if (isCancel(value) || !value.trim()) {
-						ui.warn(`Skipped ${action.key}`);
+					if (isCancel(value) || !value || !value.trim()) {
 						return false;
 					}
 

package/src/lib/jsonc-edit.ts

@@ -0,0 +1,292 @@
+/**
+ * Shared JSONC text-manipulation helpers.
+ *
+ * These operate on raw JSONC strings so that comments and formatting
+ * are preserved when adding/removing sections.
+ */
+
+/**
+ * Find the matching closing bracket/brace for an opening one,
+ * respecting strings and comments.
+ */
+export function findMatchingBracket(
+	content: string,
+	startIndex: number,
+	openChar: string,
+	closeChar: string,
+): number {
+	let depth = 0;
+	let inString = false;
+	let stringChar = "";
+	let escaped = false;
+	let inLineComment = false;
+	let inBlockComment = false;
+
+	for (let i = startIndex; i < content.length; i++) {
+		const char = content[i] ?? "";
+		const next = content[i + 1] ?? "";
+
+		if (inLineComment) {
+			if (char === "\n") inLineComment = false;
+			continue;
+		}
+
+		if (inBlockComment) {
+			if (char === "*" && next === "/") {
+				inBlockComment = false;
+				i++;
+			}
+			continue;
+		}
+
+		if (inString) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === stringChar) {
+				inString = false;
+				stringChar = "";
+			}
+			continue;
+		}
+
+		if (char === "/" && next === "/") {
+			inLineComment = true;
+			i++;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			inBlockComment = true;
+			i++;
+			continue;
+		}
+
+		if (char === '"' || char === "'") {
+			inString = true;
+			stringChar = char;
+			continue;
+		}
+
+		if (char === openChar) {
+			depth++;
+		} else if (char === closeChar) {
+			depth--;
+			if (depth === 0) return i;
+		}
+	}
+
+	return -1;
+}
+
+/**
+ * Check if content is only whitespace and comments.
+ */
+export function isOnlyCommentsAndWhitespace(content: string): boolean {
+	let inLineComment = false;
+	let inBlockComment = false;
+
+	for (let i = 0; i < content.length; i++) {
+		const char = content[i] ?? "";
+		const next = content[i + 1] ?? "";
+
+		if (inLineComment) {
+			if (char === "\n") inLineComment = false;
+			continue;
+		}
+
+		if (inBlockComment) {
+			if (char === "*" && next === "/") {
+				inBlockComment = false;
+				i++;
+			}
+			continue;
+		}
+
+		if (char === "/" && next === "/") {
+			inLineComment = true;
+			i++;
+			continue;
+		}
+
+		if (char === "/" && next === "*") {
+			inBlockComment = true;
+			i++;
+			continue;
+		}
+
+		if (!/\s/.test(char)) return false;
+	}
+
+	return true;
+}
+
+/**
+ * Find the last closing brace of an object within an array range.
+ */
+export function findLastObjectEndInArray(
+	content: string,
+	startIndex: number,
+	endIndex: number,
+): number {
+	let lastBraceIndex = -1;
+	let inString = false;
+	let stringChar = "";
+	let escaped = false;
+	let inLineComment = false;
+	let inBlockComment = false;
+
+	for (let i = startIndex; i < endIndex; i++) {
+		const char = content[i] ?? "";
+		const next = content[i + 1] ?? "";
+
+		if (inLineComment) {
+			if (char === "\n") inLineComment = false;
+			continue;
+		}
+
+		if (inBlockComment) {
+			if (char === "*" && next === "/") {
+				inBlockComment = false;
+				i++;
+			}
+			continue;
+		}
+
+		if (inString) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === stringChar) {
+				inString = false;
+				stringChar = "";
+			}
+			continue;
+		}
+
+		if (char === "/" && next === "/") {
+			inLineComment = true;
+			i++;
+			continue;
+		}
+
+		if (char === "/" && next === "*") {
+			inBlockComment = true;
+			i++;
+			continue;
+		}
+
+		if (char === '"' || char === "'") {
+			inString = true;
+			stringChar = char;
+			continue;
+		}
+
+		if (char === "}") lastBraceIndex = i;
+	}
+
+	return lastBraceIndex;
+}
+
+/**
+ * Find the start of a line comment (//) in a string, respecting strings.
+ */
+export function findLineCommentStart(line: string): number {
+	let inString = false;
+	let stringChar = "";
+	let escaped = false;
+
+	for (let i = 0; i < line.length - 1; i++) {
+		const char = line[i] ?? "";
+		const next = line[i + 1] ?? "";
+
+		if (inString) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === stringChar) {
+				inString = false;
+				stringChar = "";
+			}
+			continue;
+		}
+
+		if (char === '"' || char === "'") {
+			inString = true;
+			stringChar = char;
+			continue;
+		}
+
+		if (char === "/" && next === "/") return i;
+	}
+
+	return -1;
+}
+
+/**
+ * Determine if we need to add a comma before new content.
+ * Looks at the last non-whitespace, non-comment character.
+ */
+export function shouldAddCommaBefore(content: string): boolean {
+	let i = content.length - 1;
+
+	// First pass: find where any trailing line comment starts
+	for (let j = content.length - 1; j >= 0; j--) {
+		if (content[j] === "\n") {
+			const lineStart = content.lastIndexOf("\n", j - 1) + 1;
+			const line = content.slice(lineStart, j);
+			const commentIndex = findLineCommentStart(line);
+			if (commentIndex !== -1) {
+				i = lineStart + commentIndex - 1;
+			}
+			break;
+		}
+	}
+
+	// Skip whitespace
+	while (i >= 0 && /\s/.test(content[i] ?? "")) {
+		i--;
+	}
+
+	if (i < 0) return false;
+
+	const lastChar = content[i];
+	return lastChar !== "{" && lastChar !== "[" && lastChar !== ",";
+}
+
+/**
+ * Add a new top-level section (key + value) to a JSONC file before the
+ * final closing brace, preserving existing comments and formatting.
+ *
+ * @param content  Raw JSONC file content
+ * @param sectionJson  The `"key": value` string to insert (no trailing comma)
+ * @returns Updated file content
+ */
+export function addSectionBeforeClosingBrace(content: string, sectionJson: string): string {
+	const lastBraceIndex = content.lastIndexOf("}");
+	if (lastBraceIndex === -1) {
+		throw new Error("Invalid JSON: no closing brace found");
+	}
+
+	const beforeBrace = content.slice(0, lastBraceIndex);
+	const needsComma = shouldAddCommaBefore(beforeBrace);
+	const trimmedBefore = beforeBrace.trimEnd();
+
+	const insertion = needsComma ? `,\n\t${sectionJson}` : `\n\t${sectionJson}`;
+
+	return `${trimmedBefore + insertion}\n${content.slice(lastBraceIndex)}`;
+}

package/src/lib/managed-deploy.ts

@@ -5,17 +5,21 @@
  */
 
 import { stat } from "node:fs/promises";
+import { join } from "node:path";
 import { validateBindings } from "./binding-validator.ts";
 import { buildProject, parseWranglerConfig } from "./build-helper.ts";
 import { createManagedProject, syncProjectTags } from "./control-plane.ts";
 import { debug } from "./debug.ts";
 import { uploadDeployment } from "./deploy-upload.ts";
+import { ensureMigrations, ensureNodejsCompat } from "./do-config.ts";
+import { validateDoExports } from "./do-export-validator.ts";
 import { JackError, JackErrorCode } from "./errors.ts";
 import { formatSize } from "./format.ts";
 import { createFileCountProgress, createUploadProgress } from "./progress.ts";
 import type { OperationReporter } from "./project-operations.ts";
 import { getProjectTags } from "./tags.ts";
 import { Events, track, trackActivationIfFirst } from "./telemetry.ts";
+import { findWranglerConfig } from "./wrangler-config.ts";
 import { packageForDeploy } from "./zip-packager.ts";
 
 export interface ManagedCreateResult {
@@ -101,12 +105,43 @@ export async function deployCodeToManagedProject(
 	let pkg: Awaited<ReturnType<typeof packageForDeploy>> | null = null;
 
 	try {
-		const config = await parseWranglerConfig(projectPath);
+		let config = await parseWranglerConfig(projectPath);
 
 		// Step 1: Build the project (must happen before validation, as build creates dist/)
 		reporter?.start("Building project...");
 		const buildOutput = await buildProject({ projectPath, reporter });
 
+		// Step 1.5: Auto-fix DO prerequisites (after build so we have output to validate)
+		if (config.durable_objects?.bindings?.length) {
+			const configPath = findWranglerConfig(projectPath) ?? join(projectPath, "wrangler.jsonc");
+			const fixes: string[] = [];
+
+			const addedCompat = await ensureNodejsCompat(configPath, config);
+			if (addedCompat) fixes.push("nodejs_compat");
+
+			const migratedClasses = await ensureMigrations(configPath, config);
+			if (migratedClasses.length > 0) fixes.push(`migrations for ${migratedClasses.join(", ")}`);
+
+			if (fixes.length > 0) {
+				config = await parseWranglerConfig(projectPath);
+				reporter?.success(`Auto-configured: ${fixes.join(", ")}`);
+			}
+
+			// Validate DO class exports
+			const missing = await validateDoExports(
+				buildOutput.outDir,
+				buildOutput.entrypoint,
+				config.durable_objects.bindings.map((b) => b.class_name),
+			);
+			if (missing.length > 0) {
+				throw new JackError(
+					JackErrorCode.VALIDATION_ERROR,
+					`Durable Object class${missing.length > 1 ? "es" : ""} not exported: ${missing.join(", ")}`,
+					missing.map((c) => `Add "export" before "class ${c}" in your source code`).join("\n"),
+				);
+			}
+		}
+
 		// Step 2: Validate bindings are supported (after build, so assets dir exists)
 		const validation = validateBindings(config, projectPath);
 		if (!validation.valid) {

package/src/lib/project-link.ts

@@ -86,6 +86,43 @@ export function generateByoProjectId(): string {
 	return `byo_${uuid}`;
 }
 
+/**
+ * Build the managed project URL for a given slug.
+ *
+ * If the link has owner_username, uses it directly. Otherwise fetches it
+ * from the control plane and backfills the local link for future calls.
+ *
+ * @param slug - Project slug (e.g. "cozy-paws-relate")
+ * @param ownerUsername - Owner username if already known
+ * @param projectDir - Project directory (for backfilling the link). If omitted, no backfill.
+ */
+export async function buildManagedUrl(
+	slug: string,
+	ownerUsername?: string | null,
+	projectDir?: string,
+): Promise<string> {
+	if (ownerUsername) {
+		return `https://${ownerUsername}-${slug}.runjack.xyz`;
+	}
+
+	// Fetch from control plane to resolve owner_username
+	try {
+		const { findProjectBySlug } = await import("./control-plane.ts");
+		const project = await findProjectBySlug(slug);
+		if (project?.owner_username) {
+			// Backfill local link so subsequent calls are fast
+			if (projectDir) {
+				updateProjectLink(projectDir, { owner_username: project.owner_username }).catch(() => {});
+			}
+			return `https://${project.owner_username}-${slug}.runjack.xyz`;
+		}
+	} catch {
+		// Control plane unavailable, fall through
+	}
+
+	return `https://${slug}.runjack.xyz`;
+}
+
 /**
  * Link a local directory to a control plane project (managed)
  * or create a local-only link (BYO with provided/generated ID)

package/src/lib/project-operations.ts

@@ -60,6 +60,7 @@ import { detectProjectType, validateProject } from "./project-detection.ts";
 import {
 	type DeployMode,
 	type TemplateMetadata as TemplateOrigin,
+	buildManagedUrl,
 	generateByoProjectId,
 	linkProject,
 	readProjectLink,
@@ -71,6 +72,7 @@ import { applySchema, getD1Bindings, getD1DatabaseName, hasD1Config } from "./sc
 import { getSavedSecrets, saveSecrets } from "./secrets.ts";
 import { getProjectNameFromDir, getRemoteManifest } from "./storage/index.ts";
 import { Events, track, trackActivationIfFirst } from "./telemetry.ts";
+import { findWranglerConfig, hasWranglerConfig } from "./wrangler-config.ts";
 
 // ============================================================================
 // Type Definitions
@@ -304,20 +306,6 @@ async function promptEnvVars(
 	return result;
 }
 
-/**
- * Get the wrangler config file path for a project
- * Returns the first found: wrangler.jsonc, wrangler.toml, wrangler.json
- */
-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;
-}
-
 /**
  * Run wrangler deploy with explicit config to avoid parent directory conflicts
  */
@@ -325,7 +313,7 @@ async function runWranglerDeploy(
 	projectPath: string,
 	options: { dryRun?: boolean; outDir?: string } = {},
 ) {
-	const configFile = getWranglerConfigPath(projectPath);
+	const configFile = findWranglerConfig(projectPath);
 	const configArg = configFile ? ["--config", configFile] : [];
 	const dryRunArgs = options.dryRun
 		? ["--dry-run", ...(options.outDir ? ["--outdir", options.outDir] : [])]
@@ -797,10 +785,18 @@ export async function createProject(
 			? resolve(targetDirOption, name)
 			: join(getJackHome(), name);
 		if (existsSync(effectiveTargetDir)) {
+			const existingLink = await readProjectLink(effectiveTargetDir);
+			if (existingLink) {
+				throw new JackError(
+					JackErrorCode.VALIDATION_ERROR,
+					`'${name}' already exists`,
+					`cd ${effectiveTargetDir} && jack ship  to deploy it, or  rm -rf ${effectiveTargetDir}  to start fresh.`,
+				);
+			}
 			throw new JackError(
 				JackErrorCode.VALIDATION_ERROR,
-				`Folder exists at ${effectiveTargetDir}/`,
-				"Remove it first, or use 'jack ship' if it's a project.",
+				`Folder already exists at ${effectiveTargetDir}/`,
+				"Remove it or pick a different name.",
 			);
 		}
 	}
@@ -873,10 +869,18 @@ export async function createProject(
 
 	// Check directory doesn't exist (only needed for auto-generated names now)
 	if (!nameWasProvided && existsSync(targetDir)) {
+		const existingLink = await readProjectLink(targetDir);
+		if (existingLink) {
+			throw new JackError(
+				JackErrorCode.VALIDATION_ERROR,
+				`'${projectName}' already exists`,
+				`cd ${targetDir} && jack ship  to deploy it, or  rm -rf ${targetDir}  to start fresh.`,
+			);
+		}
 		throw new JackError(
 			JackErrorCode.VALIDATION_ERROR,
-			`Folder exists at ${targetDir}/`,
-			"Remove it first, or use 'jack ship' if it's a project.",
+			`Folder already exists at ${targetDir}/`,
+			"Remove it first or pick a different name.",
 		);
 	}
 
@@ -1045,8 +1049,8 @@ export async function createProject(
 		if (!hookResult.success) {
 			throw new JackError(
 				JackErrorCode.VALIDATION_ERROR,
-				"Project setup incomplete",
-				"Missing required configuration",
+				"Project setup cancelled",
+				`Run the same command again when you're ready — jack new ${projectName} -t ${resolvedTemplate}`,
 			);
 		}
 	}
@@ -1111,7 +1115,7 @@ export async function createProject(
 				placeholder: "paste value or press Esc to skip",
 			});
 
-			if (!isCancel(value) && value.trim()) {
+			if (!isCancel(value) && value && value.trim()) {
 				secretsToUse[optionalSecret.name] = value.trim();
 				// Save to global secrets for reuse
 				await saveSecrets([
@@ -1123,7 +1127,7 @@ export async function createProject(
 				]);
 				reporter.success(`Saved ${optionalSecret.name}`);
 			} else {
-				reporter.info(`Skipped ${optionalSecret.name}`);
+				reporter.info(`Skipped ${optionalSecret.name} — add it later with: jack secrets add ${optionalSecret.name}`);
 			}
 
 			reporter.start("Creating project...");
@@ -1590,25 +1594,22 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 	const interactive = interactiveOption ?? !isCi;
 
 	// Check for wrangler config
-	const hasWranglerConfig =
-		existsSync(join(projectPath, "wrangler.toml")) ||
-		existsSync(join(projectPath, "wrangler.jsonc")) ||
-		existsSync(join(projectPath, "wrangler.json"));
+	const hasConfig = hasWranglerConfig(projectPath);
 
 	// 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) {
+	if (!hasConfig && !hasProjectLink) {
 		autoDetectResult = await runAutoDetectFlow(projectPath, reporter, interactive, dryRun);
-	} else if (!hasWranglerConfig) {
+	} else if (!hasConfig) {
 		throw new JackError(
 			JackErrorCode.PROJECT_NOT_FOUND,
 			"No wrangler config found in current directory",
 			"Run: jack new <project-name>",
 		);
-	} else if (hasWranglerConfig && !hasProjectLink) {
+	} else if (hasConfig && !hasProjectLink) {
 		// Orphaned state: wrangler config exists but no project link
 		// This happens when: linking failed during jack new, user has existing wrangler project,
 		// or project was moved/copied without .jack directory
@@ -1798,9 +1799,7 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		managedDeployResult = await deployToManagedProject(managedProjectId as string, projectPath, reporter, options.message);
 
 		// Construct URL with username if available
-		workerUrl = link?.owner_username
-			? `https://${link.owner_username}-${projectName}.runjack.xyz`
-			: `https://${projectName}.runjack.xyz`;
+		workerUrl = await buildManagedUrl(projectName, link?.owner_username, projectPath);
 	} else {
 		// BYO mode: deploy via wrangler
 
@@ -1990,11 +1989,8 @@ export async function getProjectStatus(
 	const link = await readProjectLink(resolvedPath);
 
 	// 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 hasConfig = hasWranglerConfig(resolvedPath);
+	const localExists = hasConfig;
 	const localPath = localExists ? resolvedPath : null;
 
 	// If no link and no local project, return null
@@ -2014,9 +2010,7 @@ export async function getProjectStatus(
 	// Determine URL based on mode
 	let workerUrl: string | null = null;
 	if (link?.deploy_mode === "managed") {
-		workerUrl = link.owner_username
-			? `https://${link.owner_username}-${projectName}.runjack.xyz`
-			: `https://${projectName}.runjack.xyz`;
+		workerUrl = await buildManagedUrl(projectName, link.owner_username, resolvedPath);
 	}
 
 	// Get database name on-demand
@@ -2124,12 +2118,9 @@ export async function scanStaleProjects(): Promise<StaleProjectScan> {
 
 		for (const projectPath of paths) {
 			// Check if path exists and has valid wrangler config
-			const hasWranglerConfig =
-				existsSync(join(projectPath, "wrangler.jsonc")) ||
-				existsSync(join(projectPath, "wrangler.toml")) ||
-				existsSync(join(projectPath, "wrangler.json"));
+			const hasConfig = hasWranglerConfig(projectPath);
 
-			if (!hasWranglerConfig) {
+			if (!hasConfig) {
 				// Type 1: No wrangler config at path (dir deleted/moved)
 				const name = projectPath.split("/").pop() || projectId;
 				stale.push({

package/src/lib/prompts.ts

@@ -68,7 +68,7 @@ async function promptAdditionalSecrets(): Promise<
 			message: "Enter secret name (or press enter to finish):",
 		});
 
-		if (isCancel(key) || !key.trim()) {
+		if (isCancel(key) || !key || !key.trim()) {
 			break;
 		}
 
@@ -76,7 +76,7 @@ async function promptAdditionalSecrets(): Promise<
 			message: `Enter value for ${key}:`,
 		});
 
-		if (isCancel(value)) {
+		if (isCancel(value) || !value) {
 			break;
 		}
 

package/src/lib/resources.ts

@@ -5,9 +5,8 @@
  * or parsed from wrangler.jsonc (BYO).
  */
 
-import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { parseJsonc } from "./jsonc.ts";
+import { findWranglerConfig } from "./wrangler-config.ts";
 
 // Resource types matching control plane schema
 export type ResourceType =
@@ -88,10 +87,10 @@ export function convertControlPlaneResources(resources: ControlPlaneResource[]):
  * Returns a unified resource view.
  */
 export async function parseWranglerResources(projectPath: string): Promise<ResolvedResources> {
-	const wranglerPath = join(projectPath, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectPath);
 
-	if (!existsSync(wranglerPath)) {
-		return {};
+	if (!wranglerPath) {
+		return {} as ResolvedResources;
 	}
 
 	try {