@getjack/jack 0.1.2 → 0.1.4

package/src/commands/projects.ts

@@ -1,13 +1,19 @@
-import { dirname } from "node:path";
-import { select } from "@inquirer/prompts";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { promptSelect } from "../lib/hooks.ts";
 import { error, info, item, output as outputSpinner, success, warn } from "../lib/output.ts";
 import {
 	cleanupStaleProjects,
 	getProjectStatus,
-	listAllProjects,
 	scanStaleProjects,
-	type ProjectStatus,
 } from "../lib/project-operations.ts";
+import {
+	type ResolvedProject,
+	listAllProjects,
+	removeProject as removeProjectEverywhere,
+	resolveProject,
+} from "../lib/project-resolver.ts";
 import { getProjectNameFromDir } from "../lib/storage/index.ts";
 
 /**
@@ -21,87 +27,85 @@ export default async function projects(subcommand?: string, args: string[] = [])
 	switch (subcommand) {
 		case "info":
 			return await infoProject(args);
+		case "remove":
+			return await removeProjectEntry(args);
 		case "cleanup":
 			return await cleanupProjects();
-		default:
+		case "scan":
+			return await scanProjects(args);
+		case "down":
+			return await handleDown(args);
+		default: {
+			// Commands that are valid top-level commands users might try under projects
+			const topLevelCommands = ["open", "logs", "clone", "sync"];
+			const isTopLevel = topLevelCommands.includes(subcommand);
+
 			error(`Unknown subcommand: ${subcommand}`);
-			info("Available: list, info, cleanup");
+			if (isTopLevel) {
+				const projectArg = args[0] ? ` ${args[0]}` : "";
+				info(`Did you mean: jack ${subcommand}${projectArg}`);
+			}
+			info("Available: list, info, remove, cleanup, scan, down");
 			process.exit(1);
+		}
 	}
 }
 
 /**
  * List all projects with status indicators
  */
-async function listProjects(args: string[]): Promise<void> {
-	// Parse flags
-	const flags = {
-		local: args.includes("--local"),
-		deployed: args.includes("--deployed"),
-		cloud: args.includes("--cloud"),
-	};
-
-	// Determine status for each project (with spinner for API calls)
+async function listProjects(_args: string[]): Promise<void> {
+	// Fetch all projects from registry and control plane
 	outputSpinner.start("Checking project status...");
-	const statuses: ProjectStatus[] = await listAllProjects();
+	const projects: ResolvedProject[] = await listAllProjects();
 	outputSpinner.stop();
 
-	if (statuses.length === 0) {
+	if (projects.length === 0) {
 		info("No projects found");
 		info("Create a project with: jack new <name>");
 		return;
 	}
 
-	// Filter based on flags
-	let filteredStatuses = statuses;
-	if (flags.local) {
-		filteredStatuses = filteredStatuses.filter((s) => s.local);
-	}
-	if (flags.deployed) {
-		filteredStatuses = filteredStatuses.filter((s) => s.deployed);
-	}
-	if (flags.cloud) {
-		filteredStatuses = filteredStatuses.filter((s) => s.backedUp);
-	}
+	// Separate local projects from cloud-only projects
+	const localProjects: ResolvedProject[] = [];
+	const cloudOnlyProjects: ResolvedProject[] = [];
 
-	if (filteredStatuses.length === 0) {
-		info("No projects match the specified filters");
-		return;
+	for (const proj of projects) {
+		if (proj.localPath && proj.sources.filesystem) {
+			localProjects.push(proj);
+		} else {
+			cloudOnlyProjects.push(proj);
+		}
 	}
 
-	// Group projects by parent directory
+	// Group local projects by parent directory
 	interface DirectoryGroup {
-		path: string;
-		projects: ProjectStatus[];
+		displayPath: string;
+		projects: ResolvedProject[];
 	}
 
 	const groups = new Map<string, DirectoryGroup>();
-	const ungrouped: ProjectStatus[] = [];
-	const stale: ProjectStatus[] = [];
-
-	for (const status of filteredStatuses) {
-		// Stale projects go to their own section
-		if (status.missing) {
-			stale.push(status);
-		} else if (status.localPath && status.local) {
-			const parent = dirname(status.localPath);
-			if (!groups.has(parent)) {
-				groups.set(parent, { path: parent, projects: [] });
-			}
-			groups.get(parent)?.projects.push(status);
-		} else {
-			ungrouped.push(status);
+	const home = homedir();
+
+	for (const proj of localProjects) {
+		if (!proj.localPath) continue;
+		const parent = dirname(proj.localPath);
+		if (!groups.has(parent)) {
+			// Replace home directory with ~ for display
+			const displayPath = parent.startsWith(home) ? `~${parent.slice(home.length)}` : parent;
+			groups.set(parent, { displayPath, projects: [] });
 		}
+		groups.get(parent)?.projects.push(proj);
 	}
 
-	// Display grouped projects
+	// Display header
 	console.error("");
-	info("Projects");
+	info("Your projects");
 	console.error("");
 
-	// Display directory groups (active local projects)
+	// Display local project groups
 	for (const [_parentPath, group] of groups) {
-		console.error(`${colors.dim}${group.path}/${colors.reset}`);
+		console.error(`  ${colors.dim}${group.displayPath}/${colors.reset}`);
 		const sortedProjects = group.projects.sort((a, b) => a.name.localeCompare(b.name));
 
 		for (let i = 0; i < sortedProjects.length; i++) {
@@ -110,51 +114,41 @@ async function listProjects(args: string[]): Promise<void> {
 			const isLast = i === sortedProjects.length - 1;
 			const prefix = isLast ? "└──" : "├──";
 
-			const badges = buildStatusBadges(proj);
-			console.error(`  ${colors.dim}${prefix}${colors.reset} ${proj.name}  ${badges}`);
+			const statusBadge = buildStatusBadge(proj);
+			console.error(`  ${colors.dim}${prefix}${colors.reset} ${proj.name}  ${statusBadge}`);
 		}
 		console.error("");
 	}
 
-	// Display ungrouped projects (cloud-only, no local path)
-	if (ungrouped.length > 0) {
-		console.error(`${colors.dim}Cloud only:${colors.reset}`);
-		for (const proj of ungrouped) {
-			const badges = buildStatusBadges(proj);
-			console.error(`  ${proj.name}  ${badges}`);
-		}
-		console.error("");
-	}
+	// Display cloud-only projects
+	if (cloudOnlyProjects.length > 0) {
+		console.error(`  ${colors.dim}On jack cloud (no local files)${colors.reset}`);
+		const sortedCloudProjects = cloudOnlyProjects.sort((a, b) => a.name.localeCompare(b.name));
+
+		for (let i = 0; i < sortedCloudProjects.length; i++) {
+			const proj = sortedCloudProjects[i];
+			if (!proj) continue;
+			const isLast = i === sortedCloudProjects.length - 1;
+			const prefix = isLast ? "└──" : "├──";
 
-	// Display stale projects (local folder deleted)
-	if (stale.length > 0) {
-		console.error(`${colors.yellow}Stale (local folder deleted):${colors.reset}`);
-		for (const proj of stale) {
-			// Only show non-missing badges since the section header explains the issue
-			const badges = buildStatusBadges({ ...proj, missing: false });
-			console.error(`  ${colors.dim}${proj.name}${colors.reset}  ${badges}`);
+			const statusBadge = buildStatusBadge(proj);
+			console.error(`  ${colors.dim}${prefix}${colors.reset} ${proj.name}  ${statusBadge}`);
 		}
 		console.error("");
 	}
 
 	// Summary
-	const deployedCount = statuses.filter((s) => s.deployed).length;
-	const notDeployedCount = statuses.filter((s) => s.local && !s.deployed).length;
-	const staleCount = statuses.filter((s) => s.missing).length;
+	const liveCount = projects.filter((p) => p.status === "live").length;
+	const localOnlyCount = projects.filter((p) => p.status === "local-only").length;
+	const errorCount = projects.filter((p) => p.status === "error").length;
 
-	const parts = [`${deployedCount} deployed`];
-	if (notDeployedCount > 0) {
-		parts.push(`${notDeployedCount} not deployed`);
-	}
-	if (staleCount > 0) {
-		parts.push(`${staleCount} stale`);
-	}
-	info(`${statuses.length} projects (${parts.join(", ")})`);
-	if (staleCount > 0) {
-		console.error(
-			`  ${colors.dim}Run 'jack projects cleanup' to remove stale entries${colors.reset}`,
-		);
-	}
+	const parts: string[] = [];
+	if (liveCount > 0) parts.push(`${liveCount} live`);
+	if (localOnlyCount > 0) parts.push(`${localOnlyCount} local-only`);
+	if (errorCount > 0) parts.push(`${errorCount} error`);
+
+	const summary = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+	info(`${projects.length} projects${summary}`);
 	console.error("");
 }
 
@@ -169,25 +163,21 @@ const colors = {
 };
 
 /**
- * Build status badge string for a project
+ * Build a user-friendly status badge for a project
  */
-function buildStatusBadges(status: ProjectStatus): string {
-	const badges: string[] = [];
-
-	if (status.local) {
-		badges.push(`${colors.green}[local]${colors.reset}`);
-	}
-	if (status.deployed) {
-		badges.push(`${colors.green}[deployed]${colors.reset}`);
-	}
-	if (status.backedUp) {
-		badges.push(`${colors.dim}[cloud]${colors.reset}`);
-	}
-	if (status.missing) {
-		badges.push(`${colors.yellow}[local deleted]${colors.reset}`);
+function buildStatusBadge(project: ResolvedProject): string {
+	switch (project.status) {
+		case "live":
+			return `${colors.green}[live]${colors.reset} ${colors.cyan}${project.url || ""}${colors.reset}`;
+		case "local-only":
+			return `${colors.dim}[local only]${colors.reset}`;
+		case "error":
+			return `${colors.red}[error]${colors.reset} ${project.errorMessage || "deployment failed"}`;
+		case "syncing":
+			return `${colors.yellow}[syncing]${colors.reset}`;
+		default:
+			return "";
 	}
-
-	return badges.join(" ");
 }
 
 /**
@@ -232,21 +222,15 @@ async function infoProject(args: string[]): Promise<void> {
 		statuses.push("deployed");
 	}
 	if (status.backedUp) {
-		statuses.push("backed-up");
-	}
-	if (status.missing) {
-		statuses.push("missing");
+		statuses.push("backup");
 	}
 
 	item(`Status: ${statuses.join(", ") || "none"}`);
 	console.error("");
 
-	// Local info
+	// Workspace info (only shown if running from project directory)
 	if (status.localPath) {
-		item(`Local path: ${status.localPath}`);
-		if (status.missing) {
-			warn("  Path no longer exists");
-		}
+		item(`Workspace path: ${status.localPath}`);
 		console.error("");
 	}
 
@@ -261,9 +245,9 @@ async function infoProject(args: string[]): Promise<void> {
 		console.error("");
 	}
 
-	// Cloud info
+	// Backup info
 	if (status.backedUp && status.backupFiles !== null) {
-		item(`Cloud backup: ${status.backupFiles} files`);
+		item(`Backup: ${status.backupFiles} files`);
 		if (status.backupLastSync) {
 			item(`Last synced: ${new Date(status.backupLastSync).toLocaleString()}`);
 		}
@@ -293,7 +277,7 @@ async function infoProject(args: string[]): Promise<void> {
 }
 
 /**
- * Remove stale registry entries
+ * Find and remove stale registry entries (projects with URLs but no deployed worker)
  */
 async function cleanupProjects(): Promise<void> {
 	outputSpinner.start("Scanning for stale projects...");
@@ -316,42 +300,24 @@ async function cleanupProjects(): Promise<void> {
 	console.error("");
 	info("What cleanup does:");
 	item("Removes entries from jack's local tracking registry");
-	item("Does NOT undeploy live services");
-	item("Does NOT delete cloud backups or databases");
+	item("Does NOT delete backups or databases");
+	info("Remove a single entry with: jack projects remove <name>");
 	console.error("");
 
 	// Show found issues
 	warn(`Found ${scan.stale.length} stale project(s):`);
 	console.error("");
 
-	// Check which have deployed workers
-	const deployedStale = scan.stale.filter((stale) => stale.workerUrl);
-
 	for (const stale of scan.stale) {
-		const hasWorker = stale.workerUrl
-			? ` ${colors.yellow}(still deployed)${colors.reset}`
-			: "";
-		item(`${stale.name}: ${stale.reason}${hasWorker}`);
+		item(`${stale.name}: ${stale.reason} (URL: ${stale.workerUrl})`);
 	}
 	console.error("");
 
-	if (deployedStale.length > 0) {
-		warn(`${deployedStale.length} project(s) are still deployed`);
-		info("To fully remove, run 'jack down <name>' first");
-		console.error("");
-	}
-
 	// Prompt to remove
-	console.error("  Esc to skip\n");
-	const action = await select({
-		message: "Remove these from jack's tracking? (deployed services stay live)",
-		choices: [
-			{ name: "1. Yes", value: "yes" },
-			{ name: "2. No", value: "no" },
-		],
-	});
-
-	if (action === "no") {
+	info("Remove these from jack's tracking?");
+	const choice = await promptSelect(["Yes", "No"]);
+
+	if (choice !== 0) {
 		info("Cleanup cancelled");
 		return;
 	}
@@ -361,7 +327,167 @@ async function cleanupProjects(): Promise<void> {
 
 	console.error("");
 	success(`Removed ${scan.stale.length} entry/entries from jack's registry`);
-	if (deployedStale.length > 0) {
-		info("Note: Deployed services are still live");
+}
+
+/**
+ * Remove a project from registry and jack cloud
+ */
+async function removeProjectEntry(args: string[]): Promise<void> {
+	const name = args.find((arg) => !arg.startsWith("--"));
+	const yes = args.includes("--yes");
+
+	if (!name) {
+		error("Project name required");
+		info("Usage: jack projects remove <name>");
+		process.exit(1);
+	}
+
+	// Use resolver to find project anywhere (registry OR control plane)
+	outputSpinner.start("Checking project status...");
+	const project = await resolveProject(name);
+	outputSpinner.stop();
+
+	if (!project) {
+		error(`Project "${name}" not found`);
+		info("Check available projects with: jack projects");
+		process.exit(1);
+	}
+
+	// Show what we found and where
+	console.error("");
+	info(`Removing "${name}"...`);
+	console.error("");
+
+	// Show project details
+	if (project.localPath) {
+		item(`Workspace: ${project.localPath}`);
+	}
+	if (project.url) {
+		item(`URL: ${project.url}`);
+	}
+
+	// Show where we'll remove from
+	const locations: string[] = [];
+	if (project.sources.registry) {
+		locations.push("local registry");
+	}
+	if (project.sources.controlPlane) {
+		locations.push("jack cloud");
+	}
+	if (locations.length > 0) {
+		item(`Will remove from: ${locations.join(", ")}`);
+	}
+
+	// Warn if still deployed
+	if (project.status === "live") {
+		console.error("");
+		warn("Project is still deployed; removal does not undeploy the worker");
+	}
+
+	console.error("");
+
+	if (!yes) {
+		info("Remove this project?");
+		const choice = await promptSelect(["Yes", "No"]);
+
+		if (choice !== 0) {
+			info("Removal cancelled");
+			return;
+		}
+	}
+
+	// Use resolver's removeProject to clean up everywhere
+	outputSpinner.start("Removing project...");
+	const result = await removeProjectEverywhere(name);
+	outputSpinner.stop();
+
+	console.error("");
+
+	// Show what was removed
+	if (result.removed.length > 0) {
+		for (const location of result.removed) {
+			success(`Removed from ${location}`);
+		}
+	}
+
+	// Show any errors
+	if (result.errors.length > 0) {
+		for (const err of result.errors) {
+			warn(err);
+		}
+	}
+
+	// Final status
+	if (result.removed.length > 0 && result.errors.length === 0) {
+		console.error("");
+		success(`Project "${name}" removed`);
+	} else if (result.removed.length === 0) {
+		console.error("");
+		error(`Failed to remove "${name}"`);
 	}
+
+	// Hint about undeploying
+	if (project.status === "live") {
+		console.error("");
+		info(`To undeploy the worker, run: jack down ${name}`);
+	}
+}
+
+/**
+ * Scan a directory for jack projects and register them
+ */
+async function scanProjects(args: string[]): Promise<void> {
+	const targetDir = args[0] || process.cwd();
+	const absoluteDir = resolve(targetDir);
+
+	if (!existsSync(absoluteDir)) {
+		error(`Directory not found: ${targetDir}`);
+		process.exit(1);
+	}
+
+	outputSpinner.start(`Scanning ${targetDir} for jack projects...`);
+
+	const { scanDirectoryForProjects, registerDiscoveredProjects } = await import(
+		"../lib/local-paths.ts"
+	);
+
+	const discovered = await scanDirectoryForProjects(absoluteDir);
+	outputSpinner.stop();
+
+	if (discovered.length === 0) {
+		info("No jack projects found");
+		info("Projects must have a wrangler.toml or wrangler.jsonc file");
+		return;
+	}
+
+	console.error("");
+	info(`Found ${discovered.length} project(s):`);
+
+	const home = homedir();
+	for (let i = 0; i < discovered.length; i++) {
+		const proj = discovered[i];
+		if (!proj) continue;
+		const displayPath = proj.path.startsWith(home) ? `~${proj.path.slice(home.length)}` : proj.path;
+		const isLast = i === discovered.length - 1;
+		const prefix = isLast ? "└──" : "├──";
+		console.error(
+			`  ${colors.dim}${prefix}${colors.reset} ${proj.name}  ${colors.dim}${displayPath}${colors.reset}`,
+		);
+	}
+
+	// Register all discovered projects
+	await registerDiscoveredProjects(discovered);
+
+	console.error("");
+	success(`Registered ${discovered.length} local path(s)`);
+}
+
+/**
+ * Handle down subcommand - routes to top-level down command
+ */
+async function handleDown(args: string[]): Promise<void> {
+	const { default: down } = await import("./down.ts");
+	const projectName = args.find((arg) => !arg.startsWith("--"));
+	const force = args.includes("--force");
+	return await down(projectName, { force });
 }