@getjack/jack 0.1.2 → 0.1.4

package/src/commands/down.ts

@@ -1,63 +1,55 @@
-import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { select } from "@inquirer/prompts";
 import {
 	checkWorkerExists,
 	deleteDatabase,
 	deleteWorker,
 	exportDatabase,
 } from "../lib/cloudflare-api.ts";
+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 Project,
-	getProject,
-	getProjectDatabaseName,
-	updateProject,
-	updateProjectDatabase,
-} from "../lib/registry.ts";
+import { resolveProject } from "../lib/project-resolver.ts";
+import { type Project, getProject, updateProject } from "../lib/registry.ts";
+import { parseWranglerResources } from "../lib/resources.ts";
 import { deleteCloudProject, getProjectNameFromDir } from "../lib/storage/index.ts";
 
 /**
- * Get database name for a project, with fallback to wrangler config
+ * Resolve database name for a project.
+ * For managed projects: fetch from control plane.
+ * For BYO projects: parse from wrangler.jsonc in cwd.
  */
-async function resolveDbName(project: Project): Promise<string | null> {
-	// First check registry
-	const dbFromRegistry = getProjectDatabaseName(project);
-	if (dbFromRegistry) {
-		return dbFromRegistry;
+async function resolveDatabaseName(project: Project, projectName: string): Promise<string | null> {
+	// For managed projects, fetch from control plane
+	if (project.deploy_mode === "managed" && project.remote?.project_id) {
+		try {
+			const resources = await fetchProjectResources(project.remote.project_id);
+			const d1 = resources.find((r) => r.resource_type === "d1");
+			return d1?.resource_name || null;
+		} catch {
+			return null;
+		}
 	}
 
-	// Fallback: read from wrangler config file
-	if (project.localPath && existsSync(project.localPath)) {
-		const jsoncPath = join(project.localPath, "wrangler.jsonc");
-		if (existsSync(jsoncPath)) {
-			try {
-				const content = await Bun.file(jsoncPath).text();
-				const jsonContent = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-				const config = JSON.parse(jsonContent);
-				if (config.d1_databases?.[0]?.database_name) {
-					return config.d1_databases[0].database_name;
-				}
-			} catch {
-				// Ignore parse errors
-			}
+	// For BYO, parse from wrangler config in cwd
+	try {
+		let cwdProjectName: string | null = null;
+		try {
+			cwdProjectName = await getProjectNameFromDir(process.cwd());
+		} catch {
+			cwdProjectName = null;
 		}
 
-		const tomlPath = join(project.localPath, "wrangler.toml");
-		if (existsSync(tomlPath)) {
-			try {
-				const content = await Bun.file(tomlPath).text();
-				const match = content.match(/database_name\s*=\s*"([^"]+)"/);
-				if (match?.[1]) {
-					return match[1];
-				}
-			} catch {
-				// Ignore read errors
-			}
+		if (!cwdProjectName || cwdProjectName !== projectName) {
+			warn(`Run this command from the ${projectName} project directory to manage its database.`);
+			return null;
 		}
-	}
 
-	return null;
+		const resources = await parseWranglerResources(process.cwd());
+		return resources.d1?.name || null;
+	} catch {
+		return null;
+	}
 }
 
 export interface DownFlags {
@@ -78,13 +70,58 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			}
 		}
 
-		// Get project from registry
+		// Resolve project from all sources (registry + control plane)
+		const resolved = await resolveProject(name);
+
+		// Check if found only on control plane (orphaned managed project)
+		if (resolved?.sources.controlPlane && !resolved.sources.registry) {
+			console.error("");
+			info(`Found "${name}" on jack cloud, linking locally...`);
+		}
+
+		// Get the registry project (may have been created by resolver cache)
 		const project = await getProject(name);
-		if (!project) {
-			warn(`Project '${name}' not found in registry`);
+
+		if (!resolved && !project) {
+			// Not found anywhere
+			warn(`Project '${name}' not found`);
 			info("Will attempt to undeploy if deployed");
 		}
 
+		// Check if this is a managed project (either from resolved or registry)
+		const isManaged =
+			resolved?.remote?.projectId ||
+			(project?.deploy_mode === "managed" && project.remote?.project_id);
+
+		if (isManaged) {
+			// Build project object for managedDown if we only have resolved data
+			const managedProject: Project = project || {
+				workerUrl: resolved?.url || null,
+				createdAt: resolved?.createdAt || new Date().toISOString(),
+				lastDeployed: resolved?.updatedAt || null,
+				status: resolved?.status === "live" ? "live" : "build_failed",
+				deploy_mode: "managed",
+				remote:
+					resolved?.remote && resolved.url
+						? {
+								project_id: resolved.remote.projectId,
+								project_slug: resolved.slug,
+								org_id: resolved.remote.orgId,
+								runjack_url: resolved.url,
+							}
+						: undefined,
+			};
+
+			// Route to managed deletion flow
+			const deleteSuccess = await managedDown(managedProject, name, flags);
+			if (!deleteSuccess) {
+				process.exit(0); // User cancelled
+			}
+			return;
+		}
+
+		// Continue with existing BYO flow...
+
 		// Check if worker exists
 		output.start("Checking deployment...");
 		const workerExists = await checkWorkerExists(name);
@@ -117,7 +154,7 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 
 			console.error("");
 			success(`'${name}' undeployed`);
-			info("Databases and cloud storage were not affected");
+			info("Databases and backups were not affected");
 			console.error("");
 			return;
 		}
@@ -128,23 +165,18 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 		if (project?.workerUrl) {
 			item(`URL: ${project.workerUrl}`);
 		}
-		const dbName = project ? await resolveDbName(project) : null;
+		const dbName = project ? await resolveDatabaseName(project, name) : null;
 		if (dbName) {
 			item(`Database: ${dbName}`);
 		}
 		console.error("");
 
 		// Confirm undeploy
-		console.error("  Esc to skip\n");
-		const action = await select({
-			message: "Undeploy this project?",
-			choices: [
-				{ name: "1. Yes", value: "yes" },
-				{ name: "2. No", value: "no" },
-			],
-		});
-
-		if (action === "no") {
+		console.error("");
+		info("Undeploy this project?");
+		const action = await promptSelect(["Yes", "No"]);
+
+		if (action !== 0) {
 			info("Cancelled");
 			return;
 		}
@@ -157,16 +189,11 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			info(`Found database: ${dbName}`);
 
 			// Ask if they want to export first
-			console.error("  Esc to skip\n");
-			const exportAction = await select({
-				message: `Export database '${dbName}' before deleting?`,
-				choices: [
-					{ name: "1. Yes", value: "yes" },
-					{ name: "2. No", value: "no" },
-				],
-			});
+			console.error("");
+			info(`Export database '${dbName}' before deleting?`);
+			const exportAction = await promptSelect(["Yes", "No"]);
 
-			if (exportAction === "yes") {
+			if (exportAction === 0) {
 				const exportPath = join(process.cwd(), `${dbName}-backup.sql`);
 				output.start(`Exporting database to ${exportPath}...`);
 				try {
@@ -176,15 +203,10 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 				} catch (err) {
 					output.stop();
 					error(`Failed to export database: ${err instanceof Error ? err.message : String(err)}`);
-					console.error("  Esc to skip\n");
-					const continueAction = await select({
-						message: "Continue without exporting?",
-						choices: [
-							{ name: "1. Yes", value: "yes" },
-							{ name: "2. No", value: "no" },
-						],
-					});
-					if (continueAction === "no") {
+					console.error("");
+					info("Continue without exporting?");
+					const continueAction = await promptSelect(["Yes", "No"]);
+					if (continueAction !== 0) {
 						info("Cancelled");
 						return;
 					}
@@ -192,31 +214,20 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			}
 
 			// Ask if they want to delete the database
-			console.error("  Esc to skip\n");
-			const deleteAction = await select({
-				message: `Delete database '${dbName}'?`,
-				choices: [
-					{ name: "1. Yes", value: "yes" },
-					{ name: "2. No", value: "no" },
-				],
-			});
+			console.error("");
+			info(`Delete database '${dbName}'?`);
+			const deleteAction = await promptSelect(["Yes", "No"]);
 
-			shouldDeleteDb = deleteAction === "yes";
+			shouldDeleteDb = deleteAction === 0;
 		}
 
-		// Handle R2 backup deletion
+		// Handle backup deletion
 		let shouldDeleteR2 = false;
 		if (project) {
 			console.error("");
-			console.error("  Esc to skip\n");
-			const deleteR2Action = await select({
-				message: "Delete cloud backup for this project?",
-				choices: [
-					{ name: "1. Yes", value: "yes" },
-					{ name: "2. No", value: "no" },
-				],
-			});
-			shouldDeleteR2 = deleteR2Action === "yes";
+			info("Delete backup for this project?");
+			const deleteR2Action = await promptSelect(["Yes", "No"]);
+			shouldDeleteR2 = deleteR2Action === 0;
 		}
 
 		// Execute deletions
@@ -243,9 +254,6 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 				await deleteDatabase(dbName);
 				output.stop();
 				success(`Database '${dbName}' deleted`);
-
-				// Update registry
-				await updateProjectDatabase(name, null);
 			} catch (err) {
 				output.stop();
 				warn(
@@ -254,20 +262,20 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			}
 		}
 
-		// Delete cloud backup if requested
+		// Delete backup if requested
 		if (shouldDeleteR2) {
-			output.start("Deleting cloud backup...");
+			output.start("Deleting backup...");
 			try {
 				const deleted = await deleteCloudProject(name);
 				output.stop();
 				if (deleted) {
-					success("Cloud backup deleted");
+					success("Backup deleted");
 				} else {
-					warn("No cloud backup found or already deleted");
+					warn("No backup found or already deleted");
 				}
 			} catch (err) {
 				output.stop();
-				warn(`Failed to delete cloud backup: ${err instanceof Error ? err.message : String(err)}`);
+				warn(`Failed to delete backup: ${err instanceof Error ? err.message : String(err)}`);
 			}
 		}
 

package/src/commands/feedback.ts

@@ -0,0 +1,189 @@
+/**
+ * jack feedback - Submit feedback to the jack team
+ *
+ * Works without login. Auto-collects metadata.
+ * Free-form text input, no categories.
+ */
+
+import pkg from "../../package.json";
+import { getCredentials } from "../lib/auth/store.ts";
+import { getControlApiUrl } from "../lib/control-plane.ts";
+import { error, info, output, success } from "../lib/output.ts";
+import { getProject } from "../lib/registry.ts";
+import { getProjectNameFromDir } from "../lib/storage/index.ts";
+import { getTelemetryConfig } from "../lib/telemetry.ts";
+
+interface FeedbackMetadata {
+	jack_version: string;
+	os: string;
+	project_name: string | null;
+	deploy_mode: "managed" | "byo" | null;
+}
+
+/**
+ * Check if user has allowed telemetry (respects privacy preferences)
+ */
+async function shouldAttachPersonalInfo(): Promise<boolean> {
+	if (process.env.DO_NOT_TRACK === "1") return false;
+	if (process.env.CI === "true") return false;
+	if (process.env.JACK_TELEMETRY_DISABLED === "1") return false;
+
+	try {
+		const config = await getTelemetryConfig();
+		return config.enabled;
+	} catch {
+		return true;
+	}
+}
+
+export default async function feedback(): Promise<void> {
+	// Check for interactive terminal
+	if (!process.stdin.isTTY) {
+		error("Feedback requires interactive input.");
+		info("Run in a terminal, or open an issue at github.com/getjack-org/jack");
+		process.exit(1);
+	}
+
+	// Show prompt
+	console.error("");
+	info("Share feedback, report a bug, or suggest a feature.");
+	info("Press Enter on an empty line to submit. Escape to cancel.");
+	console.error("");
+
+	// Read multi-line input
+	const message = await readMultilineInput();
+
+	if (!message.trim()) {
+		info("No feedback provided.");
+		return;
+	}
+
+	// Check privacy preferences
+	const attachPersonalInfo = await shouldAttachPersonalInfo();
+
+	// Collect metadata (respects privacy settings)
+	const metadata = await collectMetadata(attachPersonalInfo);
+
+	// Get email if logged in AND telemetry is enabled
+	let email: string | null = null;
+	if (attachPersonalInfo) {
+		const creds = await getCredentials();
+		email = creds?.user?.email ?? null;
+	}
+
+	// Submit
+	output.start("Sending feedback...");
+
+	try {
+		const response = await fetch(`${getControlApiUrl()}/v1/feedback`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				message: message.trim(),
+				email,
+				metadata,
+			}),
+		});
+
+		output.stop();
+
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status}`);
+		}
+
+		success("Done! Thanks for your feedback.");
+	} catch (err) {
+		output.stop();
+
+		// Network errors
+		if (err instanceof TypeError && err.message.includes("fetch")) {
+			error("Could not reach jack servers.");
+			info("Check your internet connection and try again.");
+		} else {
+			error("Failed to submit feedback.");
+			info("Try again later, or open an issue at github.com/getjack-org/jack");
+		}
+		process.exit(1);
+	}
+}
+
+async function readMultilineInput(): Promise<string> {
+	const lines: string[] = [];
+	const rl = await import("node:readline");
+
+	// Enable keypress events on stdin
+	rl.emitKeypressEvents(process.stdin);
+
+	const readline = rl.createInterface({
+		input: process.stdin,
+		output: process.stderr,
+		prompt: "> ",
+	});
+
+	return new Promise((resolve) => {
+		let emptyLineCount = 0;
+		let cancelled = false;
+
+		// Listen for Escape key
+		const onKeypress = (_ch: string, key: { name: string; ctrl?: boolean }) => {
+			if (key?.name === "escape") {
+				cancelled = true;
+				readline.close();
+			}
+		};
+		process.stdin.on("keypress", onKeypress);
+
+		readline.prompt();
+
+		readline.on("line", (line) => {
+			if (line === "") {
+				emptyLineCount++;
+				if (emptyLineCount >= 1 && lines.length > 0) {
+					// Empty line after content = submit
+					readline.close();
+					return;
+				}
+			} else {
+				emptyLineCount = 0;
+				lines.push(line);
+			}
+			readline.prompt();
+		});
+
+		readline.on("close", () => {
+			process.stdin.removeListener("keypress", onKeypress);
+			resolve(cancelled ? "" : lines.join("\n"));
+		});
+
+		// Handle Ctrl+C gracefully
+		readline.on("SIGINT", () => {
+			cancelled = true;
+			readline.close();
+		});
+	});
+}
+
+async function collectMetadata(attachPersonalInfo: boolean): Promise<FeedbackMetadata> {
+	let projectName: string | null = null;
+	let deployMode: "managed" | "byo" | null = null;
+
+	// Only collect project info if telemetry is enabled
+	if (attachPersonalInfo) {
+		try {
+			projectName = await getProjectNameFromDir(process.cwd());
+			if (projectName) {
+				const project = await getProject(projectName);
+				deployMode = project?.deploy_mode ?? null;
+			}
+		} catch {
+			// Not in a project directory, that's fine
+		}
+	}
+
+	return {
+		jack_version: pkg.version,
+		os: process.platform,
+		project_name: projectName,
+		deploy_mode: deployMode,
+	};
+}

package/src/commands/init.ts

@@ -5,11 +5,7 @@ import {
 	updateAgent,
 } from "../lib/agents.ts";
 import { readConfig, writeConfig } from "../lib/config.ts";
-import {
-	getIdeDisplayName,
-	installMcpConfigsToAllIdes,
-	saveMcpConfig,
-} from "../lib/mcp-config.ts";
+import { getAppDisplayName, installMcpConfigsToAllApps, saveMcpConfig } from "../lib/mcp-config.ts";
 import { info, item, spinner, success } from "../lib/output.ts";
 import { ensureAuth, ensureWrangler, isAuthenticated } from "../lib/wrangler.ts";
 
@@ -79,20 +75,20 @@ export default async function init(options: InitOptions = {}): Promise<void> {
 		info("No agents detected (you can add them later with: jack agents add)");
 	}
 
-	// Step 4: Install MCP configs to detected IDEs (unless --skip-mcp)
+	// Step 4: Install MCP configs to detected apps (unless --skip-mcp)
 	if (!options.skipMcp) {
 		const mcpSpinner = spinner("Installing MCP server configs...");
 		try {
-			const installedIdes = await installMcpConfigsToAllIdes();
+			const installedApps = await installMcpConfigsToAllApps();
 			mcpSpinner.stop();
 
-			if (installedIdes.length > 0) {
-				success(`MCP server installed to ${installedIdes.length} IDE(s)`);
-				for (const ideId of installedIdes) {
-					item(`  ${getIdeDisplayName(ideId)}`);
+			if (installedApps.length > 0) {
+				success(`MCP server installed to ${installedApps.length} app(s)`);
+				for (const appId of installedApps) {
+					item(`  ${getAppDisplayName(appId)}`);
 				}
 			} else {
-				info("No supported IDEs detected for MCP installation");
+				info("No supported apps detected for MCP installation");
 			}
 		} catch (err) {
 			mcpSpinner.stop();

package/src/commands/login.ts

@@ -0,0 +1,88 @@
+import { type DeviceAuthResponse, pollDeviceToken, startDeviceAuth } from "../lib/auth/client.ts";
+import { type AuthCredentials, saveCredentials } from "../lib/auth/store.ts";
+import { error, info, spinner, success } from "../lib/output.ts";
+
+interface LoginOptions {
+	/** Skip the initial "Logging in..." message (used when called from auto-login) */
+	silent?: boolean;
+}
+
+export default async function login(options: LoginOptions = {}): Promise<void> {
+	if (!options.silent) {
+		info("Logging in to jack cloud...");
+		console.error("");
+	}
+
+	const spin = spinner("Starting login...");
+	let deviceAuth: DeviceAuthResponse;
+
+	try {
+		deviceAuth = await startDeviceAuth();
+		spin.stop();
+	} catch (err) {
+		spin.stop();
+		error(err instanceof Error ? err.message : "Failed to start login");
+		process.exit(1);
+	}
+
+	console.error("");
+	console.error("  ┌────────────────────────────────────┐");
+	console.error("  │                                    │");
+	console.error(`  │    Your code:  ${deviceAuth.user_code.padEnd(12)}      │`);
+	console.error("  │                                    │");
+	console.error("  └────────────────────────────────────┘");
+	console.error("");
+	info(`Opening ${deviceAuth.verification_uri} in your browser...`);
+	console.error("");
+
+	// Open browser - use Bun.spawn for cross-platform
+	try {
+		const platform = process.platform;
+		const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+		Bun.spawn([cmd, deviceAuth.verification_uri_complete]);
+	} catch {
+		info(`If the browser didn't open, go to: ${deviceAuth.verification_uri_complete}`);
+	}
+
+	const pollSpin = spinner("Waiting for you to complete login in browser...");
+	const interval = (deviceAuth.interval || 5) * 1000;
+	const expiresAt = Date.now() + deviceAuth.expires_in * 1000;
+
+	while (Date.now() < expiresAt) {
+		await sleep(interval);
+
+		try {
+			const tokens = await pollDeviceToken(deviceAuth.device_code);
+
+			if (tokens) {
+				pollSpin.stop();
+
+				// Default to 5 minutes if expires_in not provided
+				const expiresIn = tokens.expires_in ?? 300;
+				const creds: AuthCredentials = {
+					access_token: tokens.access_token,
+					refresh_token: tokens.refresh_token,
+					expires_at: Math.floor(Date.now() / 1000) + expiresIn,
+					user: tokens.user,
+				};
+				await saveCredentials(creds);
+
+				console.error("");
+				success(`Logged in as ${tokens.user.email}`);
+				return;
+			}
+		} catch (err) {
+			pollSpin.stop();
+			error(err instanceof Error ? err.message : "Login failed");
+			process.exit(1);
+		}
+	}
+
+	pollSpin.stop();
+	error("Login timed out. Please try again.");
+	process.exit(1);
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/commands/logout.ts

@@ -0,0 +1,14 @@
+import { deleteCredentials, getCredentials } from "../lib/auth/store.ts";
+import { info, success } from "../lib/output.ts";
+
+export default async function logout(): Promise<void> {
+	const creds = await getCredentials();
+
+	if (!creds) {
+		info("Not logged in");
+		return;
+	}
+
+	await deleteCredentials();
+	success("Logged out");
+}

package/src/commands/logs.ts

@@ -1,5 +1,7 @@
 import { existsSync } from "node:fs";
 import { output } from "../lib/output.ts";
+import { getProject } from "../lib/registry.ts";
+import { getProjectNameFromDir } from "../lib/storage/index.ts";
 
 // Lines containing these strings will be filtered out
 const FILTERED_PATTERNS = ["⛅️ wrangler"];
@@ -17,6 +19,25 @@ export default async function logs(): Promise<void> {
 		process.exit(1);
 	}
 
+	// Check if this is a managed project
+	let projectName: string | null = null;
+	try {
+		projectName = await getProjectNameFromDir(process.cwd());
+	} catch {
+		// Continue without project name - will fall through to wrangler tail
+	}
+
+	if (projectName) {
+		const project = await getProject(projectName);
+		if (project?.deploy_mode === "managed") {
+			output.warn("Real-time logs not yet available for managed projects");
+			output.info("Logs are being collected - web UI coming soon");
+			output.info("Track progress: https://github.com/getjack-org/jack/issues/2");
+			return;
+		}
+	}
+
+	// BYOC project - use wrangler tail
 	output.info("Streaming logs from Cloudflare Worker...");
 	output.info("Press Ctrl+C to stop\n");