@getjack/jack 0.1.28 → 0.1.30

package/src/commands/down.ts

@@ -1,3 +1,4 @@
+import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { getAuthState } from "../lib/auth/index.ts";
 import {
@@ -6,6 +7,7 @@ import {
 	deleteWorker,
 	exportDatabase,
 } from "../lib/cloudflare-api.ts";
+import { getJackHome } from "../lib/config.ts";
 import { fetchProjectResources } from "../lib/control-plane.ts";
 import { promptSelect } from "../lib/hooks.ts";
 import { managedDown } from "../lib/managed-down.ts";
@@ -88,7 +90,7 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 		// Check if found only on control plane (orphaned managed project)
 		if (resolved?.sources.controlPlane && !resolved.sources.filesystem) {
 			console.error("");
-			info(`Found "${name}" on jack cloud, linking locally...`);
+			info(`Found "${name}" on jack cloud`);
 		}
 
 		// Guard against mismatched resolutions when an explicit name is provided
@@ -115,6 +117,7 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			// Get the project ID from link or resolved data
 			const projectId = link?.project_id || resolved?.remote?.projectId;
 			const runjackUrl = resolved?.url || null;
+			const localPath = resolved?.localPath || null;
 
 			if (!projectId) {
 				error("Cannot determine project ID for managed deletion");
@@ -122,18 +125,19 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			}
 
 			// Route to managed deletion flow
-			const deleteSuccess = await managedDown({ projectId, runjackUrl }, name, flags);
+			const deleteSuccess = await managedDown({ projectId, runjackUrl, localPath }, name, flags);
 			if (!deleteSuccess) {
 				process.exit(0); // User cancelled
 			}
 
-			// Clean up local tracking state
-			const localPath = resolved?.localPath || process.cwd();
-			try {
-				await unlinkProject(localPath);
-				await unregisterPath(projectId, localPath);
-			} catch {
-				// Non-fatal: local cleanup failed but cloud deletion succeeded
+			// Clean up local tracking state (only if project has local path)
+			if (resolved?.localPath) {
+				try {
+					await unlinkProject(resolved.localPath);
+					await unregisterPath(projectId, resolved.localPath);
+				} catch {
+					// Non-fatal: local cleanup failed but cloud deletion succeeded
+				}
 			}
 			return;
 		}
@@ -203,8 +207,10 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 		// Auto-export database if it exists (no prompt)
 		let exportPath: string | null = null;
 		if (dbName) {
-			exportPath = join(process.cwd(), `${dbName}-backup.sql`);
-			output.start(`Exporting database to ${exportPath}...`);
+			const backupDir = resolved?.localPath ?? join(getJackHome(), name);
+			mkdirSync(backupDir, { recursive: true });
+			exportPath = join(backupDir, `${dbName}-backup.sql`);
+			output.start("Exporting database...");
 			try {
 				await exportDatabase(dbName, exportPath);
 				output.stop();
@@ -267,7 +273,7 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 		console.error("");
 		success(`Undeployed '${name}'`);
 		if (exportPath) {
-			info(`Backup saved to ./${dbName}-backup.sql`);
+			info(`Database backup: ${exportPath}`);
 		}
 		console.error("");
 	} catch (err) {

package/src/commands/hack.ts

@@ -1,18 +1,195 @@
+const reset = "\x1b[0m";
+const bright = "\x1b[1m";
+const dim = "\x1b[2m";
+const cyan = "\x1b[38;2;0;255;255m";
+const dimCyan = "\x1b[38;2;0;180;180m";
+const green = "\x1b[38;2;0;200;0m";
+
+const matrixChars = "░▒▓█▀▄■□◆◇●◐◑◒◓ｦｱｳｴｵｶｷｸｹｺ";
+
+function randomChar(): string {
+	return matrixChars[Math.floor(Math.random() * matrixChars.length)];
+}
+
+async function sleep(ms: number) {
+	await new Promise((r) => setTimeout(r, ms));
+}
+
+async function type(text: string, delay = 30) {
+	for (const char of text) {
+		process.stdout.write(char);
+		await sleep(delay);
+	}
+}
+
+async function typeLine(text: string, delay = 30) {
+	await type(text, delay);
+	console.log();
+}
+
+async function matrixDecode(text: string, indent = "") {
+	const frames = 30;
+	const delay = 50;
+	const len = text.length;
+
+	for (let frame = 0; frame <= frames; frame++) {
+		const resolvedCount = Math.floor((frame / frames) * len);
+		let line = indent;
+
+		for (let i = 0; i < len; i++) {
+			if (i < resolvedCount) {
+				line += `${bright}${cyan}${text[i]}${reset}`;
+			} else {
+				line += `${dimCyan}${randomChar()}${reset}`;
+			}
+		}
+
+		process.stdout.write(`\x1b[2K\r${line}`);
+		await sleep(delay);
+	}
+
+	process.stdout.write(`\x1b[2K\r${indent}${bright}${cyan}${text}${reset}\n`);
+}
+
+async function bootSequence() {
+	const modulePool = [
+		"consciousness.ko",
+		"cyberspace.ko",
+		"deploy.ko",
+		"neural.ko",
+		"ice-breaker.ko",
+		"daemon.ko",
+		"matrix.ko",
+		"decrypt.ko",
+		"intrusion.ko",
+		"phantom.ko",
+	];
+	const modules = pickRandom(modulePool, 3);
+
+	console.log();
+	console.log(`${dim}JACK OS v1.0${reset}`);
+	console.log(`${dim}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${reset}`);
+	await sleep(300);
+
+	await typeLine(`${green}Initializing...${reset}`, 20);
+	for (const mod of modules) {
+		await type(`  ${dim}├─${reset} ${mod}`, 15);
+		await sleep(100 + Math.random() * 200);
+		console.log(`  ${green}[OK]${reset}`);
+	}
+	await sleep(200);
+}
+
+function pickRandom<T>(arr: T[], count: number): T[] {
+	const shuffled = [...arr].sort(() => Math.random() - 0.5);
+	return shuffled.slice(0, count);
+}
+
+async function traceRoute() {
+	const username = process.env.USER || process.env.USERNAME || "user";
+
+	const serverPool = [
+		"node.chiba.city",
+		"relay.freeside.orbital",
+		"proxy.night.city",
+		"vault.zaibatsu.corp",
+		"node.sprawl.net",
+		"relay.tessier-ashpool.ice",
+		"cache.construct.sim",
+		"gate.zion.cluster",
+		"hub.screaming.fist",
+		"core.wintermute.ai",
+		"edge.straylight.run",
+		"sync.maelstrom.net",
+	];
+
+	const midHops = pickRandom(serverPool, 3);
+	const hops = [
+		["localhost", "0.1"],
+		[`${username}.meat.space`, String(10 + Math.floor(Math.random() * 20))],
+		[midHops[0], String(50 + Math.floor(Math.random() * 50))],
+		[midHops[1], String(100 + Math.floor(Math.random() * 100))],
+		[midHops[2], "███"],
+	];
+
+	console.log();
+	await typeLine(`${green}Tracing route...${reset}`, 20);
+
+	for (let i = 0; i < hops.length; i++) {
+		const [host, ms] = hops[i];
+		await type(`  ${dim}${i + 1}${reset}  ${host}`, 10);
+		await sleep(150 + Math.random() * 300);
+		console.log(`  ${dimCyan}${ms}ms${reset}`);
+	}
+	await sleep(200);
+}
+
+async function sshConnect(target: string) {
+	console.log();
+	await typeLine(`${green}Connecting to ${target}:22...${reset}`, 15);
+	await sleep(300);
+	await type(`${dim}RSA fingerprint: ${reset}${dimCyan}`);
+	for (let i = 0; i < 12; i++) {
+		process.stdout.write(randomChar());
+		await sleep(30);
+	}
+	console.log(`${reset}`);
+	await sleep(400);
+	console.log(`${bright}${green}ACCESS GRANTED${reset}`);
+	await sleep(500);
+}
+
 export default async function hack(): Promise<void> {
 	const quotes = [
+		// Sneakers (1992)
+		"The world isn't run by weapons anymore. It's run by ones and zeroes.",
+		"No more secrets.",
 		// Gibson - Neuromancer
 		"The sky above the port was the color of television, tuned to a dead channel.",
 		"Cyberspace. A consensual hallucination.",
 		// Gibson - various
 		"The future is already here — it's just not evenly distributed.",
-		"The street finds its own uses for things.",
-		// Sterling
-		"Anything that can be done to a rat can be done to a human being.",
-		// Stephenson - Snow Crash
-		"The Metaverse. It's a fictional structure made out of code.",
-		// Generic cyberpunk vibes
-		"We are all cyborgs now.",
+		// Cyberpunk 2077 - Johnny Silverhand
+		"Wake the fuck up, Samurai. We have a city to burn.",
+		// Hackers (1995)
+		"Mess with the best, die like the rest.",
+		"Hack the planet!",
+		// Hacker wisdom
+		"Playfully doing something difficult, whether useful or not, that is hacking.",
+		"There's nothing more permanent than a temporary hack.",
+		// jack philosophy - from SPIRIT.md
+		"Context-switching to dashboards is violence.",
+		"GUIs are for browsing. CLIs are for flow.",
+		"The best infrastructure is invisible.",
+		"Every friction point is a creative thought lost.",
+		"Create and ship before your first commit.",
+		"Don't punish exploration. Creation is free.",
 	];
 	const quote = quotes[Math.floor(Math.random() * quotes.length)];
-	console.error(`\n  "${quote}"\n`);
+
+	const serverPool = [
+		"node.chiba.city",
+		"relay.freeside.orbital",
+		"proxy.night.city",
+		"vault.zaibatsu.corp",
+		"node.sprawl.net",
+		"relay.tessier-ashpool.ice",
+		"cache.construct.sim",
+		"gate.zion.cluster",
+		"hub.screaming.fist",
+		"core.wintermute.ai",
+		"edge.straylight.run",
+		"sync.maelstrom.net",
+	];
+	const target = serverPool[Math.floor(Math.random() * serverPool.length)];
+
+	await bootSequence();
+	await traceRoute();
+	await sshConnect(target);
+
+	console.log();
+	console.log(`${dim}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${reset}`);
+	console.log();
+	await matrixDecode(`"${quote}"`);
+	console.log();
 }

package/src/commands/init.ts

@@ -5,8 +5,19 @@ import {
 	updateAgent,
 } from "../lib/agents.ts";
 import { readConfig, writeConfig } from "../lib/config.ts";
+import { promptSelect } from "../lib/hooks.ts";
 import { getAppDisplayName, installMcpConfigsToAllApps, saveMcpConfig } from "../lib/mcp-config.ts";
 import { info, item, spinner, success } from "../lib/output.ts";
+import {
+	detectShell,
+	getRcFileName,
+	getRcFilePath,
+	getShellFileDisplayPath,
+	getShellName,
+	hasLegacyInstall,
+	install as installShellIntegration,
+	isInstalled as isShellIntegrationInstalled,
+} from "../lib/shell-integration.ts";
 import { ensureAuth, ensureWrangler, isAuthenticated } from "../lib/wrangler.ts";
 
 export async function isInitialized(): Promise<boolean> {
@@ -122,7 +133,47 @@ export default async function init(options: InitOptions = {}): Promise<void> {
 		}
 	}
 
-	// Step 5: Save config (preserve existing agents, just update init status)
+	// Step 5: Shell integration
+	const shell = detectShell();
+	const rcFile = getRcFilePath(shell);
+
+	if (rcFile && shell !== "unknown") {
+		const alreadyInstalled = isShellIntegrationInstalled(rcFile);
+		const hasLegacy = hasLegacyInstall(rcFile);
+
+		if (alreadyInstalled && !hasLegacy) {
+			// Already installed
+		} else if (hasLegacy) {
+			console.error("");
+			info("Upgrading shell integration...");
+			try {
+				const result = installShellIntegration(rcFile);
+				if (result.migrated) {
+					success(`Upgraded to ${getShellFileDisplayPath()}`);
+					info(`Restart your terminal or run: source ~/${getRcFileName(rcFile)}`);
+				}
+			} catch {
+				info("Could not upgrade shell integration (non-critical)");
+			}
+		} else {
+			console.error("");
+			info("Enable 'jack cd' and 'jack new' to auto-change directories?");
+			const choice = await promptSelect(["Yes", "No"]);
+
+			if (choice === 0) {
+				try {
+					installShellIntegration(rcFile);
+					success(`Added to ~/${getRcFileName(rcFile)}`);
+					info(`Restart your terminal or run: source ~/${getRcFileName(rcFile)}`);
+				} catch {
+					info("Could not update shell config (non-critical)");
+					info('Add manually: eval "$(jack shell-init)"');
+				}
+			}
+		}
+	}
+
+	// Step 6: Save config (preserve existing agents, just update init status)
 	const existingConfig = await readConfig();
 	await writeConfig({
 		version: 1,

package/src/commands/link.ts

@@ -9,14 +9,10 @@
 
 import { existsSync } from "node:fs";
 import { isLoggedIn } from "../lib/auth/index.ts";
-import { isCancel, promptSelectValue } from "../lib/hooks.ts";
-import {
-	type ManagedProject,
-	findProjectBySlug,
-	listManagedProjects,
-} from "../lib/control-plane.ts";
+import { findProjectById, findProjectBySlug } from "../lib/control-plane.ts";
 import { error, info, output, success } from "../lib/output.ts";
 import { registerPath } from "../lib/paths-index.ts";
+import { pickProject, requireTTY } from "../lib/picker.ts";
 import { generateByoProjectId, linkProject, readProjectLink } from "../lib/project-link.ts";
 
 export interface LinkFlags {
@@ -27,8 +23,17 @@ export default async function link(projectName?: string, flags: LinkFlags = {}):
 	// Check if already linked
 	const existingLink = await readProjectLink(process.cwd());
 	if (existingLink) {
+		// Try to look up project name for better UX
+		let projectDisplay = existingLink.project_id;
+		if (existingLink.deploy_mode === "managed") {
+			const project = await findProjectById(existingLink.project_id);
+			if (project) {
+				projectDisplay = project.slug;
+			}
+		}
+
 		error("This directory is already linked");
-		info(`Project ID: ${existingLink.project_id}`);
+		info(`Linked to: ${projectDisplay}`);
 		info("To re-link, first run: jack unlink");
 		process.exit(1);
 	}
@@ -105,51 +110,28 @@ export default async function link(projectName?: string, flags: LinkFlags = {}):
 		return;
 	}
 
-	// Interactive mode - list and select project
-	output.start("Loading projects...");
-	let projects: ManagedProject[] = [];
-	try {
-		projects = await listManagedProjects();
-	} catch (err) {
-		output.stop();
-		error("Failed to load projects");
-		if (err instanceof Error) {
-			info(err.message);
-		}
-		process.exit(1);
-	}
-	output.stop();
-
-	if (projects.length === 0) {
-		error("No projects found");
-		info("Create one with: jack new");
-		info("Or link to your Cloudflare account: jack link --byo");
-		process.exit(1);
-	}
+	// Interactive mode - use fuzzy picker with cloud-only projects
+	requireTTY();
 
-	console.error("");
-	const choice = await promptSelectValue(
-		"Select a project to link:",
-		projects.map((p) => ({
-			value: p.id,
-			label: `${p.slug} (${p.status})`,
-		})),
-	);
+	const result = await pickProject({ cloudOnly: true });
 
-	if (isCancel(choice)) {
+	if (result.action === "cancel") {
 		info("Cancelled");
 		process.exit(0);
 	}
 
-	const selected = projects.find((p) => p.id === choice);
-	if (!selected) {
-		error("No project selected");
+	const selected = result.project;
+
+	// Need project ID - fetch from control plane by slug
+	const project = await findProjectBySlug(selected.name);
+	if (!project) {
+		error(`Could not find project: ${selected.name}`);
 		process.exit(1);
 	}
 
 	output.start("Linking project...");
-	await linkProject(process.cwd(), selected.id, "managed");
-	await registerPath(selected.id, process.cwd());
+	await linkProject(process.cwd(), project.id, "managed");
+	await registerPath(project.id, process.cwd());
 	output.stop();
-	success(`Linked to: ${selected.slug}`);
+	success(`Linked to: ${selected.name}`);
 }

package/src/commands/logs.ts

@@ -1,8 +1,8 @@
 import { existsSync } from "node:fs";
-import { output } from "../lib/output.ts";
-import { getDeployMode, getProjectId } from "../lib/project-link.ts";
 import { authFetch } from "../lib/auth/index.ts";
 import { getControlApiUrl, startLogSession } from "../lib/control-plane.ts";
+import { output } from "../lib/output.ts";
+import { getDeployMode, getProjectId } from "../lib/project-link.ts";
 
 // Lines containing these strings will be filtered out
 const FILTERED_PATTERNS = ["⛅️ wrangler"];

package/src/commands/mcp.ts

@@ -1,9 +1,15 @@
 import { spawn } from "node:child_process";
-import { rm, mkdtemp } from "node:fs/promises";
+import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { error, info, success } from "../lib/output.ts";
+import {
+	APP_MCP_CONFIGS,
+	getAppDisplayName,
+	installMcpConfigToApp,
+	isAppInstalled,
+} from "../lib/mcp-config.ts";
+import { error, info, item, success } from "../lib/output.ts";
 import { startMcpServer } from "../mcp/server.ts";
 
 const cliRoot = fileURLToPath(new URL("../..", import.meta.url));
@@ -27,13 +33,78 @@ export default async function mcp(subcommand?: string, options: McpOptions = {})
 		return;
 	}
 
-	error("Unknown subcommand. Use: jack mcp serve or jack mcp test");
+	if (subcommand === "install") {
+		await installMcpConfig();
+		return;
+	}
+
+	error("Unknown subcommand. Use: jack mcp serve, jack mcp install, or jack mcp test");
 	info("Usage:");
 	info("  jack mcp serve [--project /path] [--debug]  Start MCP server");
+	info("  jack mcp install                            Install/repair MCP config for AI agents");
 	info("  jack mcp test                               Test MCP server connectivity");
 	process.exit(1);
 }
 
+/**
+ * Install or repair MCP configuration for all detected apps
+ */
+async function installMcpConfig(): Promise<void> {
+	info("Installing jack MCP server configuration...\n");
+
+	const installed: string[] = [];
+	const skipped: string[] = [];
+	const failed: string[] = [];
+
+	for (const appId of Object.keys(APP_MCP_CONFIGS)) {
+		const displayName = getAppDisplayName(appId);
+
+		if (!isAppInstalled(appId)) {
+			skipped.push(displayName);
+			continue;
+		}
+
+		try {
+			const result = await installMcpConfigToApp(appId);
+			if (result) {
+				installed.push(displayName);
+			} else {
+				failed.push(displayName);
+			}
+		} catch {
+			failed.push(displayName);
+		}
+	}
+
+	// Report results
+	if (installed.length > 0) {
+		success(`Installed to ${installed.length} app(s):`);
+		for (const app of installed) {
+			item(`  ${app}`);
+		}
+	}
+
+	if (skipped.length > 0) {
+		info(`\nSkipped (not installed):`);
+		for (const app of skipped) {
+			item(`  ${app}`);
+		}
+	}
+
+	if (failed.length > 0) {
+		error(`\nFailed to install:`);
+		for (const app of failed) {
+			item(`  ${app}`);
+		}
+	}
+
+	if (installed.length > 0) {
+		info("\nRestart your AI agent (Claude Code, Claude Desktop) to use jack MCP tools.");
+	} else if (failed.length === 0 && skipped.length > 0) {
+		info("\nNo supported AI agents detected. Install Claude Code or Claude Desktop first.");
+	}
+}
+
 /**
  * Test MCP server by spawning it and sending test requests
  */