@getjack/jack 0.1.19 → 0.1.22

package/package.json

@@ -1,13 +1,16 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.19",
+	"version": "0.1.22",
 	"description": "Ship before you forget why you started. The vibecoder's deployment CLI.",
 	"license": "Apache-2.0",
 	"type": "module",
 	"bin": {
 		"jack": "./src/index.ts"
 	},
-	"files": ["src", "templates"],
+	"files": [
+		"src",
+		"templates"
+	],
 	"engines": {
 		"bun": ">=1.0.0"
 	},

package/src/commands/down.ts

@@ -10,7 +10,8 @@ import { fetchProjectResources } from "../lib/control-plane.ts";
 import { promptSelect } from "../lib/hooks.ts";
 import { managedDown } from "../lib/managed-down.ts";
 import { error, info, item, output, success, warn } from "../lib/output.ts";
-import { type LocalProjectLink, readProjectLink } from "../lib/project-link.ts";
+import { unregisterPath } from "../lib/paths-index.ts";
+import { type LocalProjectLink, readProjectLink, unlinkProject } from "../lib/project-link.ts";
 import { resolveProject } from "../lib/project-resolver.ts";
 import { parseWranglerResources } from "../lib/resources.ts";
 import { deleteCloudProject, getProjectNameFromDir } from "../lib/storage/index.ts";
@@ -124,6 +125,15 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			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
+			}
 			return;
 		}
 

package/src/commands/init.ts

@@ -11,14 +11,27 @@ import { ensureAuth, ensureWrangler, isAuthenticated } from "../lib/wrangler.ts"
 
 export async function isInitialized(): Promise<boolean> {
 	const config = await readConfig();
-	if (!config?.initialized) return false;
-
-	// Check Jack Cloud auth first (most common path)
 	const { isLoggedIn } = await import("../lib/auth/store.ts");
-	if (await isLoggedIn()) return true;
 
-	// Fall back to wrangler/Cloudflare auth (BYO mode)
-	return await isAuthenticated();
+	if (config?.initialized) {
+		if ((await isLoggedIn()) || (await isAuthenticated())) return true;
+	}
+
+	// Auto-initialize if authenticated
+	const loggedIn = await isLoggedIn();
+	const wranglerAuth = !loggedIn && (await isAuthenticated());
+
+	if (loggedIn || wranglerAuth) {
+		await writeConfig({
+			version: 1,
+			initialized: true,
+			initializedAt: new Date().toISOString(),
+			...config,
+		});
+		return true;
+	}
+
+	return false;
 }
 
 interface InitOptions {

package/src/commands/new.ts

@@ -1,4 +1,10 @@
-import { getPreferredLaunchAgent, launchAgent } from "../lib/agents.ts";
+import {
+	getAgentDefinition,
+	getPreferredLaunchAgent,
+	launchAgent,
+	scanAgents,
+	updateAgent,
+} from "../lib/agents.ts";
 import { debug } from "../lib/debug.ts";
 import { getErrorDetails } from "../lib/errors.ts";
 import { promptSelect } from "../lib/hooks.ts";
@@ -120,9 +126,55 @@ export default async function newProject(
 				}
 			}
 		} else {
-			console.error("");
-			output.info("No launchable AI agent detected");
-			output.info("Run: jack agents scan");
+			// No agents configured - auto-scan and offer to open in detected agents
+			const detectionResult = await scanAgents();
+
+			if (detectionResult.detected.length > 0) {
+				// Auto-enable newly detected agents
+				for (const { id, path, launch } of detectionResult.detected) {
+					await updateAgent(id, {
+						active: true,
+						path,
+						detectedAt: new Date().toISOString(),
+						launch,
+					});
+				}
+
+				// Build menu options: detected agents + Skip
+				const menuOptions = detectionResult.detected.map(({ id }) => {
+					const definition = getAgentDefinition(id);
+					return definition?.name ?? id;
+				});
+				menuOptions.push("Skip");
+
+				console.error("");
+				console.error("  Open project in:");
+				console.error("");
+				const choice = await promptSelect(menuOptions);
+
+				// Launch selected agent (unless Skip or cancelled)
+				if (choice >= 0 && choice < detectionResult.detected.length) {
+					const selected = detectionResult.detected[choice];
+					const launchConfig = selected.launch;
+					if (launchConfig) {
+						const launchResult = await launchAgent(launchConfig, result.targetDir, {
+							projectName: result.projectName,
+							url: result.workerUrl,
+						});
+						if (!launchResult.success) {
+							const definition = getAgentDefinition(selected.id);
+							output.warn(`Failed to launch ${definition?.name ?? selected.id}`);
+							if (launchResult.command?.length) {
+								output.info(`Run manually: ${launchResult.command.join(" ")}`);
+							}
+						}
+					}
+				}
+			} else {
+				console.error("");
+				output.info("No AI agents detected");
+				output.info("Install Claude Code or Codex, then run: jack agents scan");
+			}
 		}
 	}
 }

package/src/commands/publish.ts

@@ -39,7 +39,7 @@ export default async function publish(): Promise<void> {
 		output.success(`Published as ${result.published_as}`);
 
 		console.error("");
-		output.info("Others can now fork your project:");
+		output.info("Share this project:");
 		output.info(`  ${result.fork_command}`);
 	} catch (err) {
 		spin.stop();

package/src/lib/agents.ts

@@ -434,7 +434,9 @@ export interface AgentLaunchContext {
 function buildInitialPrompt(context: AgentLaunchContext): string | null {
 	if (!context.url) return null;
 
-	return `[jack] Project "${context.projectName}" is live at ${context.url} - say hi and let's build!`;
+	return `Project "${context.projectName}" is live at ${context.url}
+
+Read CLAUDE.md and AGENTS.md for project context, then say hi and offer to help build.`;
 }
 
 function buildLaunchCommand(

package/src/lib/auth/ensure-auth.test.ts

@@ -210,9 +210,9 @@ describe("ensureAuthForCreate", () => {
 		});
 
 		it("throws error when both forceManaged and forceByo are set", async () => {
-			await expect(
-				ensureAuthForCreate({ forceManaged: true, forceByo: true }),
-			).rejects.toThrow("Cannot use both --managed and --byo flags");
+			await expect(ensureAuthForCreate({ forceManaged: true, forceByo: true })).rejects.toThrow(
+				"Cannot use both --managed and --byo flags",
+			);
 		});
 	});
 

package/src/lib/control-plane.ts

@@ -2,6 +2,9 @@
  * Control Plane API client for jack cloud
  */
 
+import { debug } from "./debug.ts";
+import { formatSize } from "./format.ts";
+
 const DEFAULT_CONTROL_API_URL = "https://control.getjack.org";
 
 export function getControlApiUrl(): string {
@@ -109,6 +112,9 @@ export async function createManagedProject(
 		requestBody.use_prebuilt = options.usePrebuilt;
 	}
 
+	debug("Creating managed project", { name, template: options?.template, usePrebuilt: options?.usePrebuilt });
+	const start = Date.now();
+
 	const response = await authFetch(`${getControlApiUrl()}/v1/projects`, {
 		method: "POST",
 		headers: {
@@ -118,6 +124,9 @@ export async function createManagedProject(
 		body: JSON.stringify(requestBody),
 	});
 
+	const duration = ((Date.now() - start) / 1000).toFixed(1);
+	debug(`Control plane response: ${response.status} (${duration}s)`);
+
 	if (!response.ok) {
 		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
 			message?: string;
@@ -586,10 +595,15 @@ export async function uploadSourceSnapshot(
 	const sourceFile = Bun.file(sourceZipPath);
 	formData.append("source", sourceFile);
 
-	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/source`, {
+	const url = `${getControlApiUrl()}/v1/projects/${projectId}/source`;
+	debug(`Source snapshot: ${formatSize(sourceFile.size)}`);
+
+	const start = Date.now();
+	const response = await authFetch(url, {
 		method: "POST",
 		body: formData,
 	});
+	debug(`Source snapshot: ${response.status} (${((Date.now() - start) / 1000).toFixed(1)}s)`);
 
 	if (!response.ok) {
 		const error = (await response.json().catch(() => ({ message: "Upload failed" }))) as {

package/src/lib/deploy-upload.ts

@@ -6,6 +6,8 @@ import { readFile } from "node:fs/promises";
 import type { AssetManifest } from "./asset-hash.ts";
 import { authFetch } from "./auth/index.ts";
 import { getControlApiUrl } from "./control-plane.ts";
+import { debug } from "./debug.ts";
+import { formatSize } from "./format.ts";
 
 export interface DeployUploadOptions {
 	projectId: string;
@@ -31,6 +33,9 @@ export interface DeployUploadResult {
  */
 export async function uploadDeployment(options: DeployUploadOptions): Promise<DeployUploadResult> {
 	const formData = new FormData();
+	let totalSize = 0;
+
+	const prepareStart = Date.now();
 
 	// Read files and add to form data
 	const manifestContent = await readFile(options.manifestPath);
@@ -39,17 +44,24 @@ export async function uploadDeployment(options: DeployUploadOptions): Promise<De
 		new Blob([manifestContent], { type: "application/json" }),
 		"manifest.json",
 	);
+	totalSize += manifestContent.length;
 
 	const bundleContent = await readFile(options.bundleZipPath);
 	formData.append("bundle", new Blob([bundleContent], { type: "application/zip" }), "bundle.zip");
+	totalSize += bundleContent.length;
+	debug(`  bundle.zip: ${formatSize(bundleContent.length)}`);
 
 	const sourceContent = await readFile(options.sourceZipPath);
 	formData.append("source", new Blob([sourceContent], { type: "application/zip" }), "source.zip");
+	totalSize += sourceContent.length;
+	debug(`  source.zip: ${formatSize(sourceContent.length)}`);
 
 	// Optional files
 	if (options.schemaPath) {
 		const schemaContent = await readFile(options.schemaPath);
 		formData.append("schema", new Blob([schemaContent], { type: "text/sql" }), "schema.sql");
+		totalSize += schemaContent.length;
+		debug(`  schema.sql: ${formatSize(schemaContent.length)}`);
 	}
 
 	if (options.secretsPath) {
@@ -59,27 +71,40 @@ export async function uploadDeployment(options: DeployUploadOptions): Promise<De
 			new Blob([secretsContent], { type: "application/json" }),
 			"secrets.json",
 		);
+		totalSize += secretsContent.length;
 	}
 
 	if (options.assetsZipPath) {
 		const assetsContent = await readFile(options.assetsZipPath);
 		formData.append("assets", new Blob([assetsContent], { type: "application/zip" }), "assets.zip");
+		totalSize += assetsContent.length;
+		debug(`  assets.zip: ${formatSize(assetsContent.length)}`);
 	}
 
 	if (options.assetManifest) {
+		const manifestJson = JSON.stringify(options.assetManifest);
 		formData.append(
 			"asset-manifest",
-			new Blob([JSON.stringify(options.assetManifest)], { type: "application/json" }),
+			new Blob([manifestJson], { type: "application/json" }),
 			"asset-manifest.json",
 		);
+		totalSize += manifestJson.length;
 	}
 
+	const prepareMs = Date.now() - prepareStart;
+	debug(`Payload ready: ${formatSize(totalSize)} (${prepareMs}ms)`);
+
 	// POST to control plane
 	const url = `${getControlApiUrl()}/v1/projects/${options.projectId}/deployments/upload`;
+	debug(`POST ${url}`);
+
+	const uploadStart = Date.now();
 	const response = await authFetch(url, {
 		method: "POST",
 		body: formData,
 	});
+	const uploadMs = Date.now() - uploadStart;
+	debug(`Response: ${response.status} (${(uploadMs / 1000).toFixed(1)}s)`);
 
 	if (!response.ok) {
 		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {

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

@@ -12,7 +12,7 @@ import { debug } from "./debug.ts";
 import { uploadDeployment } from "./deploy-upload.ts";
 import { JackError, JackErrorCode } from "./errors.ts";
 import { formatSize } from "./format.ts";
-import { createUploadProgress } from "./progress.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";
@@ -116,10 +116,17 @@ 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
@@ -141,7 +148,7 @@ export async function deployCodeToManagedProject(
 		// Use custom progress with pulsing bar (since fetch doesn't support upload progress)
 		const uploadProgress = createUploadProgress({
 			totalSize: totalUploadSize,
-			label: "Uploading to jack cloud",
+			label: "Deploying to jack cloud",
 		});
 		uploadProgress.start();