@getjack/jack 0.1.8 → 0.1.10

package/package.json

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

package/src/commands/login.ts

@@ -6,7 +6,8 @@ import {
 	getCurrentUserProfile,
 	setUsername,
 } from "../lib/control-plane.ts";
-import { error, info, spinner, success, warn } from "../lib/output.ts";
+import { celebrate, error, info, spinner, success, warn } from "../lib/output.ts";
+import { identifyUser } from "../lib/telemetry.ts";
 
 interface LoginOptions {
 	/** Skip the initial "Logging in..." message (used when called from auto-login) */
@@ -31,13 +32,7 @@ export default async function login(options: LoginOptions = {}): Promise<void> {
 		process.exit(1);
 	}
 
-	console.error("");
-	console.error("  ┌────────────────────────────────────┐");
-	console.error("  │                                    │");
-	console.error(`  │    Your code:  ${deviceAuth.user_code.padEnd(12)}      │`);
-	console.error("  │                                    │");
-	console.error("  └────────────────────────────────────┘");
-	console.error("");
+	celebrate("Your code:", [deviceAuth.user_code]);
 	info(`Opening ${deviceAuth.verification_uri} in your browser...`);
 	console.error("");
 
@@ -73,8 +68,12 @@ export default async function login(options: LoginOptions = {}): Promise<void> {
 				};
 				await saveCredentials(creds);
 
+				// Link user identity for cross-platform analytics
+				await identifyUser(tokens.user.id, { email: tokens.user.email });
+
 				console.error("");
-				success(`Logged in as ${tokens.user.email}`);
+				const displayName = tokens.user.first_name || "Logged in";
+				success(tokens.user.first_name ? `Welcome back, ${displayName}` : displayName);
 
 				// Prompt for username if not set
 				await promptForUsername(tokens.user.email);
@@ -209,3 +208,4 @@ function normalizeToUsername(input: string): string {
 		.replace(/^-+|-+$/g, "")
 		.slice(0, 39);
 }
+

package/src/commands/new.ts

@@ -59,6 +59,7 @@ export default async function newProject(
 				error: output.error,
 				success: output.success,
 				box: output.box,
+				celebrate: output.celebrate,
 			},
 			interactive: !isCi,
 			managed: options.managed,

package/src/commands/projects.ts

@@ -18,11 +18,7 @@ import {
 	sortByUpdated,
 	toListItems,
 } from "../lib/project-list.ts";
-import {
-	cleanupStaleProjects,
-	getProjectStatus,
-	scanStaleProjects,
-} from "../lib/project-operations.ts";
+import { cleanupStaleProjects, scanStaleProjects } from "../lib/project-operations.ts";
 import {
 	type ResolvedProject,
 	listAllProjects,
@@ -104,7 +100,7 @@ async function listProjects(args: string[]): Promise<void> {
 	const cloudOnly = args.includes("--cloud");
 
 	// Fetch all projects from registry and control plane
-	outputSpinner.start("Checking project status...");
+	outputSpinner.start("Loading projects...");
 	const projects: ResolvedProject[] = await listAllProjects();
 	outputSpinner.stop();
 
@@ -154,6 +150,7 @@ async function listProjects(args: string[]): Promise<void> {
 function renderGroupedView(items: ProjectListItem[]): void {
 	const groups = groupProjects(items);
 	const total = items.length;
+	const CLOUD_LIMIT = 5;
 
 	// Build consistent tag color map across all projects
 	const tagColorMap = buildTagColorMap(items);
@@ -178,7 +175,6 @@ function renderGroupedView(items: ProjectListItem[]): void {
 
 	// Section 3: Cloud-only (show last N by updatedAt)
 	if (groups.cloudOnly.length > 0) {
-		const CLOUD_LIMIT = 5;
 		const sorted = sortByUpdated(groups.cloudOnly);
 
 		console.error("");
@@ -191,9 +187,14 @@ function renderGroupedView(items: ProjectListItem[]): void {
 		);
 	}
 
-	// Footer hint
+	// Footer hint - only show --all hint if there are hidden cloud projects
 	console.error("");
-	info("jack ls --all for full list, --status error to filter");
+	const hasHiddenCloudProjects = groups.cloudOnly.length > CLOUD_LIMIT;
+	if (hasHiddenCloudProjects) {
+		info(`jack ls --all to see all ${groups.cloudOnly.length} cloud projects`);
+	} else {
+		info("jack ls --status error to filter, --json for machine output");
+	}
 	console.error("");
 }
 
@@ -247,6 +248,7 @@ function renderFlatTable(items: ProjectListItem[]): void {
  * Show detailed project info
  */
 async function infoProject(args: string[]): Promise<void> {
+	const hasExplicitName = Boolean(args[0]);
 	let name = args[0];
 
 	// If no name provided, try to get from cwd
@@ -261,80 +263,82 @@ async function infoProject(args: string[]): Promise<void> {
 		}
 	}
 
-	// Check actual status (with spinner for API calls)
+	// Resolve project using the same pattern as down.ts
 	outputSpinner.start("Fetching project info...");
-	const status = await getProjectStatus(name);
+	const resolved = await resolveProject(name, {
+		preferLocalLink: !hasExplicitName,
+		includeResources: true,
+	});
 	outputSpinner.stop();
 
-	if (!status) {
-		error(`Project "${name}" not found in registry`);
+	// Guard against mismatched resolutions when an explicit name is provided
+	if (hasExplicitName && resolved) {
+		const matches =
+			name === resolved.slug || name === resolved.name || name === resolved.remote?.projectId;
+		if (!matches) {
+			error(`Project '${name}' resolves to '${resolved.slug}'.`);
+			info("Use the exact slug/name and try again.");
+			process.exit(1);
+		}
+	}
+
+	if (!resolved) {
+		error(`Project "${name}" not found`);
 		info("List projects with: jack projects list");
 		process.exit(1);
 	}
 
 	console.error("");
-	info(`Project: ${status.name}`);
+	info(`Project: ${resolved.name}`);
 	console.error("");
 
 	// Status section
 	const statuses: string[] = [];
-	if (status.local) {
+	if (resolved.sources.filesystem) {
 		statuses.push("local");
 	}
-	if (status.deployed) {
+	if (resolved.status === "live") {
 		statuses.push("deployed");
 	}
-	if (status.backedUp) {
-		statuses.push("backup");
-	}
 
 	item(`Status: ${statuses.join(", ") || "none"}`);
 	console.error("");
 
 	// Workspace info (only shown if running from project directory)
-	if (status.localPath) {
-		item(`Workspace path: ${status.localPath}`);
+	if (resolved.localPath) {
+		item(`Workspace path: ${resolved.localPath}`);
 		console.error("");
 	}
 
 	// Deployment info
-	if (status.workerUrl) {
-		item(`Worker URL: ${status.workerUrl}`);
-	}
-	if (status.lastDeployed) {
-		item(`Last deployed: ${new Date(status.lastDeployed).toLocaleString()}`);
+	if (resolved.url) {
+		item(`Worker URL: ${resolved.url}`);
 	}
-	if (status.deployed) {
-		console.error("");
+	if (resolved.updatedAt) {
+		item(`Last deployed: ${new Date(resolved.updatedAt).toLocaleString()}`);
 	}
-
-	// Backup info
-	if (status.backedUp && status.backupFiles !== null) {
-		item(`Backup: ${status.backupFiles} files`);
-		if (status.backupLastSync) {
-			item(`Last synced: ${new Date(status.backupLastSync).toLocaleString()}`);
-		}
+	if (resolved.status === "live") {
 		console.error("");
 	}
 
 	// Account info
-	if (status.accountId) {
-		item(`Account ID: ${status.accountId}`);
+	if (resolved.remote?.orgId) {
+		item(`Account ID: ${resolved.remote.orgId}`);
 	}
-	if (status.workerId) {
-		item(`Worker ID: ${status.workerId}`);
+	if (resolved.slug) {
+		item(`Worker ID: ${resolved.slug}`);
 	}
 	console.error("");
 
 	// Resources
-	if (status.dbName) {
-		item(`Database: ${status.dbName}`);
+	if (resolved.resources?.d1?.name) {
+		item(`Database: ${resolved.resources.d1.name}`);
 		console.error("");
 	}
 
 	// Timestamps
-	if (status.createdAt) {
-		item(`Created: ${new Date(status.createdAt).toLocaleString()}`);
+	if (resolved.createdAt) {
+		item(`Created: ${new Date(resolved.createdAt).toLocaleString()}`);
 	}
 	console.error("");
 }
@@ -406,7 +410,7 @@ async function removeProjectEntry(args: string[]): Promise<void> {
 	}
 
 	// Use resolver to find project anywhere (registry OR control plane)
-	outputSpinner.start("Checking project status...");
+	outputSpinner.start("Finding project...");
 	const project = await resolveProject(name);
 	outputSpinner.stop();
 

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/output.ts

@@ -26,6 +26,7 @@ export const output = {
 	warn,
 	item,
 	box,
+	celebrate,
 };
 
 /**
@@ -94,25 +95,78 @@ 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);
+
+	// Center text based on visual length, then apply colors
+	const center = (text: string, applyBold = false) => {
+		const left = Math.floor((innerWidth - text.length) / 2);
+		const right = innerWidth - text.length - left;
+		const centered = " ".repeat(left) + text + " ".repeat(right);
+		return applyBold ? centered.replace(text, bold + text + reset + purple) : centered;
+	};
 
 	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(title, true)}║${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 () => {

package/src/lib/project-operations.ts

@@ -939,11 +939,11 @@ export async function createProject(
 	// Run pre-deploy hooks
 	if (template.hooks?.preDeploy?.length) {
 		const hookContext = { projectName, projectDir: targetDir };
-		const passed = await runHook(template.hooks.preDeploy, hookContext, {
+		const hookResult = await runHook(template.hooks.preDeploy, hookContext, {
 			interactive,
 			output: reporter,
 		});
-		if (!passed) {
+		if (!hookResult.success) {
 			reporter.error("Pre-deploy checks failed");
 			throw new JackError(JackErrorCode.VALIDATION_ERROR, "Pre-deploy checks failed", undefined, {
 				exitCode: 0,
@@ -1145,7 +1145,7 @@ export async function createProject(
 	// Run post-deploy hooks (for both modes)
 	if (template.hooks?.postDeploy?.length && workerUrl) {
 		const domain = workerUrl.replace(/^https?:\/\//, "");
-		await runHook(
+		const hookResult = await runHook(
 			template.hooks.postDeploy,
 			{
 				domain,
@@ -1155,6 +1155,11 @@ export async function createProject(
 			},
 			{ interactive, output: reporter },
 		);
+
+		// Show final celebration if there were interactive prompts (URL might have scrolled away)
+		if (hookResult.hadInteractiveActions && reporter.celebrate) {
+			reporter.celebrate("You're live!", [domain]);
+		}
 	}
 
 	return {

package/src/lib/telemetry.ts

@@ -147,6 +147,35 @@ export async function identify(properties: Partial<UserProperties>): Promise<voi
 	}
 }
 
+/**
+ * Link a logged-in user to their pre-login anonymous events.
+ * This should be called after successful authentication.
+ *
+ * @param userId - The WorkOS user ID (user.id)
+ * @param properties - Optional user properties like email
+ */
+export async function identifyUser(userId: string, properties?: { email?: string }): Promise<void> {
+	if (!(await isEnabled())) return;
+
+	try {
+		const anonymousId = await getAnonymousId();
+
+		// Identify with real user ID
+		send(`${TELEMETRY_PROXY}/identify`, {
+			distinctId: userId,
+			properties: { ...properties, ...userProps },
+		});
+
+		// Alias to merge pre-login anonymous events with identified user
+		send(`${TELEMETRY_PROXY}/alias`, {
+			distinctId: userId,
+			alias: anonymousId,
+		});
+	} catch {
+		// Silent
+	}
+}
+
 // ============================================
 // TRACK
 // ============================================

package/src/mcp/test-utils.ts

@@ -22,7 +22,7 @@ export async function openMcpTestClient(options: McpClientOptions): Promise<McpT
 		command: options.command,
 		args: options.args ?? [],
 		cwd: options.cwd,
-		env: options.env,
+		env: options.env as Record<string, string> | undefined,
 		stderr: "pipe",
 	});
 
@@ -53,6 +53,7 @@ export async function openMcpTestClient(options: McpClientOptions): Promise<McpT
 
 export function parseMcpToolResult(toolResult: {
 	content?: Array<{ type: string; text?: string }>;
+	[key: string]: unknown;
 }): unknown {
 	const toolText = toolResult.content?.[0]?.type === "text" ? toolResult.content[0].text : null;
 	if (!toolText) {

package/src/templates/index.ts

@@ -225,7 +225,7 @@ export async function resolveTemplate(template?: string): Promise<Template> {
 
 	// username/slug format - fetch from jack cloud
 	if (template.includes("/")) {
-		const [username, slug] = template.split("/", 2);
+		const [username, slug] = template.split("/", 2) as [string, string];
 		return fetchPublishedTemplate(username, slug);
 	}
 

package/src/templates/types.ts

@@ -6,6 +6,23 @@ export type HookAction =
 	| { action: "clipboard"; text: string; message?: string }
 	| { action: "shell"; command: string; cwd?: "project"; message?: string }
 	| { action: "pause"; message?: string } // press enter to continue
+	| {
+			action: "prompt";
+			message: string;
+			validate?: "json" | "accountAssociation";
+			required?: boolean;
+			successMessage?: string;
+			writeJson?: {
+				path: string;
+				set: Record<string, string | { from: "input" }>;
+			};
+	  }
+	| {
+			action: "writeJson";
+			path: string;
+			set: Record<string, string>;
+			successMessage?: string;
+	  }
 	| {
 			action: "require";
 			source: "secret" | "env";

package/templates/CLAUDE.md

@@ -110,6 +110,20 @@ name = "jack-template"           → name = "my-app"
 
 Templates can define hooks in `.jack.json` that run at specific lifecycle points.
 
+### Hook Schema (Quick Reference)
+
+| Action | Required Fields | Non-Interactive Behavior |
+|--------|------------------|--------------------------|
+| `message` | `text` | Prints message |
+| `box` | `title`, `lines` | Prints box |
+| `url` | `url` | Prints label + URL |
+| `clipboard` | `text` | Prints text |
+| `pause` | _(none)_ | Skipped |
+| `require` | `source`, `key` | Validates, prints setup if provided |
+| `shell` | `command` | Runs with stdin ignored |
+| `prompt` | `message` | Skipped (supports `validate: "json" | "accountAssociation"`) |
+| `writeJson` | `path`, `set` | Runs (safe in CI) |
+
 ### Hook Lifecycle
 
 ```json
@@ -132,6 +146,8 @@ Templates can define hooks in `.jack.json` that run at specific lifecycle points
 | `shell` | Execute shell command | `{"action": "shell", "command": "curl {{url}}/health"}` |
 | `pause` | Wait for Enter key | `{"action": "pause", "message": "Press Enter..."}` |
 | `require` | Verify secret or env | `{"action": "require", "source": "secret", "key": "API_KEY"}` |
+| `prompt` | Prompt for input and update JSON file | `{"action": "prompt", "message": "Paste JSON", "validate": "json", "successMessage": "Saved", "writeJson": {"path": "public/data.json", "set": {"data": {"from": "input"}}}}` |
+| `writeJson` | Update JSON file with template vars | `{"action": "writeJson", "path": "public/data.json", "set": {"siteUrl": "{{url}}"}}` |
 
 ### Non-Interactive Mode
 
@@ -141,7 +157,9 @@ Hooks run in a non-interactive mode for MCP/silent execution. In this mode:
 - `clipboard` prints the text (no clipboard access)
 - `pause` is skipped
 - `require` still validates; if `setupUrl` exists it prints `Setup: ...`
+- `prompt` is skipped
 - `shell` runs with stdin ignored to avoid hangs
+- `writeJson` still runs (non-interactive safe)
 
 ### Hook Variables
 
@@ -178,7 +196,9 @@ These variables are substituted at runtime (different from template placeholders
     "postDeploy": [
       {"action": "clipboard", "text": "{{url}}"},
       {"action": "box", "title": "Deployed: {{name}}", "lines": ["URL: {{url}}"]},
-      {"action": "url", "url": "https://farcaster.xyz/.../manifest?domain={{domain}}", "label": "Generate manifest"},
+      {"action": "url", "url": "https://farcaster.xyz/.../manifest?domain={{domain}}", "label": "Sign manifest"},
+      {"action": "writeJson", "path": "public/.well-known/farcaster.json", "set": {"miniapp.homeUrl": "{{url}}"}},
+      {"action": "prompt", "message": "Paste accountAssociation JSON", "validate": "accountAssociation", "successMessage": "Saved domain association", "writeJson": {"path": "public/.well-known/farcaster.json", "set": {"accountAssociation": {"from": "input"}}}},
       {"action": "url", "url": "https://farcaster.xyz/.../preview?url={{url}}", "label": "Preview"}
     ]
   }

package/templates/miniapp/.jack.json

@@ -38,12 +38,41 @@
 			{
 				"action": "box",
 				"title": "Deployed: {{name}}",
-				"lines": ["URL: {{url}}", "", "Next: Generate a manifest, then preview your miniapp"]
+				"lines": [
+					"URL: {{url}}",
+					"Manifest: {{url}}/.well-known/farcaster.json",
+					"",
+					"Next: Sign the manifest and paste accountAssociation when prompted"
+				]
+			},
+			{
+				"action": "writeJson",
+				"path": "public/.well-known/farcaster.json",
+				"successMessage": "Updated manifest URLs to {{url}}",
+				"set": {
+					"miniapp.name": "{{name}}",
+					"miniapp.homeUrl": "{{url}}",
+					"miniapp.iconUrl": "{{url}}/icon.png",
+					"miniapp.imageUrl": "{{url}}/og.png",
+					"miniapp.splashImageUrl": "{{url}}/icon.png"
+				}
 			},
 			{
 				"action": "url",
 				"url": "https://farcaster.xyz/~/developers/mini-apps/manifest?domain={{domain}}",
-				"label": "Generate manifest"
+				"label": "Sign manifest"
+			},
+			{
+				"action": "prompt",
+				"message": "Paste accountAssociation JSON from Farcaster (or press Enter to skip):",
+				"validate": "accountAssociation",
+				"successMessage": "Saved domain association to public/.well-known/farcaster.json",
+				"writeJson": {
+					"path": "public/.well-known/farcaster.json",
+					"set": {
+						"accountAssociation": { "from": "input" }
+					}
+				}
 			},
 			{
 				"action": "url",

package/templates/miniapp/index.html

@@ -4,7 +4,6 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>jack-template</title>
-    <meta name="fc:miniapp" content='{"version":"1","imageUrl":"/og.png","button":{"title":"Open App","action":{"type":"launch_miniapp","name":"jack-template","splashImageUrl":"/icon.png","splashBackgroundColor":"#0a0a0a"}}}' />
   </head>
   <body>
     <div id="root"></div>

package/templates/miniapp/public/.well-known/farcaster.json

@@ -1,17 +1,17 @@
 {
-	"accountAssociation": {
-		"header": "",
-		"payload": "",
-		"signature": ""
-	},
-	"miniapp": {
-		"version": "1",
-		"name": "jack-template",
-		"iconUrl": "/icon.png",
-		"homeUrl": "/",
-		"imageUrl": "/og.png",
-		"splashImageUrl": "/icon.png",
-		"splashBackgroundColor": "#0a0a0a",
-		"buttonTitle": "Open App"
-	}
+  "accountAssociation": {
+    "header": "",
+    "payload": "",
+    "signature": ""
+  },
+  "miniapp": {
+    "version": "1",
+    "name": "jack-template",
+    "iconUrl": "https://example.com/icon.png",
+    "homeUrl": "https://example.com",
+    "imageUrl": "https://example.com/og.png",
+    "buttonTitle": "Open App",
+    "splashImageUrl": "https://example.com/icon.png",
+    "splashBackgroundColor": "#0a0a0a"
+  }
 }

package/templates/miniapp/src/worker.ts

@@ -13,6 +13,13 @@ type Env = {
 	APP_URL?: string; // Production URL for share embeds (e.g., https://my-app.workers.dev)
 };
 
+function isIpAddress(hostname: string): boolean {
+	if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname)) {
+		return true;
+	}
+	return hostname.includes(":");
+}
+
 // Get production base URL - required for valid Farcaster embeds
 // Farcaster requires absolute https:// URLs (no localhost, no relative paths)
 // See: https://miniapps.farcaster.xyz/docs/embeds
@@ -23,8 +30,13 @@ function getBaseUrl(
 	// 1. Prefer explicit APP_URL if set (most reliable for custom domains)
 	if (env.APP_URL && env.APP_URL.trim() !== "") {
 		const url = env.APP_URL.replace(/\/$/, "");
-		if (url.startsWith("https://")) {
-			return url;
+		try {
+			const parsed = new URL(url);
+			if (parsed.protocol === "https:" && !isIpAddress(parsed.hostname)) {
+				return parsed.origin;
+			}
+		} catch {
+			// Ignore parse errors
 		}
 		// If APP_URL is set but not https, warn and continue
 		console.warn(`APP_URL should be https, got: ${url}`);
@@ -33,8 +45,19 @@ function getBaseUrl(
 	// 2. Use Host header (always set by Cloudflare in production)
 	const host = c.req.header("host");
 	if (host) {
-		// Reject localhost - embeds won't work in local dev
-		if (host.startsWith("localhost") || host.startsWith("127.0.0.1")) {
+		let hostname = host;
+		try {
+			hostname = new URL(`https://${host}`).hostname;
+		} catch {
+			// Ignore parse errors and fall back to raw host
+		}
+
+		// Reject localhost or IPs - embeds won't work in local dev or IP domains
+		if (
+			hostname === "localhost" ||
+			hostname === "127.0.0.1" ||
+			isIpAddress(hostname)
+		) {
 			return null; // Signal that we can't generate valid embed URLs
 		}