@getjack/jack 0.1.7 → 0.1.9

package/src/lib/project-detection.ts

@@ -297,9 +297,28 @@ export function detectProjectType(projectPath: string): DetectionResult {
 	if (viteConfig && hasDep(pkg, "vite")) {
 		configFiles.push(viteConfig);
 		detectedDeps.push("vite");
+
+		// Check for Vite + Worker hybrid pattern
+		// This is indicated by @cloudflare/vite-plugin AND a worker entry file
+		const hasCloudflarePlugin = hasDep(pkg, "@cloudflare/vite-plugin");
+		let workerEntry: string | null = null;
+
+		if (hasCloudflarePlugin) {
+			detectedDeps.push("@cloudflare/vite-plugin");
+			// Check common worker entry locations
+			const workerCandidates = ["src/worker.ts", "src/worker.js", "worker.ts", "worker.js"];
+			for (const candidate of workerCandidates) {
+				if (existsSync(join(projectPath, candidate))) {
+					workerEntry = candidate;
+					break;
+				}
+			}
+		}
+
 		return {
 			type: "vite",
 			configFile: viteConfig,
+			entryPoint: workerEntry || undefined,
 			detectedDeps,
 			configFiles,
 		};

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,
@@ -1047,22 +1047,22 @@ export async function createProject(
 
 		// Build first if needed (wrangler needs built assets)
 		if (await needsOpenNextBuild(targetDir)) {
-			reporter.start("Building...");
+			reporter.start("Building assets...");
 			try {
 				await runOpenNextBuild(targetDir);
 				reporter.stop();
-				reporter.success("Built");
+				reporter.success("Built assets");
 			} catch (err) {
 				reporter.stop();
 				reporter.error("Build failed");
 				throw err;
 			}
 		} else if (await needsViteBuild(targetDir)) {
-			reporter.start("Building...");
+			reporter.start("Building assets...");
 			try {
 				await runViteBuild(targetDir);
 				reporter.stop();
-				reporter.success("Built");
+				reporter.success("Built assets");
 			} catch (err) {
 				reporter.stop();
 				reporter.error("Build failed");
@@ -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 {
@@ -1237,9 +1242,11 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 	}
 
 	// Validate mode availability
-	const modeError = await validateModeAvailability(deployMode);
-	if (modeError) {
-		throw new JackError(JackErrorCode.VALIDATION_ERROR, modeError);
+	if (!dryRun) {
+		const modeError = await validateModeAvailability(deployMode);
+		if (modeError) {
+			throw new JackError(JackErrorCode.VALIDATION_ERROR, modeError);
+		}
 	}
 
 	let workerUrl: string | null = null;
@@ -1264,19 +1271,19 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		// (deployToManagedProject handles its own build, so only build here for dry-run)
 		if (dryRun) {
 			if (await needsOpenNextBuild(projectPath)) {
-				const buildSpin = reporter.spinner("Building...");
+				const buildSpin = reporter.spinner("Building assets...");
 				try {
 					await runOpenNextBuild(projectPath);
-					buildSpin.success("Built");
+					buildSpin.success("Built assets");
 				} catch (err) {
 					buildSpin.error("Build failed");
 					throw err;
 				}
 			} else if (await needsViteBuild(projectPath)) {
-				const buildSpin = reporter.spinner("Building...");
+				const buildSpin = reporter.spinner("Building assets...");
 				try {
 					await runViteBuild(projectPath);
-					buildSpin.success("Built");
+					buildSpin.success("Built assets");
 				} catch (err) {
 					buildSpin.error("Build failed");
 					throw err;
@@ -1302,19 +1309,19 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 
 		// Build first if needed (wrangler needs built assets)
 		if (await needsOpenNextBuild(projectPath)) {
-			const buildSpin = reporter.spinner("Building...");
+			const buildSpin = reporter.spinner("Building assets...");
 			try {
 				await runOpenNextBuild(projectPath);
-				buildSpin.success("Built");
+				buildSpin.success("Built assets");
 			} catch (err) {
 				buildSpin.error("Build failed");
 				throw err;
 			}
 		} else if (await needsViteBuild(projectPath)) {
-			const buildSpin = reporter.spinner("Building...");
+			const buildSpin = reporter.spinner("Building assets...");
 			try {
 				await runViteBuild(projectPath);
-				buildSpin.success("Built");
+				buildSpin.success("Built assets");
 			} catch (err) {
 				buildSpin.error("Build failed");
 				throw err;
@@ -1396,16 +1403,16 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		}
 	}
 
-	if (includeSync) {
+	if (includeSync && deployMode !== "byo") {
 		const syncConfig = await getSyncConfig();
 		if (syncConfig.enabled && syncConfig.autoSync) {
-			const syncSpin = reporter.spinner("Syncing source to cloud...");
+			const syncSpin = reporter.spinner("Syncing source to jack storage...");
 			try {
 				const syncResult = await syncToCloud(projectPath);
 				if (syncResult.success) {
 					if (syncResult.filesUploaded > 0 || syncResult.filesDeleted > 0) {
 						syncSpin.success(
-							`Backed up ${syncResult.filesUploaded} files to jack-storage/${projectName}/`,
+							`Synced source to jack storage (${syncResult.filesUploaded} uploaded, ${syncResult.filesDeleted} removed)`,
 						);
 					} else {
 						syncSpin.success("Source already synced");

package/src/lib/project-resolver.ts

@@ -179,6 +179,8 @@ export interface ResolveProjectOptions {
 	projectPath?: string;
 	/** Allow fallback lookup by managed project name when slug lookup fails */
 	matchByName?: boolean;
+	/** Prefer local .jack/project.json when resolving (default true) */
+	preferLocalLink?: boolean;
 }
 
 /**
@@ -225,9 +227,10 @@ export async function resolveProject(
 	let resolved: ResolvedProject | null = null;
 	const matchByName = options?.matchByName !== false;
 	const projectPath = options?.projectPath || process.cwd();
+	const preferLocalLink = options?.preferLocalLink ?? true;
 
 	// First, check if we're resolving from a local path with .jack/project.json
-	const link = await readProjectLink(projectPath);
+	const link = preferLocalLink ? await readProjectLink(projectPath) : null;
 
 	if (link) {
 		// We have a local link - start with that

package/src/lib/secrets.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { chmod, mkdir, stat } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { CONFIG_DIR } from "./config.ts";
 
 export interface SecretEntry {
 	value: string;
@@ -14,7 +14,6 @@ export interface SecretsFile {
 	secrets: Record<string, SecretEntry>;
 }
 
-const CONFIG_DIR = join(homedir(), ".config", "jack");
 const SECRETS_PATH = join(CONFIG_DIR, "secrets.json");
 
 /**

package/src/lib/telemetry-config.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { CONFIG_DIR } from "./config.ts";
 
 /**
  * Telemetry configuration structure
@@ -12,8 +12,8 @@ export interface TelemetryConfig {
 	version: number; // config schema version (start at 1)
 }
 
-export const TELEMETRY_CONFIG_DIR = join(homedir(), ".config", "jack");
-export const TELEMETRY_CONFIG_PATH = join(TELEMETRY_CONFIG_DIR, "telemetry.json");
+export const TELEMETRY_CONFIG_DIR = CONFIG_DIR;
+export const TELEMETRY_CONFIG_PATH = join(CONFIG_DIR, "telemetry.json");
 
 /**
  * Cached telemetry config for memoization

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

@@ -0,0 +1,113 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+export interface McpClientOptions {
+	command: string;
+	args?: string[];
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	clientName?: string;
+	clientVersion?: string;
+}
+
+export interface McpTestClient {
+	client: Client;
+	transport: StdioClientTransport;
+	getStderr(): string;
+	close(): Promise<void>;
+}
+
+export async function openMcpTestClient(options: McpClientOptions): Promise<McpTestClient> {
+	const transport = new StdioClientTransport({
+		command: options.command,
+		args: options.args ?? [],
+		cwd: options.cwd,
+		env: options.env as Record<string, string> | undefined,
+		stderr: "pipe",
+	});
+
+	let stderr = "";
+	transport.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString();
+	});
+
+	const client = new Client({
+		name: options.clientName ?? "jack-mcp-test",
+		version: options.clientVersion ?? "0.1.0",
+	});
+
+	try {
+		await client.connect(transport);
+	} catch (error) {
+		await transport.close();
+		throw error;
+	}
+
+	return {
+		client,
+		transport,
+		getStderr: () => stderr,
+		close: () => transport.close(),
+	};
+}
+
+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) {
+		throw new Error("MCP tool response missing text content");
+	}
+
+	const parsed = JSON.parse(toolText);
+	if (!parsed.success) {
+		const message = parsed.error?.message ?? "unknown error";
+		throw new Error(`MCP tool failed: ${message}`);
+	}
+
+	return parsed.data;
+}
+
+export async function verifyMcpToolsAndResources(client: Client): Promise<void> {
+	const tools = await client.listTools();
+	if (!tools.tools?.length) {
+		throw new Error("MCP server reported no tools");
+	}
+
+	const resources = await client.listResources();
+	if (!resources.resources?.length) {
+		throw new Error("MCP server reported no resources");
+	}
+
+	await client.readResource({ uri: "agents://context" });
+}
+
+export async function callMcpListProjects(
+	client: Client,
+	filter?: "all" | "local" | "deployed" | "cloud",
+): Promise<unknown[]> {
+	const response = await client.callTool({
+		name: "list_projects",
+		arguments: filter ? { filter } : {},
+	});
+
+	const data = parseMcpToolResult(response);
+	if (!Array.isArray(data)) {
+		throw new Error("MCP list_projects returned unexpected data");
+	}
+
+	return data;
+}
+
+export async function callMcpGetProjectStatus(
+	client: Client,
+	args: { name?: string; project_path?: string },
+): Promise<unknown> {
+	const response = await client.callTool({
+		name: "get_project_status",
+		arguments: args,
+	});
+
+	return parseMcpToolResult(response);
+}

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
 		}