@getjack/jack 0.1.17 → 0.1.20

package/package.json

@@ -1,16 +1,13 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.17",
+	"version": "0.1.20",
 	"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"
 	},

package/src/commands/clone.ts

@@ -1,13 +1,14 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { isCancel, select } from "@clack/prompts";
-import { fetchProjectTags } from "../lib/control-plane.ts";
+import { downloadProjectSource, fetchProjectTags } from "../lib/control-plane.ts";
 import { formatSize } from "../lib/format.ts";
 import { box, error, info, spinner, success } from "../lib/output.ts";
 import { registerPath } from "../lib/paths-index.ts";
 import { linkProject, updateProjectLink } from "../lib/project-link.ts";
 import { resolveProject } from "../lib/project-resolver.ts";
 import { cloneFromCloud, getRemoteManifest } from "../lib/storage/index.ts";
+import { extractZipToDirectory } from "../lib/zip-utils.ts";
 
 export interface CloneFlags {
 	as?: string;
@@ -53,53 +54,74 @@ export default async function clone(projectName?: string, flags: CloneFlags = {}
 		}
 	}
 
-	// Fetch remote manifest
-	const spin = spinner(`Fetching from jack-storage/${projectName}/...`);
-	const manifest = await getRemoteManifest(projectName);
+	// Check if this is a managed project (has source in control-plane)
+	const spin = spinner(`Looking up ${projectName}...`);
+	let project: Awaited<ReturnType<typeof resolveProject>> = null;
 
-	if (!manifest) {
-		spin.error(`Project not found: ${projectName}`);
-		process.exit(1);
+	try {
+		project = await resolveProject(projectName);
+	} catch {
+		// Not found on control-plane, will fall back to User R2
 	}
 
-	// Show file count and size
-	const totalSize = manifest.files.reduce((sum, f) => sum + f.size, 0);
-	spin.success(`Found ${manifest.files.length} file(s) (${formatSize(totalSize)})`);
+	// Managed mode: download from control-plane
+	if (project?.sources.controlPlane && project.remote?.projectId) {
+		spin.success("Found on jack cloud");
+
+		const downloadSpin = spinner("Downloading from jack cloud...");
+		try {
+			const sourceZip = await downloadProjectSource(projectName);
+			const fileCount = await extractZipToDirectory(sourceZip, targetDir);
+			downloadSpin.success(`Restored ${fileCount} file(s) to ./${flags.as ?? projectName}/`);
+		} catch (err) {
+			downloadSpin.error("Download failed");
+			const message = err instanceof Error ? err.message : "Could not download project source";
+			error(message);
+			process.exit(1);
+		}
 
-	// Download files
-	const downloadSpin = spinner("Downloading...");
-	const result = await cloneFromCloud(projectName, targetDir);
+		// Link to control-plane
+		await linkProject(targetDir, project.remote.projectId, "managed");
+		await registerPath(project.remote.projectId, targetDir);
 
-	if (!result.success) {
-		downloadSpin.error("Clone failed");
-		error(result.error || "Could not download project files");
-		info("Check your network connection and try again");
-		process.exit(1);
-	}
+		// Fetch and restore tags from control plane
+		try {
+			const remoteTags = await fetchProjectTags(project.remote.projectId);
+			if (remoteTags.length > 0) {
+				await updateProjectLink(targetDir, { tags: remoteTags });
+				info(`Restored ${remoteTags.length} tag(s)`);
+			}
+		} catch {
+			// Silent fail - tag restoration is non-critical
+		}
+	} else {
+		// BYO mode: use existing User R2 flow
+		spin.stop();
+		const fetchSpin = spinner(`Fetching from jack-storage/${projectName}/...`);
+		const manifest = await getRemoteManifest(projectName);
+
+		if (!manifest) {
+			fetchSpin.error(`Project not found: ${projectName}`);
+			info("For BYO projects, run 'jack sync' first to backup your project.");
+			process.exit(1);
+		}
 
-	downloadSpin.success(`Restored to ./${flags.as ?? projectName}/`);
+		// Show file count and size
+		const totalSize = manifest.files.reduce((sum, f) => sum + f.size, 0);
+		fetchSpin.success(`Found ${manifest.files.length} file(s) (${formatSize(totalSize)})`);
 
-	// Link project to control plane if it's a managed project
-	try {
-		const project = await resolveProject(projectName);
-		if (project?.sources.controlPlane && project.remote?.projectId) {
-			// Managed project - link with control plane project ID
-			await linkProject(targetDir, project.remote.projectId, "managed");
-			await registerPath(project.remote.projectId, targetDir);
-
-			// Fetch and restore tags from control plane
-			try {
-				const remoteTags = await fetchProjectTags(project.remote.projectId);
-				if (remoteTags.length > 0) {
-					await updateProjectLink(targetDir, { tags: remoteTags });
-					info(`Restored ${remoteTags.length} tag(s)`);
-				}
-			} catch {
-				// Silent fail - tag restoration is non-critical
-			}
+		// Download files
+		const downloadSpin = spinner("Downloading...");
+		const result = await cloneFromCloud(projectName, targetDir);
+
+		if (!result.success) {
+			downloadSpin.error("Clone failed");
+			error(result.error || "Could not download project files");
+			info("Check your network connection and try again");
+			process.exit(1);
 		}
-	} catch {
-		// Not a control plane project or offline - continue without linking
+
+		downloadSpin.success(`Restored to ./${flags.as ?? projectName}/`);
 	}
 
 	// Show next steps

package/src/commands/down.ts

@@ -10,7 +10,8 @@ import { fetchProjectResources } from "../lib/control-plane.ts";
 import { promptSelect } from "../lib/hooks.ts";
 import { managedDown } from "../lib/managed-down.ts";
 import { error, info, item, output, success, warn } from "../lib/output.ts";
-import { type LocalProjectLink, readProjectLink } from "../lib/project-link.ts";
+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 { deleteCloudProject, getProjectNameFromDir } from "../lib/storage/index.ts";
@@ -124,6 +125,15 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			if (!deleteSuccess) {
 				process.exit(0); // User cancelled
 			}
+
+			// Clean up local tracking state
+			const localPath = resolved?.localPath || process.cwd();
+			try {
+				await unlinkProject(localPath);
+				await unregisterPath(projectId, localPath);
+			} catch {
+				// Non-fatal: local cleanup failed but cloud deletion succeeded
+			}
 			return;
 		}
 

package/src/commands/init.ts

@@ -11,8 +11,27 @@ import { ensureAuth, ensureWrangler, isAuthenticated } from "../lib/wrangler.ts"
 
 export async function isInitialized(): Promise<boolean> {
 	const config = await readConfig();
-	if (!config?.initialized) return false;
-	return await isAuthenticated();
+	const { isLoggedIn } = await import("../lib/auth/store.ts");
+
+	if (config?.initialized) {
+		if ((await isLoggedIn()) || (await isAuthenticated())) return true;
+	}
+
+	// Auto-initialize if authenticated
+	const loggedIn = await isLoggedIn();
+	const wranglerAuth = !loggedIn && (await isAuthenticated());
+
+	if (loggedIn || wranglerAuth) {
+		await writeConfig({
+			version: 1,
+			initialized: true,
+			initializedAt: new Date().toISOString(),
+			...config,
+		});
+		return true;
+	}
+
+	return false;
 }
 
 interface InitOptions {

package/src/commands/services.ts

@@ -277,6 +277,12 @@ async function dbExport(options: ServiceOptions): Promise<void> {
  */
 async function dbDelete(options: ServiceOptions): Promise<void> {
 	const projectName = await resolveProjectName(options);
+	const projectDir = process.cwd();
+
+	// Check deploy mode
+	const link = await readProjectLink(projectDir);
+	const isManaged = link?.deploy_mode === "managed";
+
 	const dbInfo = await resolveDatabaseInfo(projectName);
 
 	if (!dbInfo) {
@@ -314,14 +320,80 @@ async function dbDelete(options: ServiceOptions): Promise<void> {
 		return;
 	}
 
-	// Delete database
 	outputSpinner.start("Deleting database...");
+
+	// Track binding_name from control plane for matching in wrangler.jsonc
+	let controlPlaneBindingName: string | null = null;
+
 	try {
-		await deleteDatabase(dbInfo.name);
+		if (isManaged && link) {
+			// Managed mode: delete via control plane
+			const { fetchProjectResources, deleteProjectResource } = await import(
+				"../lib/control-plane.ts"
+			);
+
+			// Find the resource ID for this database
+			const resources = await fetchProjectResources(link.project_id);
+			const d1Resource = resources.find(
+				(r) => r.resource_type === "d1" && r.resource_name === dbInfo.name,
+			);
+
+			if (d1Resource) {
+				// Save binding_name for wrangler.jsonc cleanup
+				controlPlaneBindingName = d1Resource.binding_name;
+				// Delete via control plane (which also deletes from Cloudflare)
+				await deleteProjectResource(link.project_id, d1Resource.id);
+			} else {
+				// Resource not in control plane - fall back to wrangler for cleanup
+				await deleteDatabase(dbInfo.name);
+			}
+		} else {
+			// BYO mode: delete via wrangler directly
+			await deleteDatabase(dbInfo.name);
+		}
+
+		// 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");
+
+		let bindingRemoved = false;
+		try {
+			// Find the binding by matching (in order of reliability):
+			// 1. binding name (e.g., "DB") - if control plane provided it
+			// 2. database_id (provider_id from control plane)
+			// 3. database_name
+			// 4. If managed mode and we successfully deleted, remove first D1 binding
+			const existingBindings = await getExistingD1Bindings(configPath);
+			let bindingToRemove = existingBindings.find(
+				(b) =>
+					(controlPlaneBindingName && b.binding === controlPlaneBindingName) ||
+					b.database_id === dbInfo.id ||
+					b.database_name === dbInfo.name,
+			);
+
+			// Fallback: if managed mode and we deleted from control plane,
+			// remove the first D1 binding (binding_name may be null for older DBs)
+			if (!bindingToRemove && isManaged && existingBindings.length > 0) {
+				bindingToRemove = existingBindings[0];
+			}
+
+			if (bindingToRemove) {
+				bindingRemoved = await removeD1Binding(configPath, bindingToRemove.database_name);
+			}
+		} catch (bindingErr) {
+			// Log but don't fail - the database is already deleted
+			// The user can manually clean up wrangler.jsonc if needed
+		}
+
 		outputSpinner.stop();
 
 		console.error("");
 		success("Database deleted");
+		if (bindingRemoved) {
+			item("Binding removed from wrangler.jsonc");
+		}
 		console.error("");
 	} catch (err) {
 		outputSpinner.stop();
@@ -332,10 +404,11 @@ async function dbDelete(options: ServiceOptions): Promise<void> {
 }
 
 /**
- * Parse --name flag from args
- * Supports: --name foo, --name=foo
+ * Parse --name flag or positional arg from args
+ * Supports: --name foo, --name=foo, or first positional arg
  */
 function parseNameFlag(args: string[]): string | undefined {
+	// Check --name flag first (takes priority)
 	for (let i = 0; i < args.length; i++) {
 		const arg = args[i];
 		if (arg === "--name" && args[i + 1]) {
@@ -345,6 +418,14 @@ function parseNameFlag(args: string[]): string | undefined {
 			return arg.slice("--name=".length);
 		}
 	}
+
+	// Fall back to first positional argument (non-flag)
+	for (const arg of args) {
+		if (!arg.startsWith("-")) {
+			return arg;
+		}
+	}
+
 	return undefined;
 }
 

package/src/commands/sync.ts

@@ -1,6 +1,7 @@
 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";
 import { syncToCloud } from "../lib/storage/index.ts";
 
 export interface SyncFlags {
@@ -25,6 +26,14 @@ export default async function sync(flags: SyncFlags = {}): Promise<void> {
 		process.exit(1);
 	}
 
+	// Check if this is a managed project
+	const link = await readProjectLink(process.cwd());
+	if (link?.deploy_mode === "managed") {
+		info("Managed projects are automatically backed up to jack cloud during deploy.");
+		info("Use 'jack clone <project>' on another machine to restore.");
+		return;
+	}
+
 	// Check if sync is enabled
 	const syncConfig = await getSyncConfig();
 	if (!syncConfig.enabled) {

package/src/commands/update.ts

@@ -2,6 +2,7 @@
  * jack update - Self-update to the latest version
  */
 
+import { debug } from "../lib/debug.ts";
 import { error, info, success, warn } from "../lib/output.ts";
 import {
 	checkForUpdate,
@@ -13,8 +14,13 @@ import {
 export default async function update(): Promise<void> {
 	const currentVersion = getCurrentVersion();
 
+	debug("Update check started");
+	debug(`Current version: ${currentVersion}`);
+	debug(`Exec path: ${process.argv[1]}`);
+
 	// Check if running via bunx
 	if (isRunningViaBunx()) {
+		debug("Detected bunx execution");
 		info(`Running via bunx (current: v${currentVersion})`);
 		info("bunx automatically uses cached packages.");
 		info("To get the latest version, run:");
@@ -28,7 +34,9 @@ export default async function update(): Promise<void> {
 	info(`Current version: v${currentVersion}`);
 
 	// Check for updates
+	debug("Fetching latest version from npm...");
 	const latestVersion = await checkForUpdate();
+	debug(`Latest version from npm: ${latestVersion ?? "none (you're up to date)"}`);
 
 	if (!latestVersion) {
 		success("You're on the latest version!");
@@ -38,7 +46,9 @@ export default async function update(): Promise<void> {
 	info(`New version available: v${latestVersion}`);
 	info("Updating...");
 
+	debug("Running: bun add -g @getjack/jack@latest");
 	const result = await performUpdate();
+	debug(`Update result: ${JSON.stringify(result)}`);
 
 	if (result.success) {
 		success(`Updated to v${result.version ?? latestVersion}`);

package/src/lib/agents.ts

@@ -434,7 +434,9 @@ export interface AgentLaunchContext {
 function buildInitialPrompt(context: AgentLaunchContext): string | null {
 	if (!context.url) return null;
 
-	return `[jack] Project "${context.projectName}" is live at ${context.url} - say hi and let's build!`;
+	return `Project "${context.projectName}" is live at ${context.url}
+
+Read CLAUDE.md and AGENTS.md for project context, then say hi and offer to help build.`;
 }
 
 function buildLaunchCommand(

package/src/lib/auth/ensure-auth.test.ts

@@ -210,9 +210,9 @@ describe("ensureAuthForCreate", () => {
 		});
 
 		it("throws error when both forceManaged and forceByo are set", async () => {
-			await expect(
-				ensureAuthForCreate({ forceManaged: true, forceByo: true }),
-			).rejects.toThrow("Cannot use both --managed and --byo flags");
+			await expect(ensureAuthForCreate({ forceManaged: true, forceByo: true })).rejects.toThrow(
+				"Cannot use both --managed and --byo flags",
+			);
 		});
 	});
 

package/src/lib/control-plane.ts

@@ -2,6 +2,9 @@
  * Control Plane API client for jack cloud
  */
 
+import { debug } from "./debug.ts";
+import { formatSize } from "./format.ts";
+
 const DEFAULT_CONTROL_API_URL = "https://control.getjack.org";
 
 export function getControlApiUrl(): string {
@@ -109,6 +112,9 @@ export async function createManagedProject(
 		requestBody.use_prebuilt = options.usePrebuilt;
 	}
 
+	debug("Creating managed project", { name, template: options?.template, usePrebuilt: options?.usePrebuilt });
+	const start = Date.now();
+
 	const response = await authFetch(`${getControlApiUrl()}/v1/projects`, {
 		method: "POST",
 		headers: {
@@ -118,6 +124,9 @@ export async function createManagedProject(
 		body: JSON.stringify(requestBody),
 	});
 
+	const duration = ((Date.now() - start) / 1000).toFixed(1);
+	debug(`Control plane response: ${response.status} (${duration}s)`);
+
 	if (!response.ok) {
 		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
 			message?: string;
@@ -371,6 +380,46 @@ export async function createProjectResource(
 	return data.resource;
 }
 
+export interface DeleteResourceResponse {
+	success: boolean;
+	resource_id: string;
+	deleted_at: string;
+}
+
+/**
+ * Delete a resource from a managed project.
+ * Uses DELETE /v1/projects/:id/resources/:id endpoint.
+ */
+export async function deleteProjectResource(
+	projectId: string,
+	resourceId: string,
+): Promise<DeleteResourceResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/${projectId}/resources/${resourceId}`,
+		{ method: "DELETE" },
+	);
+
+	// Handle 404 gracefully - resource may already be deleted
+	if (response.status === 404) {
+		return {
+			success: true,
+			resource_id: resourceId,
+			deleted_at: new Date().toISOString(),
+		};
+	}
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to delete resource: ${response.status}`);
+	}
+
+	return response.json() as Promise<DeleteResourceResponse>;
+}
+
 /**
  * Sync project tags to the control plane.
  * Fire-and-forget: errors are logged but not thrown.
@@ -546,10 +595,15 @@ export async function uploadSourceSnapshot(
 	const sourceFile = Bun.file(sourceZipPath);
 	formData.append("source", sourceFile);
 
-	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/source`, {
+	const url = `${getControlApiUrl()}/v1/projects/${projectId}/source`;
+	debug(`Source snapshot: ${formatSize(sourceFile.size)}`);
+
+	const start = Date.now();
+	const response = await authFetch(url, {
 		method: "POST",
 		body: formData,
 	});
+	debug(`Source snapshot: ${response.status} (${((Date.now() - start) / 1000).toFixed(1)}s)`);
 
 	if (!response.ok) {
 		const error = (await response.json().catch(() => ({ message: "Upload failed" }))) as {
@@ -580,3 +634,25 @@ export async function publishProject(projectId: string): Promise<PublishProjectR
 
 	return response.json() as Promise<PublishProjectResponse>;
 }
+
+/**
+ * Download the source snapshot for a project.
+ * Returns the zip file contents as a Buffer.
+ * Used by jack clone to restore managed projects.
+ */
+export async function downloadProjectSource(slug: string): Promise<Buffer> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/by-slug/${encodeURIComponent(slug)}/source`,
+	);
+
+	if (!response.ok) {
+		if (response.status === 404) {
+			throw new Error("Project source not found. Deploy first with 'jack ship'.");
+		}
+		throw new Error(`Failed to download source: ${response.status}`);
+	}
+
+	return Buffer.from(await response.arrayBuffer());
+}

package/src/lib/deploy-upload.ts

@@ -6,6 +6,8 @@ import { readFile } from "node:fs/promises";
 import type { AssetManifest } from "./asset-hash.ts";
 import { authFetch } from "./auth/index.ts";
 import { getControlApiUrl } from "./control-plane.ts";
+import { debug } from "./debug.ts";
+import { formatSize } from "./format.ts";
 
 export interface DeployUploadOptions {
 	projectId: string;
@@ -31,6 +33,9 @@ export interface DeployUploadResult {
  */
 export async function uploadDeployment(options: DeployUploadOptions): Promise<DeployUploadResult> {
 	const formData = new FormData();
+	let totalSize = 0;
+
+	const prepareStart = Date.now();
 
 	// Read files and add to form data
 	const manifestContent = await readFile(options.manifestPath);
@@ -39,17 +44,24 @@ export async function uploadDeployment(options: DeployUploadOptions): Promise<De
 		new Blob([manifestContent], { type: "application/json" }),
 		"manifest.json",
 	);
+	totalSize += manifestContent.length;
 
 	const bundleContent = await readFile(options.bundleZipPath);
 	formData.append("bundle", new Blob([bundleContent], { type: "application/zip" }), "bundle.zip");
+	totalSize += bundleContent.length;
+	debug(`  bundle.zip: ${formatSize(bundleContent.length)}`);
 
 	const sourceContent = await readFile(options.sourceZipPath);
 	formData.append("source", new Blob([sourceContent], { type: "application/zip" }), "source.zip");
+	totalSize += sourceContent.length;
+	debug(`  source.zip: ${formatSize(sourceContent.length)}`);
 
 	// Optional files
 	if (options.schemaPath) {
 		const schemaContent = await readFile(options.schemaPath);
 		formData.append("schema", new Blob([schemaContent], { type: "text/sql" }), "schema.sql");
+		totalSize += schemaContent.length;
+		debug(`  schema.sql: ${formatSize(schemaContent.length)}`);
 	}
 
 	if (options.secretsPath) {
@@ -59,27 +71,40 @@ export async function uploadDeployment(options: DeployUploadOptions): Promise<De
 			new Blob([secretsContent], { type: "application/json" }),
 			"secrets.json",
 		);
+		totalSize += secretsContent.length;
 	}
 
 	if (options.assetsZipPath) {
 		const assetsContent = await readFile(options.assetsZipPath);
 		formData.append("assets", new Blob([assetsContent], { type: "application/zip" }), "assets.zip");
+		totalSize += assetsContent.length;
+		debug(`  assets.zip: ${formatSize(assetsContent.length)}`);
 	}
 
 	if (options.assetManifest) {
+		const manifestJson = JSON.stringify(options.assetManifest);
 		formData.append(
 			"asset-manifest",
-			new Blob([JSON.stringify(options.assetManifest)], { type: "application/json" }),
+			new Blob([manifestJson], { type: "application/json" }),
 			"asset-manifest.json",
 		);
+		totalSize += manifestJson.length;
 	}
 
+	const prepareMs = Date.now() - prepareStart;
+	debug(`Payload ready: ${formatSize(totalSize)} (${prepareMs}ms)`);
+
 	// POST to control plane
 	const url = `${getControlApiUrl()}/v1/projects/${options.projectId}/deployments/upload`;
+	debug(`POST ${url}`);
+
+	const uploadStart = Date.now();
 	const response = await authFetch(url, {
 		method: "POST",
 		body: formData,
 	});
+	const uploadMs = Date.now() - uploadStart;
+	debug(`Response: ${response.status} (${(uploadMs / 1000).toFixed(1)}s)`);
 
 	if (!response.ok) {
 		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {