@getjack/jack 0.1.17 → 0.1.20

package/src/lib/hooks.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import * as readline from "node:readline";
 import type { HookAction } from "../templates/types";
 import { applyJsonWrite } from "./json-edit";
-import { getSavedSecrets } from "./secrets";
+import { getSavedSecrets, saveSecrets } from "./secrets";
 import { restoreTty } from "./tty";
 
 /**
@@ -379,9 +379,87 @@ const actionHandlers: {
 	require: async (action, context, options) => {
 		const ui = options.output ?? noopOutput;
 		const interactive = options.interactive !== false;
+		const onMissing = action.onMissing ?? "fail";
+
 		if (action.source === "secret") {
 			const result = await checkSecretExists(action.key, context.projectDir);
+			if (result.exists) {
+				// Found existing secret - show feedback for prompt/generate modes
+				if (onMissing === "prompt" || onMissing === "generate") {
+					ui.success(`Using saved ${action.key}`);
+				}
+				return true;
+			}
+
+			// Secret doesn't exist - handle based on onMissing mode
 			if (!result.exists) {
+				// Handle onMissing: "generate" - run command and save output
+				if (onMissing === "generate" && action.generateCommand) {
+					const message = action.message ?? `Generating ${action.key}...`;
+					ui.info(message);
+
+					try {
+						const proc = Bun.spawn(["sh", "-c", action.generateCommand], {
+							stdout: "pipe",
+							stderr: "pipe",
+						});
+						await proc.exited;
+
+						if (proc.exitCode === 0) {
+							const stdout = await new Response(proc.stdout).text();
+							const value = stdout.trim();
+							if (value) {
+								await saveSecrets([{ key: action.key, value, source: "generated" }]);
+								ui.success(`Generated ${action.key}`);
+								return true;
+							}
+						}
+						ui.error(`Failed to generate ${action.key}`);
+						return false;
+					} catch {
+						ui.error(`Failed to run: ${action.generateCommand}`);
+						return false;
+					}
+				}
+
+				// Handle onMissing: "prompt" - ask user for value
+				if (onMissing === "prompt") {
+					if (!interactive) {
+						// Fall back to fail behavior in non-interactive mode
+						const message = action.message ?? `Missing required secret: ${action.key}`;
+						ui.error(message);
+						ui.info(`Run: jack secrets add ${action.key}`);
+						if (action.setupUrl) {
+							ui.info(`Setup: ${action.setupUrl}`);
+						}
+						return false;
+					}
+
+					// Show setup info and go straight to prompt (URLs are clickable in most terminals)
+					const promptMsg = action.promptMessage ?? `${action.key}:`;
+					console.error("");
+					if (action.message) {
+						console.error(`  ${action.message}`);
+					}
+					if (action.setupUrl) {
+						console.error(`  Get it at: \x1b[36m${action.setupUrl}\x1b[0m`);
+					}
+					console.error("");
+
+					const { isCancel, text } = await import("@clack/prompts");
+					const value = await text({ message: promptMsg });
+
+					if (isCancel(value) || !value.trim()) {
+						ui.warn(`Skipped ${action.key}`);
+						return false;
+					}
+
+					await saveSecrets([{ key: action.key, value: value.trim(), source: "prompted" }]);
+					ui.success(`Saved ${action.key}`);
+					return true;
+				}
+
+				// Default: onMissing: "fail"
 				const message = action.message ?? `Missing required secret: ${action.key}`;
 				ui.error(message);
 				ui.info(`Run: jack secrets add ${action.key}`);
@@ -425,6 +503,14 @@ const actionHandlers: {
 		// Use multi-line input for JSON validation (handles paste from Farcaster etc.)
 		if (action.validate === "json" || action.validate === "accountAssociation") {
 			rawValue = await readMultilineJson(action.message);
+		} else if (action.secret) {
+			// Use password() for sensitive input (masks the value)
+			const { isCancel, password } = await import("@clack/prompts");
+			const result = await password({ message: action.message });
+			if (isCancel(result)) {
+				return true;
+			}
+			rawValue = result;
 		} else {
 			const { isCancel, text } = await import("@clack/prompts");
 			const result = await text({ message: action.message });
@@ -538,6 +624,151 @@ const actionHandlers: {
 		await proc.exited;
 		return proc.exitCode === 0;
 	},
+	"stripe-setup": async (action, context, options) => {
+		const ui = options.output ?? noopOutput;
+
+		// Get Stripe API key from saved secrets
+		const savedSecrets = await getSavedSecrets();
+		const stripeKey = savedSecrets.STRIPE_SECRET_KEY;
+
+		if (!stripeKey) {
+			ui.error("Missing STRIPE_SECRET_KEY - run the secret prompt first");
+			return false;
+		}
+
+		const message = action.message ?? "Setting up Stripe products and prices...";
+		ui.info(message);
+
+		// Helper to make Stripe API requests
+		async function stripeRequest(
+			method: string,
+			endpoint: string,
+			body?: Record<string, string>,
+		): Promise<{ ok: boolean; data?: Record<string, unknown>; error?: string }> {
+			const url = `https://api.stripe.com/v1${endpoint}`;
+			const headers: Record<string, string> = {
+				Authorization: `Bearer ${stripeKey}`,
+			};
+
+			const fetchOptions: RequestInit = { method, headers };
+			if (body) {
+				headers["Content-Type"] = "application/x-www-form-urlencoded";
+				fetchOptions.body = new URLSearchParams(body).toString();
+			}
+
+			try {
+				const response = await fetch(url, fetchOptions);
+				const data = (await response.json()) as Record<string, unknown>;
+
+				if (!response.ok) {
+					const error = data.error as { message?: string } | undefined;
+					return { ok: false, error: error?.message ?? "Stripe API error" };
+				}
+				return { ok: true, data };
+			} catch (err) {
+				return { ok: false, error: String(err) };
+			}
+		}
+
+		// Search for existing price by lookup_key
+		async function findPriceByLookupKey(lookupKey: string): Promise<string | null> {
+			const result = await stripeRequest(
+				"GET",
+				`/prices?lookup_keys[]=${encodeURIComponent(lookupKey)}&active=true`,
+			);
+			if (result.ok && result.data) {
+				const prices = result.data.data as Array<{ id: string }>;
+				if (prices.length > 0) {
+					return prices[0].id;
+				}
+			}
+			return null;
+		}
+
+		// Create a new product
+		async function createProduct(name: string, description?: string): Promise<string | null> {
+			const body: Record<string, string> = { name };
+			if (description) {
+				body.description = description;
+			}
+			const result = await stripeRequest("POST", "/products", body);
+			if (result.ok && result.data) {
+				return result.data.id as string;
+			}
+			return null;
+		}
+
+		// Create a new price with lookup_key
+		async function createPrice(
+			productId: string,
+			amount: number,
+			interval: "month" | "year",
+			lookupKey: string,
+		): Promise<string | null> {
+			const result = await stripeRequest("POST", "/prices", {
+				product: productId,
+				unit_amount: String(amount),
+				currency: "usd",
+				"recurring[interval]": interval,
+				lookup_key: lookupKey,
+			});
+			if (result.ok && result.data) {
+				return result.data.id as string;
+			}
+			return null;
+		}
+
+		const secretsToSave: Array<{ key: string; value: string; source: string }> = [];
+
+		for (const plan of action.plans) {
+			const lookupKey = `jack_${plan.name.toLowerCase()}_${plan.interval}`;
+
+			// Check if price key already exists in secrets (manual override)
+			if (savedSecrets[plan.priceKey]) {
+				ui.success(`Using existing ${plan.priceKey}`);
+				continue;
+			}
+
+			// Search for existing price by lookup_key
+			ui.info(`Checking for existing ${plan.name} price...`);
+			let priceId = await findPriceByLookupKey(lookupKey);
+
+			if (priceId) {
+				ui.success(`Found existing ${plan.name} price: ${priceId}`);
+			} else {
+				// Create product and price
+				ui.info(`Creating ${plan.name} product and price...`);
+
+				const productId = await createProduct(plan.name, plan.description ?? `${plan.name} plan`);
+				if (!productId) {
+					ui.error(`Failed to create ${plan.name} product`);
+					return false;
+				}
+
+				priceId = await createPrice(productId, plan.amount, plan.interval, lookupKey);
+				if (!priceId) {
+					ui.error(`Failed to create ${plan.name} price`);
+					return false;
+				}
+
+				ui.success(`Created ${plan.name}: ${priceId}`);
+			}
+
+			secretsToSave.push({
+				key: plan.priceKey,
+				value: priceId,
+				source: "stripe-setup",
+			});
+		}
+
+		// Save all price IDs to secrets
+		if (secretsToSave.length > 0) {
+			await saveSecrets(secretsToSave);
+			ui.success("Saved Stripe price IDs to secrets");
+		}
+
+		return true;
+	},
 };
 
 async function executeAction(

package/src/lib/managed-deploy.ts

@@ -4,12 +4,15 @@
  * Isolates managed deployment logic from BYO (wrangler) path.
  */
 
+import { stat } from "node:fs/promises";
 import { validateBindings } from "./binding-validator.ts";
 import { buildProject, parseWranglerConfig } from "./build-helper.ts";
 import { createManagedProject, syncProjectTags, uploadSourceSnapshot } from "./control-plane.ts";
 import { debug } from "./debug.ts";
 import { uploadDeployment } from "./deploy-upload.ts";
 import { JackError, JackErrorCode } from "./errors.ts";
+import { formatSize } from "./format.ts";
+import { createFileCountProgress, createUploadProgress } from "./progress.ts";
 import type { OperationReporter } from "./project-operations.ts";
 import { getProjectTags } from "./tags.ts";
 import { Events, track } from "./telemetry.ts";
@@ -113,14 +116,42 @@ export async function deployCodeToManagedProject(
 			);
 		}
 
-		// Step 3: Package artifacts
-		reporter?.start("Packaging artifacts...");
-		pkg = await packageForDeploy(projectPath, buildOutput, config);
-		reporter?.stop();
+		// Step 3: Package artifacts with file-count progress
+		reporter?.stop(); // Stop reporter spinner, we'll use our own progress
+		const packagingProgress = createFileCountProgress({ label: "Packaging" });
+		packagingProgress.start();
+		pkg = await packageForDeploy({
+			projectPath,
+			buildOutput,
+			config,
+			onProgress: (current, total) => packagingProgress.update(current, total),
+		});
+		packagingProgress.complete();
 		reporter?.success("Packaged artifacts");
 
 		// Step 4: Upload to control plane
-		reporter?.start("Uploading to jack cloud...");
+		// Calculate total upload size for progress display
+		const fileSizes = await Promise.all([
+			stat(pkg.bundleZipPath).then((s) => s.size),
+			stat(pkg.sourceZipPath).then((s) => s.size),
+			stat(pkg.manifestPath).then((s) => s.size),
+			pkg.schemaPath ? stat(pkg.schemaPath).then((s) => s.size) : Promise.resolve(0),
+			pkg.secretsPath ? stat(pkg.secretsPath).then((s) => s.size) : Promise.resolve(0),
+			pkg.assetsZipPath ? stat(pkg.assetsZipPath).then((s) => s.size) : Promise.resolve(0),
+		]);
+		const totalUploadSize = fileSizes.reduce((sum, size) => sum + size, 0);
+		debug(`Upload size: ${formatSize(totalUploadSize)}`);
+
+		// Stop the reporter spinner - we'll use our own progress display
+		reporter?.stop();
+
+		// Use custom progress with pulsing bar (since fetch doesn't support upload progress)
+		const uploadProgress = createUploadProgress({
+			totalSize: totalUploadSize,
+			label: "Deploying to jack cloud",
+		});
+		uploadProgress.start();
+
 		const result = await uploadDeployment({
 			projectId,
 			bundleZipPath: pkg.bundleZipPath,
@@ -132,7 +163,7 @@ export async function deployCodeToManagedProject(
 			assetManifest: pkg.assetManifest ?? undefined,
 		});
 
-		reporter?.stop();
+		uploadProgress.complete();
 		reporter?.success("Deployed to jack cloud");
 
 		// Track success

package/src/lib/output.ts

@@ -2,6 +2,19 @@ import yoctoSpinner from "yocto-spinner";
 
 const isColorEnabled = !process.env.NO_COLOR && process.stderr.isTTY !== false;
 
+/**
+ * ANSI color codes for terminal output
+ */
+export const colors = {
+	green: isColorEnabled ? "\x1b[32m" : "",
+	red: isColorEnabled ? "\x1b[31m" : "",
+	yellow: isColorEnabled ? "\x1b[33m" : "",
+	cyan: isColorEnabled ? "\x1b[36m" : "",
+	dim: isColorEnabled ? "\x1b[90m" : "",
+	bold: isColorEnabled ? "\x1b[1m" : "",
+	reset: isColorEnabled ? "\x1b[0m" : "",
+};
+
 let currentSpinner: ReturnType<typeof yoctoSpinner> | null = null;
 
 /**
@@ -95,8 +108,10 @@ export function item(message: string): void {
 	console.error(`  ${message}`);
 }
 
-// Random neon purple for cyberpunk styling
-function getRandomPurple(): string {
+/**
+ * Random neon purple for cyberpunk styling
+ */
+export function getRandomPurple(): string {
 	const purples = [177, 165, 141, 129];
 	const colorCode = purples[Math.floor(Math.random() * purples.length)];
 	return `\x1b[38;5;${colorCode}m`;
@@ -117,12 +132,15 @@ export function box(title: string, lines: string[]): void {
 	const fill = "▓".repeat(innerWidth);
 	const gradient = "░".repeat(innerWidth);
 
+	// Pad plain text first, then apply colors (ANSI codes break padEnd calculation)
 	const pad = (text: string) => `  ${text.padEnd(maxLen)}  `;
+	const padTitle = (text: string) =>
+		`  ${bold}${text}${reset}${purple}${" ".repeat(maxLen - text.length)}  `;
 
 	console.error("");
 	console.error(`  ${purple}╔${bar}╗${reset}`);
 	console.error(`  ${purple}║${fill}║${reset}`);
-	console.error(`  ${purple}║${pad(bold + title + reset + purple)}║${reset}`);
+	console.error(`  ${purple}║${padTitle(title)}║${reset}`);
 	console.error(`  ${purple}║${"─".repeat(innerWidth)}║${reset}`);
 	for (const line of lines) {
 		console.error(`  ${purple}║${pad(line)}║${reset}`);

package/src/lib/progress.ts

@@ -0,0 +1,231 @@
+/**
+ * Progress tracker with delayed bar display
+ * Shows a simple spinner initially, then reveals a progress bar
+ * after a configurable delay (aligned with SPIRIT.md principles)
+ */
+
+import { formatSize } from "./format.ts";
+import { colors, getRandomPurple } from "./output.ts";
+
+export interface ProgressOptions {
+	total: number;
+	delayMs?: number;
+	barWidth?: number;
+	label?: string;
+}
+
+export interface UploadProgressOptions {
+	totalSize: number;
+	delayMs?: number;
+	barWidth?: number;
+	label?: string;
+}
+
+const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+/**
+ * Creates a progress tracker that shows a spinner initially,
+ * then reveals a progress bar after a delay.
+ *
+ * Usage:
+ *   const progress = createProgressTracker({ total: fileSize });
+ *   progress.start();
+ *   // ... during upload
+ *   progress.update(bytesUploaded);
+ *   // ... when done
+ *   progress.complete();
+ */
+export function createProgressTracker(options: ProgressOptions) {
+	const { total, delayMs = 2000, barWidth = 25, label = "Uploading" } = options;
+	const startTime = Date.now();
+	const purple = getRandomPurple(); // Pick color once at start
+	let frame = 0;
+	let intervalId: Timer | null = null;
+	let current = 0;
+
+	function render() {
+		const elapsed = Date.now() - startTime;
+		const pct = Math.min(Math.round((current / total) * 100), 100);
+
+		clearLine();
+
+		if (elapsed < delayMs) {
+			// Just spinner for first N seconds
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label}...`,
+			);
+		} else {
+			// Show progress bar after delay
+			const filled = Math.round((pct / 100) * barWidth);
+			const empty = barWidth - filled;
+			const bar = "▓".repeat(filled) + "░".repeat(empty);
+
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label} ${purple}[${bar}]${colors.reset} ${pct}% ${colors.dim}(${formatSize(current)} / ${formatSize(total)})${colors.reset}`,
+			);
+		}
+	}
+
+	return {
+		start() {
+			render();
+			intervalId = setInterval(render, 150);
+		},
+
+		update(bytes: number) {
+			current = bytes;
+		},
+
+		complete() {
+			if (intervalId) {
+				clearInterval(intervalId);
+				intervalId = null;
+			}
+			clearLine();
+		},
+	};
+}
+
+/**
+ * Creates an upload progress indicator for operations where we know the total
+ * size but can't track byte-level progress (e.g., fetch uploads).
+ *
+ * Shows spinner first, then after delay shows an animated bar with size info.
+ * The bar pulses to indicate activity without false progress claims.
+ */
+export function createUploadProgress(options: UploadProgressOptions) {
+	const { totalSize, delayMs = 2000, barWidth = 25, label = "Uploading" } = options;
+	const startTime = Date.now();
+	const purple = getRandomPurple(); // Pick color once at start
+	let frame = 0;
+	let pulsePos = 0;
+	let intervalId: Timer | null = null;
+
+	function render() {
+		const elapsed = Date.now() - startTime;
+		const elapsedSec = (elapsed / 1000).toFixed(1);
+
+		clearLine();
+
+		if (elapsed < delayMs) {
+			// Just spinner for first N seconds
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label}...`,
+			);
+		} else {
+			// Show pulsing bar after delay (indicates activity without false progress)
+			// Create pulsing effect - a bright section that moves across the bar
+			const pulseWidth = 5;
+			pulsePos = (pulsePos + 1) % (barWidth + pulseWidth);
+
+			let bar = "";
+			for (let i = 0; i < barWidth; i++) {
+				const distFromPulse = Math.abs(i - pulsePos);
+				if (distFromPulse < pulseWidth) {
+					bar += "▓";
+				} else {
+					bar += "░";
+				}
+			}
+
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label} ${purple}[${bar}]${colors.reset} ${colors.dim}${formatSize(totalSize)} • ${elapsedSec}s${colors.reset}`,
+			);
+		}
+	}
+
+	return {
+		start() {
+			if (process.stderr.isTTY) {
+				render();
+				intervalId = setInterval(render, 150);
+			}
+		},
+
+		complete() {
+			if (intervalId) {
+				clearInterval(intervalId);
+				intervalId = null;
+			}
+			clearLine();
+		},
+	};
+}
+
+export interface FileCountProgressOptions {
+	delayMs?: number;
+	barWidth?: number;
+	label?: string;
+}
+
+/**
+ * Creates a file-count progress indicator for operations where we know
+ * the total file count and can track per-file progress.
+ *
+ * Shows spinner first, then after delay shows progress bar with file count.
+ */
+export function createFileCountProgress(options: FileCountProgressOptions = {}) {
+	const { delayMs = 2000, barWidth = 25, label = "Packaging" } = options;
+	const startTime = Date.now();
+	const purple = getRandomPurple(); // Pick color once at start
+	let frame = 0;
+	let intervalId: Timer | null = null;
+	let current = 0;
+	let total = 0;
+
+	function render() {
+		const elapsed = Date.now() - startTime;
+
+		clearLine();
+
+		if (elapsed < delayMs) {
+			// Just spinner for first N seconds
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label}...`,
+			);
+		} else if (total > 0) {
+			// Show progress bar with file count after delay
+			const pct = Math.min(Math.round((current / total) * 100), 100);
+			const filled = Math.round((pct / 100) * barWidth);
+			const empty = barWidth - filled;
+			const bar = "▓".repeat(filled) + "░".repeat(empty);
+
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label} ${purple}[${bar}]${colors.reset} ${colors.dim}(${current}/${total} files)${colors.reset}`,
+			);
+		} else {
+			// No total yet, just show spinner
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label}...`,
+			);
+		}
+	}
+
+	return {
+		start() {
+			if (process.stderr.isTTY) {
+				render();
+				intervalId = setInterval(render, 150);
+			}
+		},
+
+		update(currentFile: number, totalFiles: number) {
+			current = currentFile;
+			total = totalFiles;
+		},
+
+		complete() {
+			if (intervalId) {
+				clearInterval(intervalId);
+				intervalId = null;
+			}
+			clearLine();
+		},
+	};
+}
+
+function clearLine() {
+	if (process.stderr.isTTY) {
+		process.stderr.write("\r\x1b[K");
+	}
+}

package/src/lib/project-list.ts

@@ -338,9 +338,14 @@ export function formatErrorSection(
 	);
 
 	for (const item of items) {
-		lines.push(formatProjectLine(item, { indent: 4, tagColorMap }));
+		// Don't show errorMessage inline - we'll show a summary hint below
+		lines.push(formatProjectLine(item, { indent: 4, tagColorMap, showUrl: false }));
 	}
 
+	// Add hint for resolving errors
+	lines.push("");
+	lines.push(`    ${colors.dim}Run 'jack projects cleanup' to remove stale links${colors.reset}`);
+
 	return lines.join("\n");
 }