@getjack/jack 0.1.2 → 0.1.3

package/src/lib/local-paths.ts

@@ -0,0 +1,258 @@
+/**
+ * Local Paths Index
+ *
+ * Tracks where projects live on the local filesystem.
+ * This is a cache - can be rebuilt by scanning directories.
+ *
+ * Design:
+ * - One project can have multiple local paths (forks, copies)
+ * - Paths are verified on read (deleted dirs are pruned)
+ * - Auto-registered when jack commands run from project dirs
+ */
+
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { CONFIG_DIR } from "./config.ts";
+
+/**
+ * Local paths index structure
+ */
+export interface LocalPathsIndex {
+	version: 1;
+	/** Map of project name -> array of local paths */
+	paths: Record<string, string[]>;
+	/** Last time the index was updated */
+	updatedAt: string;
+}
+
+const INDEX_PATH = join(CONFIG_DIR, "local-paths.json");
+
+/** Directories to skip when scanning */
+const SKIP_DIRS = new Set([
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".next",
+	".nuxt",
+	".output",
+	"coverage",
+	".turbo",
+	".cache",
+]);
+
+/**
+ * Check if a directory has a wrangler config file
+ */
+function hasWranglerConfig(dir: string): boolean {
+	return (
+		existsSync(join(dir, "wrangler.jsonc")) ||
+		existsSync(join(dir, "wrangler.toml")) ||
+		existsSync(join(dir, "wrangler.json"))
+	);
+}
+
+/**
+ * Read the local paths index from disk
+ */
+export async function readLocalPaths(): Promise<LocalPathsIndex> {
+	if (!existsSync(INDEX_PATH)) {
+		return { version: 1, paths: {}, updatedAt: new Date().toISOString() };
+	}
+
+	try {
+		return await Bun.file(INDEX_PATH).json();
+	} catch {
+		// Handle corrupted index file gracefully
+		return { version: 1, paths: {}, updatedAt: new Date().toISOString() };
+	}
+}
+
+/**
+ * Write the local paths index to disk
+ */
+export async function writeLocalPaths(index: LocalPathsIndex): Promise<void> {
+	index.updatedAt = new Date().toISOString();
+	await Bun.write(INDEX_PATH, JSON.stringify(index, null, 2));
+}
+
+/**
+ * Register a local path for a project
+ * Idempotent - won't add duplicates
+ */
+export async function registerLocalPath(projectName: string, localPath: string): Promise<void> {
+	const absolutePath = resolve(localPath);
+	const index = await readLocalPaths();
+
+	if (!index.paths[projectName]) {
+		index.paths[projectName] = [];
+	}
+
+	// Avoid duplicates
+	if (!index.paths[projectName].includes(absolutePath)) {
+		index.paths[projectName].push(absolutePath);
+	}
+
+	await writeLocalPaths(index);
+}
+
+/**
+ * Remove a local path for a project
+ */
+export async function removeLocalPath(projectName: string, localPath: string): Promise<void> {
+	const absolutePath = resolve(localPath);
+	const index = await readLocalPaths();
+
+	if (index.paths[projectName]) {
+		index.paths[projectName] = index.paths[projectName].filter((p) => p !== absolutePath);
+
+		// Clean up empty arrays
+		if (index.paths[projectName].length === 0) {
+			delete index.paths[projectName];
+		}
+	}
+
+	await writeLocalPaths(index);
+}
+
+/**
+ * Get all local paths for a project, verified to exist
+ * Automatically prunes paths that no longer exist or lack wrangler config
+ */
+export async function getLocalPaths(projectName: string): Promise<string[]> {
+	const index = await readLocalPaths();
+	const paths = index.paths[projectName] || [];
+
+	// Verify paths exist and have wrangler config
+	const validPaths: string[] = [];
+	const invalidPaths: string[] = [];
+
+	for (const path of paths) {
+		if (hasWranglerConfig(path)) {
+			validPaths.push(path);
+		} else {
+			invalidPaths.push(path);
+		}
+	}
+
+	// Prune invalid paths
+	if (invalidPaths.length > 0) {
+		index.paths[projectName] = validPaths;
+		if (validPaths.length === 0) {
+			delete index.paths[projectName];
+		}
+		await writeLocalPaths(index);
+	}
+
+	return validPaths;
+}
+
+/**
+ * Get all local paths for all projects, verified to exist
+ * Returns a map of projectName -> paths[]
+ */
+export async function getAllLocalPaths(): Promise<Record<string, string[]>> {
+	const index = await readLocalPaths();
+	const result: Record<string, string[]> = {};
+	let needsWrite = false;
+
+	for (const [projectName, paths] of Object.entries(index.paths)) {
+		const validPaths: string[] = [];
+
+		for (const path of paths) {
+			if (hasWranglerConfig(path)) {
+				validPaths.push(path);
+			} else {
+				needsWrite = true;
+			}
+		}
+
+		if (validPaths.length > 0) {
+			result[projectName] = validPaths;
+		} else if (paths.length > 0) {
+			needsWrite = true;
+		}
+	}
+
+	// Write back pruned index if needed
+	if (needsWrite) {
+		index.paths = result;
+		await writeLocalPaths(index);
+	}
+
+	return result;
+}
+
+/**
+ * Scan a directory recursively for jack projects
+ * Returns discovered projects with their paths
+ */
+export async function scanDirectoryForProjects(
+	rootDir: string,
+	maxDepth = 3,
+): Promise<Array<{ name: string; path: string }>> {
+	const { getProjectNameFromDir } = await import("./storage/index.ts");
+	const discovered: Array<{ name: string; path: string }> = [];
+	const absoluteRoot = resolve(rootDir);
+
+	async function scan(dir: string, depth: number): Promise<void> {
+		if (depth > maxDepth) return;
+
+		// Check if this directory is a jack project
+		try {
+			const name = await getProjectNameFromDir(dir);
+			discovered.push({ name, path: dir });
+			return; // Don't scan subdirectories of projects
+		} catch {
+			// Not a project, continue scanning subdirectories
+		}
+
+		// Scan subdirectories
+		try {
+			const entries = await readdir(dir, { withFileTypes: true });
+
+			for (const entry of entries) {
+				// Skip non-directories
+				if (!entry.isDirectory()) continue;
+
+				// Skip hidden directories and common non-project directories
+				if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name)) {
+					continue;
+				}
+
+				const fullPath = join(dir, entry.name);
+				await scan(fullPath, depth + 1);
+			}
+		} catch {
+			// Permission denied or other error, skip silently
+		}
+	}
+
+	await scan(absoluteRoot, 0);
+	return discovered;
+}
+
+/**
+ * Register multiple discovered projects
+ * More efficient than calling registerLocalPath for each project
+ */
+export async function registerDiscoveredProjects(
+	projects: Array<{ name: string; path: string }>,
+): Promise<void> {
+	const index = await readLocalPaths();
+
+	for (const { name, path } of projects) {
+		const absolutePath = resolve(path);
+
+		if (!index.paths[name]) {
+			index.paths[name] = [];
+		}
+
+		if (!index.paths[name].includes(absolutePath)) {
+			index.paths[name].push(absolutePath);
+		}
+	}
+
+	await writeLocalPaths(index);
+}

package/src/lib/managed-deploy.ts

@@ -0,0 +1,175 @@
+/**
+ * Managed deploy handler for jack cloud
+ *
+ * Isolates managed deployment logic from BYO (wrangler) path.
+ */
+
+import { validateBindings } from "./binding-validator.ts";
+import { buildProject, parseWranglerConfig } from "./build-helper.ts";
+import { createManagedProject } from "./control-plane.ts";
+import { uploadDeployment } from "./deploy-upload.ts";
+import { JackError, JackErrorCode } from "./errors.ts";
+import type { OperationReporter } from "./project-operations.ts";
+import { Events, track } from "./telemetry.ts";
+import { packageForDeploy } from "./zip-packager.ts";
+
+export interface ManagedCreateResult {
+	projectId: string;
+	projectSlug: string;
+	orgId: string;
+	runjackUrl: string;
+	status?: "live" | "created";
+	prebuiltFailed?: boolean;
+	prebuiltError?: string;
+}
+
+export interface ManagedCreateOptions {
+	template?: string;
+	usePrebuilt?: boolean;
+}
+
+/**
+ * Create a project via the jack cloud control plane.
+ *
+ * This creates the remote project resource. Local files are created separately
+ * by the main createProject() function.
+ */
+export async function createManagedProjectRemote(
+	projectName: string,
+	reporter?: OperationReporter,
+	options?: ManagedCreateOptions,
+): Promise<ManagedCreateResult> {
+	reporter?.start("Creating managed project...");
+
+	try {
+		const result = await createManagedProject(projectName, {
+			template: options?.template,
+			usePrebuilt: options?.usePrebuilt ?? true,
+		});
+
+		const runjackUrl = `https://${result.project.slug}.runjack.xyz`;
+
+		reporter?.stop();
+		reporter?.success("Created managed project");
+
+		// Track managed project creation
+		track(Events.MANAGED_PROJECT_CREATED, {});
+
+		return {
+			projectId: result.project.id,
+			projectSlug: result.project.slug,
+			orgId: result.project.org_id,
+			runjackUrl,
+			status: result.status,
+			prebuiltFailed: result.prebuilt_failed,
+			prebuiltError: result.prebuilt_error,
+		};
+	} catch (error) {
+		reporter?.stop();
+		throw error;
+	}
+}
+
+export interface ManagedCodeDeployOptions {
+	projectId: string;
+	projectPath: string;
+	reporter?: OperationReporter;
+}
+
+/**
+ * Deploy local code to a managed project via the control plane.
+ *
+ * This builds the project, packages artifacts, and uploads to jack cloud.
+ */
+export async function deployCodeToManagedProject(
+	options: ManagedCodeDeployOptions,
+): Promise<{ deploymentId: string; status: string }> {
+	const { projectId, projectPath, reporter } = options;
+
+	// Track deploy start
+	track(Events.MANAGED_DEPLOY_STARTED, {});
+	const startTime = Date.now();
+
+	let pkg: Awaited<ReturnType<typeof packageForDeploy>> | null = null;
+
+	try {
+		const 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 2: Validate bindings are supported (after build, so assets dir exists)
+		const validation = validateBindings(config, projectPath);
+		if (!validation.valid) {
+			throw new JackError(
+				JackErrorCode.VALIDATION_ERROR,
+				validation.errors[0] || "Invalid bindings configuration",
+				validation.errors.length > 1
+					? `Additional errors:\n${validation.errors.slice(1).join("\n")}`
+					: undefined,
+			);
+		}
+
+		// Step 3: Package artifacts
+		reporter?.start("Packaging artifacts...");
+		pkg = await packageForDeploy(projectPath, buildOutput, config);
+		reporter?.stop();
+		reporter?.success("Packaged artifacts");
+
+		// Step 4: Upload to control plane
+		reporter?.start("Uploading to jack cloud...");
+		const result = await uploadDeployment({
+			projectId,
+			bundleZipPath: pkg.bundleZipPath,
+			sourceZipPath: pkg.sourceZipPath,
+			manifestPath: pkg.manifestPath,
+			schemaPath: pkg.schemaPath ?? undefined,
+			secretsPath: pkg.secretsPath ?? undefined,
+			assetsZipPath: pkg.assetsZipPath ?? undefined,
+			assetManifest: pkg.assetManifest ?? undefined,
+		});
+
+		reporter?.stop();
+		reporter?.success("Deployed to jack cloud");
+
+		// Track success
+		track(Events.MANAGED_DEPLOY_COMPLETED, {
+			duration_ms: Date.now() - startTime,
+		});
+
+		return {
+			deploymentId: result.id,
+			status: result.status,
+		};
+	} catch (error) {
+		reporter?.stop();
+
+		// Track failure
+		track(Events.MANAGED_DEPLOY_FAILED, {
+			duration_ms: Date.now() - startTime,
+		});
+
+		throw error;
+	} finally {
+		// Always cleanup temp files
+		if (pkg) {
+			await pkg.cleanup().catch(() => {});
+		}
+	}
+}
+
+/**
+ * Deploy to a managed project via the control plane.
+ */
+export async function deployToManagedProject(
+	projectId: string,
+	projectPath: string,
+	reporter?: OperationReporter,
+): Promise<{ deploymentId: string; status: string }> {
+	return deployCodeToManagedProject({
+		projectId,
+		projectPath,
+		reporter,
+	});
+}

package/src/lib/managed-down.ts

@@ -0,0 +1,159 @@
+/**
+ * Managed mode project deletion handler
+ * Mirrors BYO down.ts flow but uses control plane APIs.
+ */
+
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { deleteManagedProject, exportManagedDatabase } from "./control-plane.ts";
+import { promptSelect } from "./hooks.ts";
+import { error, info, item, output, success, warn } from "./output.ts";
+import type { Project } from "./registry.ts";
+import { updateProject } from "./registry.ts";
+
+export interface ManagedDownFlags {
+	force?: boolean;
+}
+
+export async function managedDown(
+	project: Project,
+	projectName: string,
+	flags: ManagedDownFlags = {},
+): Promise<boolean> {
+	const remote = project.remote;
+	if (!remote?.project_id) {
+		throw new Error("Project is not linked to jack cloud");
+	}
+
+	const runjackUrl = remote.runjack_url;
+	const projectId = remote.project_id;
+
+	// Force mode - quick deletion without prompts
+	if (flags.force) {
+		console.error("");
+		info(`Undeploying '${projectName}'`);
+		console.error("");
+
+		output.start("Undeploying from jack cloud...");
+		try {
+			await deleteManagedProject(projectId);
+			output.stop();
+
+			await updateProject(projectName, {
+				workerUrl: null,
+				lastDeployed: null,
+			});
+
+			console.error("");
+			success(`'${projectName}' undeployed`);
+			info("Database and backups were deleted");
+			console.error("");
+			return true;
+		} catch (err) {
+			output.stop();
+			throw err;
+		}
+	}
+
+	// Interactive mode
+	console.error("");
+	info(`Project: ${projectName}`);
+	if (runjackUrl) {
+		item(`URL: ${runjackUrl}`);
+	}
+	item("Mode: jack cloud (managed)");
+	item("Database: managed D1");
+	console.error("");
+
+	// Confirm undeploy
+	console.error("");
+	info("Undeploy this project?");
+	const action = await promptSelect(["Yes", "No"]);
+
+	if (action !== 0) {
+		info("Cancelled");
+		return false;
+	}
+
+	// Ask about database export
+	console.error("");
+	info("Database will be deleted with the project");
+
+	console.error("");
+	info("Export database before deleting?");
+	const exportAction = await promptSelect(["Yes", "No"]);
+
+	if (exportAction === 0) {
+		const exportPath = join(process.cwd(), `${projectName}-backup.sql`);
+		output.start(`Exporting database to ${exportPath}...`);
+
+		try {
+			const exportResult = await exportManagedDatabase(projectId);
+
+			// Download the SQL file
+			const response = await fetch(exportResult.download_url);
+			if (!response.ok) {
+				throw new Error(`Failed to download export: ${response.statusText}`);
+			}
+
+			const sqlContent = await response.text();
+			await writeFile(exportPath, sqlContent, "utf-8");
+
+			output.stop();
+			success(`Database exported to ${exportPath}`);
+		} catch (err) {
+			output.stop();
+			error(`Failed to export database: ${err instanceof Error ? err.message : String(err)}`);
+
+			// If export times out, abort
+			if (err instanceof Error && err.message.includes("timed out")) {
+				error("Export timeout - deletion aborted");
+				return false;
+			}
+
+			console.error("");
+			info("Continue without exporting?");
+			const continueAction = await promptSelect(["Yes", "No"]);
+
+			if (continueAction !== 0) {
+				info("Cancelled");
+				return false;
+			}
+		}
+	}
+
+	// Execute deletion
+	console.error("");
+	info("Executing cleanup...");
+	console.error("");
+
+	output.start("Undeploying from jack cloud...");
+	try {
+		const result = await deleteManagedProject(projectId);
+		output.stop();
+		success(`'${projectName}' undeployed`);
+
+		// Report resource results
+		for (const resource of result.resources) {
+			if (resource.success) {
+				success(`Deleted ${resource.resource}`);
+			} else {
+				warn(`Failed to delete ${resource.resource}: ${resource.error}`);
+			}
+		}
+
+		await updateProject(projectName, {
+			workerUrl: null,
+			lastDeployed: null,
+		});
+
+		console.error("");
+		success(`Project '${projectName}' undeployed`);
+		console.error("");
+		return true;
+	} catch (err) {
+		output.stop();
+		error(`Failed to undeploy: ${err instanceof Error ? err.message : String(err)}`);
+		throw err;
+	}
+}