@getjack/jack 0.1.16 → 0.1.19

package/README.md

@@ -7,7 +7,7 @@
   <a href="https://www.npmjs.com/package/@getjack/jack"><img src="https://img.shields.io/npm/v/@getjack/jack" alt="npm"></a>
   <a href="https://github.com/getjack-org/jack/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-blue" alt="license"></a>
   <a href="https://docs.getjack.org"><img src="https://img.shields.io/badge/docs-getjack.org-green" alt="docs"></a>
-  <a href="https://discord.gg/fb64krv48R"><img src="https://img.shields.io/badge/discord-community-5865F2" alt="discord"></a>
+  <a href="https://community.getjack.org"><img src="https://img.shields.io/badge/discord-community-5865F2" alt="discord"></a>
 </p>
 
 ---

package/package.json

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

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/community.ts

@@ -0,0 +1,47 @@
+/**
+ * jack community - Open the jack community Discord
+ */
+
+import { $ } from "bun";
+import { error } from "../lib/output.ts";
+
+const COMMUNITY_URL = "https://community.getjack.org";
+
+export default async function community(): Promise<void> {
+	console.error("");
+	console.error("  Chat with other vibecoders and the jack team.");
+	console.error("");
+	console.error(`  Press Enter to open the browser or visit ${COMMUNITY_URL}`);
+
+	// Wait for Enter key
+	await waitForEnter();
+
+	// Open browser using platform-specific command
+	const cmd =
+		process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+
+	try {
+		await $`${cmd} ${COMMUNITY_URL}`;
+	} catch (err) {
+		error(`Failed to open browser: ${err instanceof Error ? err.message : String(err)}`);
+		console.error(`  Visit: ${COMMUNITY_URL}`);
+	}
+}
+
+async function waitForEnter(): Promise<void> {
+	return new Promise((resolve) => {
+		if (!process.stdin.isTTY) {
+			// Non-interactive, just resolve immediately
+			resolve();
+			return;
+		}
+
+		process.stdin.setRawMode(true);
+		process.stdin.resume();
+		process.stdin.once("data", () => {
+			process.stdin.setRawMode(false);
+			process.stdin.pause();
+			resolve();
+		});
+	});
+}

package/src/commands/init.ts

@@ -12,6 +12,12 @@ import { ensureAuth, ensureWrangler, isAuthenticated } from "../lib/wrangler.ts"
 export async function isInitialized(): Promise<boolean> {
 	const config = await readConfig();
 	if (!config?.initialized) return false;
+
+	// Check Jack Cloud auth first (most common path)
+	const { isLoggedIn } = await import("../lib/auth/store.ts");
+	if (await isLoggedIn()) return true;
+
+	// Fall back to wrangler/Cloudflare auth (BYO mode)
 	return await isAuthenticated();
 }
 

package/src/commands/services.ts

@@ -1,10 +1,17 @@
-import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
 import { fetchProjectResources } from "../lib/control-plane.ts";
 import { formatSize } from "../lib/format.ts";
 import { error, info, item, output as outputSpinner, success, warn } from "../lib/output.ts";
 import { readProjectLink } from "../lib/project-link.ts";
 import { parseWranglerResources } from "../lib/resources.ts";
 import { createDatabase } from "../lib/services/db-create.ts";
+import {
+	DestructiveOperationError,
+	WriteNotAllowedError,
+	executeSql,
+	executeSqlFile,
+} from "../lib/services/db-execute.ts";
 import { listDatabases } from "../lib/services/db-list.ts";
 import {
 	deleteDatabase,
@@ -12,6 +19,7 @@ import {
 	generateExportFilename,
 	getDatabaseInfo as getWranglerDatabaseInfo,
 } from "../lib/services/db.ts";
+import { getRiskDescription } from "../lib/services/sql-classifier.ts";
 import { getProjectNameFromDir } from "../lib/storage/index.ts";
 import { Events, track } from "../lib/telemetry.ts";
 
@@ -125,13 +133,19 @@ function showDbHelp(): void {
 	console.error("  info       Show database information (default)");
 	console.error("  create     Create a new database");
 	console.error("  list       List all databases in the project");
+	console.error("  execute    Execute SQL against the database");
 	console.error("  export     Export database to SQL file");
 	console.error("  delete     Delete a database");
 	console.error("");
 	console.error("Examples:");
-	console.error("  jack services db          Show info about the default database");
-	console.error("  jack services db create   Create a new database");
-	console.error("  jack services db list     List all databases");
+	console.error(
+		"  jack services db                                   Show info about the default database",
+	);
+	console.error("  jack services db create                            Create a new database");
+	console.error("  jack services db list                              List all databases");
+	console.error('  jack services db execute "SELECT * FROM users"     Run a read query');
+	console.error('  jack services db execute "INSERT..." --write       Run a write query');
+	console.error("  jack services db execute --file schema.sql --write Run SQL from file");
 	console.error("");
 }
 
@@ -149,13 +163,15 @@ async function dbCommand(args: string[], options: ServiceOptions): Promise<void>
 			return await dbCreate(args.slice(1), options);
 		case "list":
 			return await dbList(options);
+		case "execute":
+			return await dbExecute(args.slice(1), options);
 		case "export":
 			return await dbExport(options);
 		case "delete":
 			return await dbDelete(options);
 		default:
 			error(`Unknown action: ${action}`);
-			info("Available: info, create, list, export, delete");
+			info("Available: info, create, list, execute, export, delete");
 			process.exit(1);
 	}
 }
@@ -261,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) {
@@ -298,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();
@@ -316,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]) {
@@ -329,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;
 }
 
@@ -427,3 +524,251 @@ async function dbList(options: ServiceOptions): Promise<void> {
 		process.exit(1);
 	}
 }
+
+/**
+ * Parse execute command arguments
+ * Supports:
+ *   jack services db execute "SELECT * FROM users"
+ *   jack services db execute "INSERT..." --write
+ *   jack services db execute --file schema.sql --write
+ *   jack services db execute --db my-other-db "SELECT..."
+ */
+interface ExecuteArgs {
+	sql?: string;
+	filePath?: string;
+	allowWrite: boolean;
+	databaseName?: string;
+}
+
+function parseExecuteArgs(args: string[]): ExecuteArgs {
+	const result: ExecuteArgs = {
+		allowWrite: false,
+	};
+
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (!arg) continue;
+
+		if (arg === "--write" || arg === "-w") {
+			result.allowWrite = true;
+			continue;
+		}
+
+		if (arg === "--file" || arg === "-f") {
+			result.filePath = args[i + 1];
+			i++; // Skip the next arg
+			continue;
+		}
+
+		if (arg.startsWith("--file=")) {
+			result.filePath = arg.slice("--file=".length);
+			continue;
+		}
+
+		if (arg === "--db" || arg === "--database") {
+			result.databaseName = args[i + 1];
+			i++; // Skip the next arg
+			continue;
+		}
+
+		if (arg.startsWith("--db=")) {
+			result.databaseName = arg.slice("--db=".length);
+			continue;
+		}
+
+		if (arg.startsWith("--database=")) {
+			result.databaseName = arg.slice("--database=".length);
+			continue;
+		}
+
+		// Any other non-flag argument is the SQL query
+		if (!arg.startsWith("-")) {
+			result.sql = arg;
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Execute SQL against the database
+ */
+async function dbExecute(args: string[], _options: ServiceOptions): Promise<void> {
+	const execArgs = parseExecuteArgs(args);
+
+	// Validate input
+	if (!execArgs.sql && !execArgs.filePath) {
+		console.error("");
+		error("No SQL provided");
+		info('Usage: jack services db execute "SELECT * FROM users"');
+		info("       jack services db execute --file schema.sql --write");
+		console.error("");
+		process.exit(1);
+	}
+
+	// Cannot specify both SQL and file
+	if (execArgs.sql && execArgs.filePath) {
+		console.error("");
+		error("Cannot specify both inline SQL and --file");
+		info("Use either inline SQL or --file, not both");
+		console.error("");
+		process.exit(1);
+	}
+
+	// If using --file, verify file exists
+	if (execArgs.filePath) {
+		const absPath = resolve(process.cwd(), execArgs.filePath);
+		if (!existsSync(absPath)) {
+			console.error("");
+			error(`File not found: ${execArgs.filePath}`);
+			console.error("");
+			process.exit(1);
+		}
+		execArgs.filePath = absPath;
+	}
+
+	const projectDir = process.cwd();
+
+	try {
+		outputSpinner.start("Executing SQL...");
+
+		let result;
+		if (execArgs.filePath) {
+			result = await executeSqlFile({
+				projectDir,
+				filePath: execArgs.filePath,
+				databaseName: execArgs.databaseName,
+				allowWrite: execArgs.allowWrite,
+				interactive: true,
+			});
+		} else {
+			result = await executeSql({
+				projectDir,
+				sql: execArgs.sql!,
+				databaseName: execArgs.databaseName,
+				allowWrite: execArgs.allowWrite,
+				interactive: true,
+			});
+		}
+
+		// Handle destructive operations - need confirmation BEFORE execution
+		if (result.requiresConfirmation) {
+			outputSpinner.stop();
+
+			// Find the destructive statements
+			const destructiveStmts = result.statements.filter((s) => s.risk === "destructive");
+
+			console.error("");
+			warn("This SQL contains destructive operations:");
+			for (const stmt of destructiveStmts) {
+				item(`${stmt.operation}: ${stmt.sql.slice(0, 60)}${stmt.sql.length > 60 ? "..." : ""}`);
+			}
+			console.error("");
+
+			// Require typed confirmation
+			const { text } = await import("@clack/prompts");
+			const confirmText = destructiveStmts
+				.map((s) => s.operation)
+				.join(" ")
+				.toUpperCase();
+
+			const userInput = await text({
+				message: `Type "${confirmText}" to confirm:`,
+				validate: (value) => {
+					if (value.toUpperCase() !== confirmText) {
+						return `Please type "${confirmText}" exactly to confirm`;
+					}
+				},
+			});
+
+			if (typeof userInput !== "string") {
+				info("Cancelled");
+				return;
+			}
+
+			// NOW execute with confirmation (interactive: false means "already confirmed")
+			outputSpinner.start("Executing SQL...");
+			if (execArgs.filePath) {
+				result = await executeSqlFile({
+					projectDir,
+					filePath: execArgs.filePath,
+					databaseName: execArgs.databaseName,
+					allowWrite: true,
+					interactive: false, // Already confirmed, execute now
+				});
+			} else {
+				result = await executeSql({
+					projectDir,
+					sql: execArgs.sql!,
+					databaseName: execArgs.databaseName,
+					allowWrite: true,
+					interactive: false, // Already confirmed, execute now
+				});
+			}
+		}
+
+		outputSpinner.stop();
+
+		if (!result.success) {
+			console.error("");
+			error(result.error || "SQL execution failed");
+			console.error("");
+			process.exit(1);
+		}
+
+		// Show results
+		console.error("");
+		success(`SQL executed (${getRiskDescription(result.risk)})`);
+
+		if (result.meta?.changes !== undefined && result.meta.changes > 0) {
+			item(`Rows affected: ${result.meta.changes}`);
+		}
+
+		if (result.meta?.duration_ms !== undefined) {
+			item(`Duration: ${result.meta.duration_ms}ms`);
+		}
+
+		if (result.warning) {
+			console.error("");
+			warn(result.warning);
+		}
+
+		// Output query results
+		if (result.results && result.results.length > 0) {
+			console.error("");
+			console.log(JSON.stringify(result.results, null, 2));
+		}
+		console.error("");
+
+		// Track telemetry
+		track(Events.SQL_EXECUTED, {
+			risk_level: result.risk,
+			statement_count: result.statements.length,
+			from_file: !!execArgs.filePath,
+		});
+	} catch (err) {
+		outputSpinner.stop();
+
+		if (err instanceof WriteNotAllowedError) {
+			console.error("");
+			error(err.message);
+			info("Add the --write flag to allow data modification:");
+			info(`  jack services db execute "${execArgs.sql || `--file ${execArgs.filePath}`}" --write`);
+			console.error("");
+			process.exit(1);
+		}
+
+		if (err instanceof DestructiveOperationError) {
+			console.error("");
+			error(err.message);
+			info("Destructive operations require confirmation via CLI.");
+			console.error("");
+			process.exit(1);
+		}
+
+		console.error("");
+		error(`SQL execution failed: ${err instanceof Error ? err.message : String(err)}`);
+		console.error("");
+		process.exit(1);
+	}
+}

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) {