@getjack/jack 0.1.7 → 0.1.9

package/src/lib/hooks.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { HookAction } from "../templates/types";
+import { applyJsonWrite } from "./json-edit";
 import { getSavedSecrets } from "./secrets";
 import { restoreTty } from "./tty";
 
@@ -17,6 +18,7 @@ export interface HookOutput {
 	error(message: string): void;
 	success(message: string): void;
 	box(title: string, lines: string[]): void;
+	celebrate?(title: string, lines: string[]): void;
 }
 
 export interface HookOptions {
@@ -32,6 +34,20 @@ const noopOutput: HookOutput = {
 	box() {},
 };
 
+/**
+ * Hook schema quick reference (interactive behavior + fields)
+ *
+ * - message: { text } -> prints info
+ * - box: { title, lines } -> prints boxed text
+ * - url: { url, label?, open?, prompt? } -> prints link; optional open prompt
+ * - clipboard: { text, message? } -> copy to clipboard (prints in non-interactive)
+ * - pause: { message? } -> waits for enter (skipped in non-interactive)
+ * - require: { source, key, message?, setupUrl? } -> validates secret/env
+ * - shell: { command, cwd?, message? } -> runs shell command
+ * - prompt: { message, validate?, required?, successMessage?, writeJson? } -> input + optional JSON update
+ * - writeJson: { path, set, successMessage? } -> JSON update (runs in non-interactive)
+ */
+
 /**
  * Prompt user with numbered options (Claude Code style)
  * Returns the selected option index (0-based) or -1 if cancelled
@@ -121,6 +137,26 @@ function substituteVars(str: string, context: HookContext): string {
 		.replace(/\{\{name\}\}/g, context.projectName ?? "");
 }
 
+function resolveHookPath(filePath: string, context: HookContext): string {
+	if (filePath.startsWith("/")) {
+		return filePath;
+	}
+	if (!context.projectDir) {
+		return filePath;
+	}
+	return join(context.projectDir, filePath);
+}
+
+function isAccountAssociation(value: unknown): value is { header: string; payload: string; signature: string } {
+	if (!value || typeof value !== "object") return false;
+	const obj = value as { header?: unknown; payload?: unknown; signature?: unknown };
+	return (
+		typeof obj.header === "string" &&
+		typeof obj.payload === "string" &&
+		typeof obj.signature === "string"
+	);
+}
+
 /**
  * Open a URL in the default browser
  */
@@ -209,153 +245,255 @@ async function checkEnvExists(env: string, projectDir?: string): Promise<boolean
  * Execute a single hook action
  * Returns true if should continue, false if should abort
  */
-async function executeAction(
-	action: HookAction,
+type ActionHandler<T extends HookAction["action"]> = (
+	action: Extract<HookAction, { action: T }>,
 	context: HookContext,
-	options?: HookOptions,
-): Promise<boolean> {
-	const interactive = options?.interactive !== false;
-	const ui = options?.output ?? noopOutput;
-
-	switch (action.action) {
-		case "message": {
-			ui.info(substituteVars(action.text, context));
+	options: HookOptions,
+) => Promise<boolean>;
+
+const actionHandlers: {
+	[T in HookAction["action"]]: ActionHandler<T>;
+} = {
+	message: async (action, context, options) => {
+		const ui = options.output ?? noopOutput;
+		ui.info(substituteVars(action.text, context));
+		return true;
+	},
+	box: async (action, context, options) => {
+		const ui = options.output ?? noopOutput;
+		const title = substituteVars(action.title, context);
+		const lines = action.lines.map((line) => substituteVars(line, context));
+		ui.box(title, lines);
+		return true;
+	},
+	url: async (action, context, options) => {
+		const ui = options.output ?? noopOutput;
+		const interactive = options.interactive !== false;
+		const url = substituteVars(action.url, context);
+		const label = action.label ?? "Link";
+		if (!interactive) {
+			ui.info(`${label}: ${url}`);
 			return true;
 		}
+		console.error("");
+		console.error(`  ${label}: \x1b[36m${url}\x1b[0m`);
 
-		case "box": {
-			const title = substituteVars(action.title, context);
-			const lines = action.lines.map((line) => substituteVars(line, context));
-			ui.box(title, lines);
+		if (action.open) {
+			ui.info(`Opening: ${url}`);
+			await openBrowser(url);
 			return true;
 		}
 
-		case "url": {
-			const url = substituteVars(action.url, context);
-			const label = action.label ?? "Link";
-			if (!interactive) {
-				ui.info(`${label}: ${url}`);
-				return true;
-			}
+		if (action.prompt !== false) {
 			console.error("");
-			console.error(`  ${label}: \x1b[36m${url}\x1b[0m`);
-
-			if (action.open) {
-				ui.info(`Opening: ${url}`);
+			const choice = await promptSelect(["Open in browser", "Skip"]);
+			if (choice === 0) {
 				await openBrowser(url);
-				return true;
-			}
-
-			if (action.prompt !== false) {
-				console.error("");
-				const choice = await promptSelect(["Open in browser", "Skip"]);
-				if (choice === 0) {
-					await openBrowser(url);
-					ui.success("Opened in browser");
-				}
+				ui.success("Opened in browser");
 			}
+		}
+		return true;
+	},
+	clipboard: async (action, context, options) => {
+		const ui = options.output ?? noopOutput;
+		const interactive = options.interactive !== false;
+		const text = substituteVars(action.text, context);
+		if (!interactive) {
+			ui.info(text);
 			return true;
 		}
+		const success = await copyToClipboard(text);
+		if (success) {
+			const message = action.message ?? "Copied to clipboard";
+			ui.success(message);
+		} else {
+			ui.warn("Could not copy to clipboard");
+		}
+		return true;
+	},
+	pause: async (action, _context, options) => {
+		const interactive = options.interactive !== false;
+		if (!interactive) {
+			return true;
+		}
+		await waitForEnter(action.message);
+		return true;
+	},
+	require: async (action, context, options) => {
+		const ui = options.output ?? noopOutput;
+		const interactive = options.interactive !== false;
+		if (action.source === "secret") {
+			const result = await checkSecretExists(action.key, context.projectDir);
+			if (!result.exists) {
+				const message = action.message ?? `Missing required secret: ${action.key}`;
+				ui.error(message);
+				ui.info(`Run: jack secrets add ${action.key}`);
 
-		case "require": {
-			if (action.source === "secret") {
-				const result = await checkSecretExists(action.key, context.projectDir);
-				if (!result.exists) {
-					const message = action.message ?? `Missing required secret: ${action.key}`;
-					ui.error(message);
-					ui.info(`Run: jack secrets add ${action.key}`);
-
-					if (action.setupUrl) {
-						if (interactive) {
-							console.error("");
-							const choice = await promptSelect(["Open setup page", "Skip"]);
-							if (choice === 0) {
-								await openBrowser(action.setupUrl);
-							}
-						} else {
-							ui.info(`Setup: ${action.setupUrl}`);
+				if (action.setupUrl) {
+					if (interactive) {
+						console.error("");
+						const choice = await promptSelect(["Open setup page", "Skip"]);
+						if (choice === 0) {
+							await openBrowser(action.setupUrl);
 						}
+					} else {
+						ui.info(`Setup: ${action.setupUrl}`);
 					}
-					return false;
-				}
-				return true;
-			}
-
-			const exists = await checkEnvExists(action.key, context.projectDir);
-			if (!exists) {
-				const message = action.message ?? `Missing required env var: ${action.key}`;
-				ui.error(message);
-				if (action.setupUrl) {
-					ui.info(`Setup: ${action.setupUrl}`);
 				}
 				return false;
 			}
 			return true;
 		}
 
-		case "clipboard": {
-			const text = substituteVars(action.text, context);
-			if (!interactive) {
-				ui.info(text);
-				return true;
-			}
-			const success = await copyToClipboard(text);
-			if (success) {
-				const message = action.message ?? "Copied to clipboard";
-				ui.success(message);
-			} else {
-				ui.warn("Could not copy to clipboard");
+		const exists = await checkEnvExists(action.key, context.projectDir);
+		if (!exists) {
+			const message = action.message ?? `Missing required env var: ${action.key}`;
+			ui.error(message);
+			if (action.setupUrl) {
+				ui.info(`Setup: ${action.setupUrl}`);
 			}
+			return false;
+		}
+		return true;
+	},
+	prompt: async (action, context, options) => {
+		const ui = options.output ?? noopOutput;
+		const interactive = options.interactive !== false;
+		if (!interactive) {
 			return true;
 		}
 
-		case "pause": {
-			if (!interactive) {
+		const { input } = await import("@inquirer/prompts");
+
+		let rawValue = "";
+		try {
+			rawValue = await input({ message: action.message });
+		} catch (err) {
+			if (err instanceof Error && err.name === "ExitPromptError") {
 				return true;
 			}
-			await waitForEnter(action.message);
+			throw err;
+		}
+
+		if (!rawValue.trim()) {
 			return true;
 		}
 
-		case "shell": {
-			const command = substituteVars(action.command, context);
-			if (action.message) {
-				ui.info(action.message);
+		let parsedInput: unknown = rawValue;
+		if (action.validate === "json" || action.validate === "accountAssociation") {
+			try {
+				parsedInput = JSON.parse(rawValue);
+			} catch {
+				ui.error("Invalid JSON input");
+				return action.required ? false : true;
+			}
+		}
+
+		if (action.validate === "accountAssociation" && !isAccountAssociation(parsedInput)) {
+			ui.error("Invalid accountAssociation JSON (expected header, payload, signature)");
+			return action.required ? false : true;
+		}
+
+		if (action.writeJson) {
+			const targetPath = resolveHookPath(action.writeJson.path, context);
+			const ok = await applyJsonWrite(
+				targetPath,
+				action.writeJson.set,
+				(value) => substituteVars(value, context),
+				parsedInput,
+			);
+			if (!ok) {
+				ui.error(`Invalid JSON file: ${targetPath}`);
+				return action.required ? false : true;
 			}
-			const cwd = action.cwd === "project" ? context.projectDir : undefined;
-			// Resume stdin in case previous prompts paused it
-			if (interactive) {
-				process.stdin.resume();
+			if (action.successMessage) {
+				ui.success(substituteVars(action.successMessage, context));
 			}
-			const proc = Bun.spawn(["sh", "-c", command], {
-				cwd,
-				stdin: interactive ? "inherit" : "ignore",
-				stdout: "inherit",
-				stderr: "inherit",
-			});
-			await proc.exited;
-			return proc.exitCode === 0;
 		}
 
-		default:
-			return true;
-	}
+		return true;
+	},
+	writeJson: async (action, context, options) => {
+		const ui = options.output ?? noopOutput;
+		const targetPath = resolveHookPath(action.path, context);
+		const ok = await applyJsonWrite(
+			targetPath,
+			action.set,
+			(value) => substituteVars(value, context),
+		);
+		if (!ok) {
+			ui.error(`Invalid JSON file: ${targetPath}`);
+			return false;
+		}
+		if (action.successMessage) {
+			ui.success(substituteVars(action.successMessage, context));
+		}
+		return true;
+	},
+	shell: async (action, context, options) => {
+		const ui = options.output ?? noopOutput;
+		const interactive = options.interactive !== false;
+		const command = substituteVars(action.command, context);
+		if (action.message) {
+			ui.info(action.message);
+		}
+		const cwd = action.cwd === "project" ? context.projectDir : undefined;
+		// Resume stdin in case previous prompts paused it
+		if (interactive) {
+			process.stdin.resume();
+		}
+		const proc = Bun.spawn(["sh", "-c", command], {
+			cwd,
+			stdin: interactive ? "inherit" : "ignore",
+			stdout: "inherit",
+			stderr: "inherit",
+		});
+		await proc.exited;
+		return proc.exitCode === 0;
+	},
+};
+
+async function executeAction(
+	action: HookAction,
+	context: HookContext,
+	options?: HookOptions,
+): Promise<boolean> {
+	const handler = actionHandlers[action.action] as (
+		action: HookAction,
+		context: HookContext,
+		options: HookOptions,
+	) => Promise<boolean>;
+	return handler(action, context, options ?? {});
+}
+
+export interface HookResult {
+	success: boolean;
+	hadInteractiveActions: boolean;
 }
 
 /**
  * Run a list of hook actions
- * Returns true if all succeeded, false if any failed (for preDeploy checks)
+ * Returns success status and whether any interactive actions were executed
  */
 export async function runHook(
 	actions: HookAction[],
 	context: HookContext,
 	options?: HookOptions,
-): Promise<boolean> {
+): Promise<HookResult> {
+	const interactive = options?.interactive !== false;
+	// Track if we had any interactive actions (prompt, pause) that ran
+	const interactiveActionTypes = ["prompt", "pause"];
+	let hadInteractiveActions = false;
+
 	for (const action of actions) {
+		// Check if this is an interactive action that will actually run
+		if (interactive && interactiveActionTypes.includes(action.action)) {
+			hadInteractiveActions = true;
+		}
 		const shouldContinue = await executeAction(action, context, options);
 		if (!shouldContinue) {
-			return false;
+			return { success: false, hadInteractiveActions };
 		}
 	}
-	return true;
+	return { success: true, hadInteractiveActions };
 }

package/src/lib/json-edit.ts

@@ -0,0 +1,56 @@
+import { existsSync } from "node:fs";
+
+export function setJsonPath(
+	target: Record<string, unknown>,
+	path: string,
+	value: unknown,
+): void {
+	const keys = path.split(".").filter(Boolean);
+	let current: Record<string, unknown> = target;
+
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		if (key === undefined) continue;
+		const next = current[key];
+		if (!next || typeof next !== "object" || Array.isArray(next)) {
+			current[key] = {};
+		}
+		current = current[key] as Record<string, unknown>;
+	}
+
+	const lastKey = keys[keys.length - 1];
+	if (lastKey) {
+		current[lastKey] = value;
+	}
+}
+
+export async function applyJsonWrite(
+	targetPath: string,
+	updates: Record<string, string | { from: "input" }>,
+	substitute: (value: string) => string,
+	inputValue?: unknown,
+): Promise<boolean> {
+	let jsonData: Record<string, unknown> = {};
+
+	if (existsSync(targetPath)) {
+		try {
+			const content = await Bun.file(targetPath).text();
+			if (content.trim()) {
+				jsonData = JSON.parse(content) as Record<string, unknown>;
+			}
+		} catch {
+			return false;
+		}
+	}
+
+	for (const [path, value] of Object.entries(updates)) {
+		if (typeof value === "string") {
+			setJsonPath(jsonData, path, substitute(value));
+		} else if (value?.from === "input") {
+			setJsonPath(jsonData, path, inputValue);
+		}
+	}
+
+	await Bun.write(targetPath, `${JSON.stringify(jsonData, null, 2)}\n`);
+	return true;
+}

package/src/lib/mcp-config.ts

@@ -3,6 +3,7 @@ import { mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { platform } from "node:os";
 import { dirname, join } from "node:path";
+import { CONFIG_DIR } from "./config.ts";
 
 /**
  * MCP server configuration structure
@@ -44,7 +45,7 @@ export const APP_MCP_CONFIGS: Record<string, AppMcpConfig> = {
 /**
  * Jack MCP configuration storage path
  */
-const JACK_MCP_CONFIG_DIR = join(homedir(), ".config", "jack", "mcp");
+const JACK_MCP_CONFIG_DIR = join(CONFIG_DIR, "mcp");
 const JACK_MCP_CONFIG_PATH = join(JACK_MCP_CONFIG_DIR, "config.json");
 
 /**

package/src/lib/output.ts

@@ -26,13 +26,34 @@ export const output = {
 	warn,
 	item,
 	box,
+	celebrate,
 };
 
 /**
  * Create a spinner for long-running operations
  */
 export function spinner(text: string) {
-	return yoctoSpinner({ text }).start();
+	const spin = yoctoSpinner({ text }).start();
+
+	return {
+		success(message: string) {
+			spin.stop();
+			success(message);
+		},
+		error(message: string) {
+			spin.stop();
+			error(message);
+		},
+		stop() {
+			spin.stop();
+		},
+		get text() {
+			return spin.text;
+		},
+		set text(value: string | undefined) {
+			spin.text = value ?? "";
+		},
+	};
 }
 
 /**
@@ -74,25 +95,75 @@ export function item(message: string): void {
 	console.error(`  ${message}`);
 }
 
+// Random neon purple for cyberpunk styling
+function getRandomPurple(): string {
+	const purples = [177, 165, 141, 129];
+	const colorCode = purples[Math.floor(Math.random() * purples.length)];
+	return `\x1b[38;5;${colorCode}m`;
+}
+
 /**
- * Print a boxed message for important info
+ * Print a boxed message for important info (cyberpunk style)
  */
 export function box(title: string, lines: string[]): void {
 	const maxLen = Math.max(title.length, ...lines.map((l) => l.length));
-	const width = maxLen + 4;
-	const border = isColorEnabled ? "\x1b[90m" : "";
+	const innerWidth = maxLen + 4;
+
+	const purple = isColorEnabled ? getRandomPurple() : "";
+	const bold = isColorEnabled ? "\x1b[1m" : "";
+	const reset = isColorEnabled ? "\x1b[0m" : "";
+
+	const bar = "═".repeat(innerWidth);
+	const fill = "▓".repeat(innerWidth);
+	const gradient = "░".repeat(innerWidth);
+
+	const pad = (text: string) => `  ${text.padEnd(maxLen)}  `;
+
+	console.error("");
+	console.error(`  ${purple}╔${bar}╗${reset}`);
+	console.error(`  ${purple}║${fill}║${reset}`);
+	console.error(`  ${purple}║${pad(bold + title + reset + purple)}║${reset}`);
+	console.error(`  ${purple}║${"─".repeat(innerWidth)}║${reset}`);
+	for (const line of lines) {
+		console.error(`  ${purple}║${pad(line)}║${reset}`);
+	}
+	console.error(`  ${purple}║${gradient}║${reset}`);
+	console.error(`  ${purple}╚${bar}╝${reset}`);
+	console.error("");
+}
+
+/**
+ * Print a celebration box (for final success after setup)
+ */
+export function celebrate(title: string, lines: string[]): void {
+	const maxLen = Math.max(title.length, ...lines.map((l) => l.length));
+	const innerWidth = maxLen + 4;
+
+	const purple = isColorEnabled ? getRandomPurple() : "";
+	const bold = isColorEnabled ? "\x1b[1m" : "";
 	const reset = isColorEnabled ? "\x1b[0m" : "";
-	const titleColor = isColorEnabled ? "\x1b[1m" : "";
+
+	const bar = "═".repeat(innerWidth);
+	const fill = "▓".repeat(innerWidth);
+	const gradient = "░".repeat(innerWidth);
+	const space = " ".repeat(innerWidth);
+
+	const center = (text: string) => {
+		const left = Math.floor((innerWidth - text.length) / 2);
+		return " ".repeat(left) + text + " ".repeat(innerWidth - text.length - left);
+	};
 
 	console.error("");
-	console.error(`${border}┌${"─".repeat(width)}┐${reset}`);
-	console.error(
-		`${border}│${reset}  ${titleColor}${title.padEnd(maxLen)}${reset}  ${border}│${reset}`,
-	);
-	console.error(`${border}├${"─".repeat(width)}┤${reset}`);
+	console.error(`  ${purple}╔${bar}╗${reset}`);
+	console.error(`  ${purple}║${fill}║${reset}`);
+	console.error(`  ${purple}║${space}║${reset}`);
+	console.error(`  ${purple}║${center(bold + title + reset + purple)}║${reset}`);
+	console.error(`  ${purple}║${space}║${reset}`);
 	for (const line of lines) {
-		console.error(`${border}│${reset}  ${line.padEnd(maxLen)}  ${border}│${reset}`);
+		console.error(`  ${purple}║${center(line)}║${reset}`);
 	}
-	console.error(`${border}└${"─".repeat(width)}┘${reset}`);
+	console.error(`  ${purple}║${space}║${reset}`);
+	console.error(`  ${purple}║${gradient}║${reset}`);
+	console.error(`  ${purple}╚${bar}╝${reset}`);
 	console.error("");
 }

package/src/lib/paths-index.test.ts

@@ -187,7 +187,7 @@ describe("paths-index", () => {
 				const index = await readPathsIndex();
 
 				// Should store absolute path
-				expect(index.paths.proj_rel[0].startsWith("/")).toBe(true);
+				expect(index.paths.proj_rel?.[0]?.startsWith("/")).toBe(true);
 			} finally {
 				process.chdir(originalCwd);
 			}
@@ -351,7 +351,7 @@ describe("paths-index", () => {
 			const discovered = await scanAndRegisterProjects(testDir);
 
 			expect(discovered).toHaveLength(1);
-			expect(discovered[0].projectId).toBe("proj_linked");
+			expect(discovered[0]!.projectId).toBe("proj_linked");
 		});
 
 		it("respects maxDepth", async () => {
@@ -366,7 +366,7 @@ describe("paths-index", () => {
 			const discovered = await scanAndRegisterProjects(testDir, 2);
 
 			expect(discovered).toHaveLength(1);
-			expect(discovered[0].projectId).toBe("proj_shallow");
+			expect(discovered[0]!.projectId).toBe("proj_shallow");
 		});
 
 		it("skips node_modules", async () => {
@@ -379,7 +379,7 @@ describe("paths-index", () => {
 			const discovered = await scanAndRegisterProjects(testDir);
 
 			expect(discovered).toHaveLength(1);
-			expect(discovered[0].projectId).toBe("proj_valid");
+			expect(discovered[0]!.projectId).toBe("proj_valid");
 		});
 
 		it("skips .git directory", async () => {
@@ -392,7 +392,7 @@ describe("paths-index", () => {
 			const discovered = await scanAndRegisterProjects(testDir);
 
 			expect(discovered).toHaveLength(1);
-			expect(discovered[0].projectId).toBe("proj_valid");
+			expect(discovered[0]!.projectId).toBe("proj_valid");
 		});
 
 		it("does not recurse into linked projects", async () => {
@@ -407,7 +407,7 @@ describe("paths-index", () => {
 
 			// Should only find parent, not nested child
 			expect(discovered).toHaveLength(1);
-			expect(discovered[0].projectId).toBe("proj_parent");
+			expect(discovered[0]!.projectId).toBe("proj_parent");
 		});
 
 		it("registers discovered projects in index", async () => {
@@ -517,7 +517,7 @@ describe("paths-index", () => {
 
 			const discovered = await scanAndRegisterProjects(testDir);
 			expect(discovered).toHaveLength(1);
-			expect(discovered[0].projectId).toBe("proj_spaces");
+			expect(discovered[0]!.projectId).toBe("proj_spaces");
 		});
 
 		it("handles permission errors gracefully", async () => {