@getjack/jack 0.1.28 → 0.1.30

package/package.json

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

package/src/commands/cd.ts

@@ -0,0 +1,163 @@
+/**
+ * cd command - print project path for shell integration
+ *
+ * Usage: jack cd <name>
+ *
+ * Outputs ONLY the absolute path to stdout (no other output).
+ * Error messages go to stderr.
+ *
+ * Exit codes:
+ * - 0: Success (path printed)
+ * - 1: No match, error, or project cannot be resolved
+ */
+
+import { join } from "node:path";
+import { CloneCollisionError, ProjectNotFoundError, cloneProject } from "../lib/clone-core.ts";
+import { getJackHome } from "../lib/config.ts";
+import { fuzzyFilter } from "../lib/fuzzy.ts";
+import { error } from "../lib/output.ts";
+import { registerPath } from "../lib/paths-index.ts";
+import { linkProject } from "../lib/project-link.ts";
+import { type ResolvedProject, listAllProjects } from "../lib/project-resolver.ts";
+import {
+	detectShell,
+	getRcFilePath,
+	isInstalled as isShellIntegrationInstalled,
+} from "../lib/shell-integration.ts";
+
+function maybeShowShellHint(path: string): void {
+	const shell = detectShell();
+	const rcFile = getRcFilePath(shell);
+
+	if (!rcFile || shell === "unknown") return;
+	if (isShellIntegrationInstalled(rcFile)) return;
+	console.error(`cd ${path}`);
+}
+
+/**
+ * Find the best matching project by name using fuzzy matching.
+ * Tiebreaker: most recently deployed wins (updatedAt descending).
+ *
+ * @param query - The search query
+ * @param projects - All resolved projects
+ * @returns The best matching project or null
+ */
+function findBestMatch(query: string, projects: ResolvedProject[]): ResolvedProject | null {
+	// Sort by updatedAt descending before fuzzy filter so tiebreaker favors recent
+	const sorted = [...projects].sort((a, b) => {
+		const aTime = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+		const bTime = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+		return bTime - aTime;
+	});
+
+	// Fuzzy filter preserves sort order for items with equal scores
+	const matches = fuzzyFilter(query, sorted, (p) => p.name);
+
+	return matches[0] ?? null;
+}
+
+export default async function cd(projectName?: string): Promise<void> {
+	// Validate project name
+	if (!projectName) {
+		// No match: exit 1, no message (shell wrapper handles it)
+		process.exit(1);
+	}
+
+	let projects: ResolvedProject[];
+
+	// Fetch all projects (local + cloud)
+	try {
+		projects = await listAllProjects();
+	} catch (err) {
+		// Network timeout
+		error("Could not reach cloud. Check your connection.");
+		if (process.env.DEBUG || process.argv.includes("--debug")) {
+			console.error("Debug:", err);
+		}
+		process.exit(1);
+	}
+
+	// Find best match using fuzzy matching
+	const match = findBestMatch(projectName, projects);
+
+	if (!match) {
+		// No match: exit 1, no message
+		process.exit(1);
+	}
+
+	// Check if project has local path
+	if (match.localPath) {
+		// Local copy exists - print path and exit
+		console.log(match.localPath);
+		maybeShowShellHint(match.localPath);
+		process.exit(0);
+	}
+
+	// Cloud-only project: check deploy mode
+	if (match.deployMode === "managed") {
+		// Managed cloud-only: auto-clone to JACK_HOME
+		const jackHome = getJackHome();
+		const targetDir = join(jackHome, match.slug || match.name);
+
+		try {
+			const result = await cloneProject(match.slug || match.name, targetDir, {
+				silent: true,
+				skipPrompts: true,
+			});
+
+			// Link and register the cloned project
+			if (result.projectId) {
+				await linkProject(result.path, result.projectId, "managed");
+				await registerPath(result.projectId, result.path);
+			}
+
+			// Print the cloned path
+			console.log(result.path);
+			maybeShowShellHint(result.path);
+			process.exit(0);
+		} catch (err) {
+			if (err instanceof ProjectNotFoundError) {
+				// Project deleted from cloud
+				error(`Project '${match.name}' no longer exists in cloud.`);
+				process.exit(1);
+			}
+
+			if (err instanceof CloneCollisionError) {
+				// Directory exists but not linked - help user decide what to do
+				error("Directory exists but isn't linked to this project");
+				console.error("");
+				console.error(`  cd ${err.targetDir}`);
+				console.error("");
+				console.error("  jack link   keep local files, connect to cloud");
+				console.error("  jack clone  replace local with cloud version");
+				process.exit(1);
+			}
+
+			// Check for "no source backup" error (orphan project)
+			const errMsg = err instanceof Error ? err.message : "";
+			if (errMsg.includes("source not found")) {
+				error(`'${match.name}' has no cloud backup.`);
+				console.error("  This project was created before source backup was enabled.");
+				console.error(`  Remove it with: jack down ${match.name}`);
+				process.exit(1);
+			}
+
+			// Other clone errors (network, etc.)
+			error("Could not reach cloud. Check your connection.");
+			if (process.env.DEBUG || process.argv.includes("--debug")) {
+				console.error("Debug:", err);
+			}
+			process.exit(1);
+		}
+	}
+
+	// BYO cloud-only: error with guidance
+	if (match.deployMode === "byo") {
+		error(`'${match.name}' is a BYO project with no local copy.`);
+		console.error("  Clone it manually or check your backup.");
+		process.exit(1);
+	}
+
+	// Unknown state (should not happen)
+	process.exit(1);
+}

package/src/commands/clone.ts

@@ -1,41 +1,51 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
+import { CloneCollisionError, type CloneReporter, cloneProject } from "../lib/clone-core.ts";
+import { downloadProjectSource } from "../lib/control-plane.ts";
+import { extractZipToDirectory } from "../lib/zip-utils.ts";
 import { isCancel, promptSelectValue } from "../lib/hooks.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 { readProjectLink } 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;
+	force?: boolean;
 }
 
 export default async function clone(projectName?: string, flags: CloneFlags = {}): Promise<void> {
+	// Check if we're in a linked directory and should pull/update
+	const currentLink = await readProjectLink(process.cwd());
+
+	if (!projectName && currentLink?.deploy_mode === "managed") {
+		// No project name, but in a managed linked directory - pull latest code
+		await pullCurrentProject(currentLink.project_id, flags);
+		return;
+	}
+
 	// Validate project name
 	if (!projectName) {
 		error("Project name required");
 		info("Usage: jack clone <project> [--as <directory>]");
+		info("Or run in a linked directory to pull latest code.");
 		process.exit(1);
 	}
 
 	// Determine target directory
 	const targetDir = resolve(flags.as ?? projectName);
+	const displayName = flags.as ?? projectName;
 
-	// Check if target directory exists
+	// Check if target directory exists and handle collision
 	if (existsSync(targetDir)) {
 		// If not TTY, error immediately
 		if (!process.stdout.isTTY) {
-			error(`Directory ${flags.as ?? projectName} already exists`);
+			error(`Directory ${displayName} already exists`);
 			process.exit(1);
 		}
 
 		// Prompt user for action
 		const action = await promptSelectValue(
-			`Directory ${flags.as ?? projectName} already exists. What would you like to do?`,
+			`Directory ${displayName} already exists. What would you like to do?`,
 			[
 				{ value: "overwrite", label: "Overwrite (delete and recreate)" },
 				{ value: "merge", label: "Merge (keep existing files)" },
@@ -52,78 +62,112 @@ export default async function clone(projectName?: string, flags: CloneFlags = {}
 			// Delete directory
 			await Bun.$`rm -rf ${targetDir}`.quiet();
 		}
+		// For "merge", we continue and let files be overwritten/added
 	}
 
-	// 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;
+	// Create reporter for progress output
+	let currentSpinner: ReturnType<typeof spinner> | null = null;
+
+	const reporter: CloneReporter = {
+		onLookup: (name) => {
+			currentSpinner = spinner(`Looking up ${name}...`);
+		},
+		onLookupComplete: (found, isManaged) => {
+			if (found && isManaged) {
+				currentSpinner?.success("Found on jack cloud");
+			} else {
+				currentSpinner?.stop();
+			}
+		},
+		onDownloadStart: (source, details) => {
+			if (source === "cloud") {
+				currentSpinner = spinner("Downloading from jack cloud...");
+			} else {
+				// BYO mode - show file count info first, then start download spinner
+				if (details) {
+					success(`Found ${details}`);
+				}
+				currentSpinner = spinner("Downloading...");
+			}
+		},
+		onDownloadComplete: (fileCount, displayPath) => {
+			currentSpinner?.success(`Restored ${fileCount} file(s) to ${displayPath}`);
+		},
+		onDownloadError: (err) => {
+			currentSpinner?.error("Download failed");
+			error(err);
+		},
+		onTagsRestored: (count) => {
+			info(`Restored ${count} tag(s)`);
+		},
+	};
 
 	try {
-		project = await resolveProject(projectName);
-	} catch {
-		// Not found on control-plane, will fall back to User R2
-	}
-
-	// 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);
+		await cloneProject(projectName, targetDir, { silent: false, skipPrompts: false }, reporter);
+
+		// Show next steps
+		box("Next steps:", [`cd ${displayName}`, "bun install", "jack ship"]);
+	} catch (err) {
+		if (err instanceof CloneCollisionError) {
+			// This shouldn't happen since we handle collision above, but just in case
+			error(err.message);
 			process.exit(1);
 		}
 
-		// Link to control-plane
-		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)`);
+		// For ProjectNotFoundError and other errors
+		if (err instanceof Error) {
+			// Check if it's a "not found" error for BYO projects
+			if (err.message.includes("For BYO projects")) {
+				error(`Project not found: ${projectName}`);
+				info("For BYO projects, run 'jack sync' first to backup your project.");
+			} else {
+				error(err.message);
 			}
-		} 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);
+		} else {
+			error("Clone failed");
 		}
+		process.exit(1);
+	}
+}
 
-		// 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)})`);
+/**
+ * Pull latest code from cloud into current linked directory
+ */
+async function pullCurrentProject(projectId: string, flags: CloneFlags): Promise<void> {
+	// Resolve project to get slug/name
+	const project = await resolveProject(projectId);
+	const projectName = project?.slug || project?.name || projectId;
 
-		// Download files
-		const downloadSpin = spinner("Downloading...");
-		const result = await cloneFromCloud(projectName, targetDir);
+	if (!project) {
+		error("Could not resolve project from control plane");
+		process.exit(1);
+	}
 
-		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);
-		}
+	// Confirm before overwriting (unless --force)
+	if (!flags.force && process.stdout.isTTY) {
+		const action = await promptSelectValue(`Pull latest code for ${projectName}?`, [
+			{ value: "yes", label: "Yes, overwrite local files" },
+			{ value: "cancel", label: "Cancel" },
+		]);
 
-		downloadSpin.success(`Restored to ./${flags.as ?? projectName}/`);
+		if (isCancel(action) || action === "cancel") {
+			info("Cancelled");
+			process.exit(0);
+		}
 	}
 
-	// Show next steps
-	box("Next steps:", [`cd ${flags.as ?? projectName}`, "bun install", "jack ship"]);
+	const currentSpinner = spinner("Downloading from jack cloud...");
+
+	try {
+		const sourceZip = await downloadProjectSource(projectName);
+		const fileCount = await extractZipToDirectory(sourceZip, process.cwd());
+		currentSpinner.success(`Updated ${fileCount} file(s)`);
+		success(`Pulled latest code for ${projectName}`);
+	} catch (err) {
+		currentSpinner.error("Download failed");
+		if (err instanceof Error) {
+			error(err.message);
+		}
+		process.exit(1);
+	}
 }