@getjack/jack 0.1.34 → 0.1.36

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] : [])]
@@ -1606,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
@@ -1814,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
 
@@ -2006,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
@@ -2030,35 +2010,11 @@ 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
+	// Get database name and deployment data
 	let dbName: string | null = null;
-	if (link?.deploy_mode === "managed") {
-		// For managed projects, fetch from control plane
-		try {
-			const { fetchProjectResources } = await import("./control-plane.ts");
-			const resources = await fetchProjectResources(link.project_id);
-			const d1 = resources.find((r) => r.resource_type === "d1");
-			dbName = d1?.resource_name || null;
-		} catch {
-			// Ignore errors, dbName stays null
-		}
-	} else if (localExists) {
-		// For BYO, parse from wrangler config
-		try {
-			const { parseWranglerResources } = await import("./resources.ts");
-			const resources = await parseWranglerResources(resolvedPath);
-			dbName = resources.d1?.name || null;
-		} catch {
-			// Ignore errors, dbName stays null
-		}
-	}
-
-	// Fetch real deployment data for managed projects
 	let lastDeployAt: string | null = null;
 	let deployCount = 0;
 	let lastDeployStatus: string | null = null;
@@ -2066,11 +2022,14 @@ export async function getProjectStatus(
 	let lastDeployMessage: string | null = null;
 
 	if (link?.deploy_mode === "managed") {
+		// Single overview call replaces fetchProjectResources + fetchDeployments
 		try {
-			const { fetchDeployments } = await import("./control-plane.ts");
-			const result = await fetchDeployments(link.project_id);
-			deployCount = result.total;
-			const latest = result.deployments[0];
+			const { fetchProjectOverview } = await import("./control-plane.ts");
+			const overview = await fetchProjectOverview(link.project_id);
+			const d1 = overview.resources.find((r) => r.resource_type === "d1");
+			dbName = d1?.resource_name || null;
+
+			const latest = overview.latest_deployment;
 			if (latest) {
 				lastDeployAt = latest.created_at;
 				lastDeployStatus = latest.status;
@@ -2078,7 +2037,16 @@ export async function getProjectStatus(
 				lastDeployMessage = latest.message;
 			}
 		} catch {
-			// Silent fail — deploy tracking is supplementary
+			// Silent fail — supplementary data
+		}
+	} else if (localExists) {
+		// For BYO, parse from wrangler config
+		try {
+			const { parseWranglerResources } = await import("./resources.ts");
+			const resources = await parseWranglerResources(resolvedPath);
+			dbName = resources.d1?.name || null;
+		} catch {
+			// Ignore errors, dbName stays null
 		}
 	}
 
@@ -2140,12 +2108,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/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 {

package/src/lib/schema.ts

@@ -4,6 +4,7 @@ import { $ } from "bun";
 import { debug } from "./debug.ts";
 import { parseJsonc } from "./jsonc.ts";
 import { output } from "./output.ts";
+import { findWranglerConfig } from "./wrangler-config.ts";
 
 /**
  * Execute schema.sql on a D1 database after deploy
@@ -47,9 +48,9 @@ export async function applySchema(bindingOrDbName: string, projectDir: string):
  * Check if project has D1 database configured (has d1_databases in wrangler config)
  */
 export async function hasD1Config(projectDir: string): Promise<boolean> {
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir);
 
-	if (!existsSync(wranglerPath)) {
+	if (!wranglerPath) {
 		return false;
 	}
 
@@ -71,9 +72,9 @@ export interface D1Binding {
  * Read D1 bindings from wrangler.jsonc
  */
 export async function getD1Bindings(projectDir: string): Promise<D1Binding[]> {
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir);
 
-	if (!existsSync(wranglerPath)) {
+	if (!wranglerPath) {
 		return [];
 	}
 
@@ -91,20 +92,15 @@ export async function getD1Bindings(projectDir: string): Promise<D1Binding[]> {
  * Returns the database_name field which is needed for wrangler d1 execute
  */
 export async function getD1DatabaseName(projectDir: string): Promise<string | null> {
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir);
 
-	if (!existsSync(wranglerPath)) {
+	if (!wranglerPath) {
 		return null;
 	}
 
 	try {
 		const content = await Bun.file(wranglerPath).text();
-		// Strip comments for parsing
-		// Note: Only remove line comments at the start of a line to avoid breaking URLs
-		const cleaned = content
-			.replace(/\/\*[\s\S]*?\*\//g, "") // block comments
-			.replace(/^\s*\/\/.*$/gm, ""); // line comments at start of line only
-		const config = JSON.parse(cleaned);
+		const config = parseJsonc<{ d1_databases?: { database_name?: string }[] }>(content);
 
 		return config.d1_databases?.[0]?.database_name || null;
 	} catch {

package/src/lib/services/db-create.ts

@@ -9,7 +9,7 @@ import { $ } from "bun";
 import { createProjectResource } from "../control-plane.ts";
 import { readProjectLink } from "../project-link.ts";
 import { getProjectNameFromDir } from "../storage/index.ts";
-import { addD1Binding, getExistingD1Bindings } from "../wrangler-config.ts";
+import { addD1Binding, findWranglerConfig, getExistingD1Bindings } from "../wrangler-config.ts";
 
 export interface CreateDatabaseOptions {
 	name?: string;
@@ -135,7 +135,7 @@ export async function createDatabase(
 	const projectName = await getProjectNameFromDir(projectDir);
 
 	// Get existing D1 bindings to determine naming
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir) ?? join(projectDir, "wrangler.jsonc");
 	const existingBindings = await getExistingD1Bindings(wranglerPath);
 	const existingCount = existingBindings.length;