@getjack/jack 0.1.28 → 0.1.30

package/src/lib/telemetry-config.ts

@@ -4,12 +4,16 @@ import { join } from "node:path";
 import { CONFIG_DIR } from "./config.ts";
 
 /**
- * Telemetry configuration structure
+ * Telemetry configuration structure (v2)
  */
 export interface TelemetryConfig {
 	anonymousId: string; // UUID v4, generated once
 	enabled: boolean; // false if user opted out
-	version: number; // config schema version (start at 1)
+	version: number; // config schema version (2 for new configs)
+	// AARRR tracking fields
+	firstSeenAt: string; // ISO date when config was created
+	firstDeployAt?: string; // ISO date when first deploy succeeded
+	lastIdentifyDate?: string; // "YYYY-MM-DD" for dedupe
 }
 
 export const TELEMETRY_CONFIG_DIR = CONFIG_DIR;
@@ -37,13 +41,25 @@ async function ensureTelemetryConfigDir(): Promise<void> {
 }
 
 /**
- * Create a new telemetry config with generated anonymous ID
+ * Create a new telemetry config with generated anonymous ID (v2)
  */
 function createNewTelemetryConfig(): TelemetryConfig {
 	return {
 		anonymousId: crypto.randomUUID(),
 		enabled: true,
-		version: 1,
+		version: 2,
+		firstSeenAt: new Date().toISOString(),
+	};
+}
+
+/**
+ * Migrate v1 config to v2 by adding AARRR tracking fields
+ */
+function migrateV1ToV2(config: TelemetryConfig): TelemetryConfig {
+	return {
+		...config,
+		version: 2,
+		firstSeenAt: new Date().toISOString(), // Best approximation for existing users
 	};
 }
 
@@ -55,6 +71,19 @@ export async function loadOrCreateTelemetryConfig(): Promise<TelemetryConfig> {
 		const newConfig = createNewTelemetryConfig();
 		await ensureTelemetryConfigDir();
 		await Bun.write(TELEMETRY_CONFIG_PATH, JSON.stringify(newConfig, null, 2));
+
+		// Track install event for new users (fire-and-forget)
+		queueMicrotask(async () => {
+			try {
+				const { track, Events } = await import("./telemetry.ts");
+				track(Events.USER_INSTALLED, {
+					install_date: newConfig.firstSeenAt,
+				});
+			} catch {
+				// Ignore - telemetry should not break CLI
+			}
+		});
+
 		return newConfig;
 	}
 
@@ -68,6 +97,12 @@ export async function loadOrCreateTelemetryConfig(): Promise<TelemetryConfig> {
 			typeof config.enabled === "boolean" &&
 			typeof config.version === "number"
 		) {
+			// Migrate v1 configs to v2
+			if (config.version === 1) {
+				const migratedConfig = migrateV1ToV2(config as TelemetryConfig);
+				await Bun.write(TELEMETRY_CONFIG_PATH, JSON.stringify(migratedConfig, null, 2));
+				return migratedConfig;
+			}
 			return config as TelemetryConfig;
 		}
 		// Invalid config, regenerate
@@ -108,3 +143,14 @@ export async function setTelemetryEnabled(enabled: boolean): Promise<void> {
 	// Update cache
 	cachedTelemetryConfig = config;
 }
+
+/**
+ * Save telemetry config to disk
+ */
+export async function saveTelemetryConfig(config: TelemetryConfig): Promise<void> {
+	await ensureTelemetryConfigDir();
+	await Bun.write(TELEMETRY_CONFIG_PATH, JSON.stringify(config, null, 2));
+
+	// Update cache
+	cachedTelemetryConfig = config;
+}

package/src/lib/telemetry.ts

@@ -35,7 +35,15 @@ export const Events = {
 	AUTO_DETECT_REJECTED: "auto_detect_rejected",
 	// Service events
 	SERVICE_CREATED: "service_created",
+	SERVICE_DELETED: "service_deleted",
 	SQL_EXECUTED: "sql_executed",
+	// AARRR lifecycle events
+	USER_INSTALLED: "user_installed",
+	USER_ACTIVATED: "user_activated",
+	// BYO deploy events (parity with managed)
+	BYO_DEPLOY_STARTED: "byo_deploy_started",
+	BYO_DEPLOY_COMPLETED: "byo_deploy_completed",
+	BYO_DEPLOY_FAILED: "byo_deploy_failed",
 } as const;
 
 type EventName = (typeof Events)[keyof typeof Events];
@@ -121,7 +129,7 @@ export interface UserProperties {
 	config_style?: "byoc" | "jack-cloud";
 }
 
-// Detect environment properties
+// Detect environment properties (for user profile - stable properties)
 export function getEnvironmentProps(): Pick<
 	UserProperties,
 	"shell" | "terminal" | "terminal_width" | "is_tty" | "locale"
@@ -135,6 +143,25 @@ export function getEnvironmentProps(): Pick<
 	};
 }
 
+// ============================================
+// INVOCATION CONTEXT (per-event, not per-user)
+// ============================================
+export interface InvocationContext {
+	is_tty: boolean;
+	is_ci: boolean;
+	terminal?: string;
+	shell?: string;
+}
+
+export function getInvocationContext(): InvocationContext {
+	return {
+		is_tty: process.stdout.isTTY ?? false,
+		is_ci: !!process.env.CI,
+		terminal: process.env.TERM_PROGRAM,
+		shell: process.env.SHELL?.split("/").pop(),
+	};
+}
+
 export async function identify(properties: Partial<UserProperties>): Promise<void> {
 	userProps = { ...userProps, ...properties };
 	if (!(await isEnabled())) return;
@@ -203,11 +230,42 @@ export async function track(event: EventName, properties?: Record<string, unknow
 	}
 }
 
+export async function trackActivationIfFirst(deployMode: "managed" | "byo"): Promise<void> {
+	try {
+		const { getTelemetryConfig, saveTelemetryConfig } = await import("./telemetry-config.ts");
+		const config = await getTelemetryConfig();
+
+		// Already activated? Skip
+		if (config.firstDeployAt) {
+			return;
+		}
+
+		const now = new Date();
+		const firstSeen = config.firstSeenAt ? new Date(config.firstSeenAt) : now;
+		const daysToActivate = Math.floor(
+			(now.getTime() - firstSeen.getTime()) / (1000 * 60 * 60 * 24),
+		);
+
+		// Fire activation event
+		track(Events.USER_ACTIVATED, {
+			deploy_mode: deployMode,
+			days_to_activate: daysToActivate,
+		});
+
+		// Save activation timestamp
+		config.firstDeployAt = now.toISOString();
+		await saveTelemetryConfig(config);
+	} catch {
+		// Ignore - telemetry should not break CLI
+	}
+}
+
 // ============================================
 // WRAPPER
 // ============================================
 export interface TelemetryOptions {
 	platform?: "cli" | "mcp";
+	subcommand?: string;
 }
 
 // biome-ignore lint/suspicious/noExplicitAny: Required for flexible command wrapping
@@ -217,9 +275,16 @@ export function withTelemetry<T extends (...args: any[]) => Promise<any>>(
 	options?: TelemetryOptions,
 ): T {
 	const platform = options?.platform ?? "cli";
+	const subcommand = options?.subcommand;
 
 	return (async (...args: Parameters<T>) => {
-		track(Events.COMMAND_INVOKED, { command: commandName, platform });
+		const context = getInvocationContext();
+		track(Events.COMMAND_INVOKED, {
+			command: commandName,
+			platform,
+			...(subcommand && { subcommand }),
+			...context,
+		});
 		const start = Date.now();
 
 		try {
@@ -227,15 +292,19 @@ export function withTelemetry<T extends (...args: any[]) => Promise<any>>(
 			track(Events.COMMAND_COMPLETED, {
 				command: commandName,
 				platform,
+				...(subcommand && { subcommand }),
 				duration_ms: Date.now() - start,
+				...context,
 			});
 			return result;
 		} catch (error) {
 			track(Events.COMMAND_FAILED, {
 				command: commandName,
 				platform,
+				...(subcommand && { subcommand }),
 				error_type: classifyError(error),
 				duration_ms: Date.now() - start,
+				...context,
 			});
 			throw error;
 		}

package/src/lib/version-check.ts

@@ -87,9 +87,7 @@ function isNewerVersion(latest: string, current: string): boolean {
  * Returns the latest version if newer, null otherwise
  * @param skipCache - If true, bypass the cache and always fetch from npm
  */
-export async function checkForUpdate(
-	skipCache = false,
-): Promise<string | null> {
+export async function checkForUpdate(skipCache = false): Promise<string | null> {
 	const currentVersion = getCurrentVersion();
 	const now = Date.now();
 

package/src/lib/wrangler-config.test.ts

@@ -6,9 +6,9 @@
 
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { addD1Binding, getExistingD1Bindings, type D1BindingConfig } from "./wrangler-config.ts";
+import { join } from "node:path";
+import { type D1BindingConfig, addD1Binding, getExistingD1Bindings } from "./wrangler-config.ts";
 
 // ============================================================================
 // Test Helpers

package/src/lib/wrangler-config.ts

@@ -387,7 +387,7 @@ function findLastObjectEndInArray(content: string, startIndex: number, endIndex:
 function shouldAddCommaBefore(content: string): boolean {
 	// Strip trailing comments and whitespace to find last meaningful char
 	let i = content.length - 1;
-	let inLineComment = false;
+	const inLineComment = false;
 
 	// First pass: find where any trailing line comment starts
 	for (let j = content.length - 1; j >= 0; j--) {

package/src/lib/zip-packager.ts

@@ -54,9 +54,7 @@ export interface ManifestData {
 	};
 }
 
-export interface ZipProgressCallback {
-	(current: number, total: number): void;
-}
+export type ZipProgressCallback = (current: number, total: number) => void;
 
 /**
  * Creates a ZIP archive from source directory

package/src/mcp/tools/index.ts

@@ -1,9 +1,9 @@
 import type { Server as McpServer } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
-import { JackError, JackErrorCode } from "../../lib/errors.ts";
 import { authFetch } from "../../lib/auth/index.ts";
 import { getControlApiUrl, startLogSession } from "../../lib/control-plane.ts";
+import { JackError, JackErrorCode } from "../../lib/errors.ts";
 import { getDeployMode, getProjectId } from "../../lib/project-link.ts";
 import { createProject, deployProject, getProjectStatus } from "../../lib/project-operations.ts";
 import { listAllProjects } from "../../lib/project-resolver.ts";
@@ -15,6 +15,13 @@ import {
 	wrapResultsForMcp,
 } from "../../lib/services/db-execute.ts";
 import { listDatabases } from "../../lib/services/db-list.ts";
+import {
+	assignDomain,
+	connectDomain,
+	disconnectDomain,
+	listDomains,
+	unassignDomain,
+} from "../../lib/services/domain-operations.ts";
 import { createStorageBucket } from "../../lib/services/storage-create.ts";
 import { deleteStorageBucket } from "../../lib/services/storage-delete.ts";
 import { getStorageBucketInfo } from "../../lib/services/storage-info.ts";
@@ -189,6 +196,25 @@ const TailLogsSchema = z.object({
 		.describe("How long to listen before returning (default: 2000ms, max: 10000ms)"),
 });
 
+const ListDomainsSchema = z.object({});
+
+const ConnectDomainSchema = z.object({
+	hostname: z.string().describe("The domain hostname to connect (e.g., 'app.example.com')"),
+});
+
+const AssignDomainSchema = z.object({
+	hostname: z.string().describe("The domain hostname to assign"),
+	project_slug: z.string().describe("The project slug to assign the domain to"),
+});
+
+const UnassignDomainSchema = z.object({
+	hostname: z.string().describe("The domain hostname to unassign from its project"),
+});
+
+const DisconnectDomainSchema = z.object({
+	hostname: z.string().describe("The domain hostname to disconnect (fully remove)"),
+});
+
 export function registerTools(server: McpServer, _options: McpServerOptions, debug: DebugLogger) {
 	// Register tool list handler
 	server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -512,6 +538,79 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 						required: ["name"],
 					},
 				},
+				{
+					name: "list_domains",
+					description:
+						"List all custom domains for the current user, including their status and assigned projects.",
+					inputSchema: {
+						type: "object",
+						properties: {},
+					},
+				},
+				{
+					name: "connect_domain",
+					description:
+						"Reserve a custom domain slot. This is the first step before assigning the domain to a project.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							hostname: {
+								type: "string",
+								description: "The domain hostname to connect (e.g., 'app.example.com')",
+							},
+						},
+						required: ["hostname"],
+					},
+				},
+				{
+					name: "assign_domain",
+					description:
+						"Assign a reserved domain to a project. The domain must be connected first. Returns DNS verification instructions.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							hostname: {
+								type: "string",
+								description: "The domain hostname to assign",
+							},
+							project_slug: {
+								type: "string",
+								description: "The project slug to assign the domain to",
+							},
+						},
+						required: ["hostname", "project_slug"],
+					},
+				},
+				{
+					name: "unassign_domain",
+					description:
+						"Unassign a domain from its project, keeping the domain slot reserved for future use.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							hostname: {
+								type: "string",
+								description: "The domain hostname to unassign from its project",
+							},
+						},
+						required: ["hostname"],
+					},
+				},
+				{
+					name: "disconnect_domain",
+					description:
+						"Fully remove a domain, releasing the slot. Use this when you no longer need the domain.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							hostname: {
+								type: "string",
+								description: "The domain hostname to disconnect (fully remove)",
+							},
+						},
+						required: ["hostname"],
+					},
+				},
 			],
 		};
 	});
@@ -736,7 +835,12 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 
 					const wrappedTailLogs = withTelemetry(
 						"tail_logs",
-						async (id: string, label: string | undefined, maxEvents: number, durationMs: number) => {
+						async (
+							id: string,
+							label: string | undefined,
+							maxEvents: number,
+							durationMs: number,
+						) => {
 							const session = await startLogSession(id, label);
 							const streamUrl = `${getControlApiUrl()}${session.stream.url}`;
 
@@ -949,10 +1053,7 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 									return {
 										success: false,
 										error: err.message,
-										suggestion:
-											"Destructive operations (DROP, TRUNCATE, ALTER, DELETE without WHERE) " +
-											"must be run via CLI with explicit confirmation: " +
-											`jack services db execute "${sql.slice(0, 50)}..." --write`,
+										suggestion: `Destructive operations (DROP, TRUNCATE, ALTER, DELETE without WHERE) must be run via CLI with explicit confirmation: jack services db execute "${sql.slice(0, 50)}..." --write`,
 										risk_level: "destructive",
 									};
 								}
@@ -1250,7 +1351,9 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 							if (!info) {
 								throw new JackError(
 									JackErrorCode.RESOURCE_NOT_FOUND,
-									bucketName ? `Storage bucket '${bucketName}' not found` : "No storage buckets found",
+									bucketName
+										? `Storage bucket '${bucketName}' not found`
+										: "No storage buckets found",
 									"Use list_storage_buckets to see available buckets or create_storage_bucket to create one",
 								);
 							}
@@ -1312,6 +1415,157 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 					};
 				}
 
+				case "list_domains": {
+					ListDomainsSchema.parse(request.params.arguments ?? {});
+
+					const wrappedListDomains = withTelemetry(
+						"list_domains",
+						async () => {
+							const result = await listDomains();
+							return {
+								domains: result.domains.map((d) => ({
+									id: d.id,
+									hostname: d.hostname,
+									status: d.status,
+									ssl_status: d.ssl_status,
+									project_id: d.project_id,
+									project_slug: d.project_slug,
+									created_at: d.created_at,
+								})),
+								slots: result.slots,
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedListDomains();
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
+				case "connect_domain": {
+					const args = ConnectDomainSchema.parse(request.params.arguments ?? {});
+
+					const wrappedConnectDomain = withTelemetry(
+						"connect_domain",
+						async (hostname: string) => {
+							const result = await connectDomain(hostname);
+							return {
+								id: result.id,
+								hostname: result.hostname,
+								status: result.status,
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedConnectDomain(args.hostname);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
+				case "assign_domain": {
+					const args = AssignDomainSchema.parse(request.params.arguments ?? {});
+
+					const wrappedAssignDomain = withTelemetry(
+						"assign_domain",
+						async (hostname: string, projectSlug: string) => {
+							const result = await assignDomain(hostname, projectSlug);
+							return {
+								id: result.id,
+								hostname: result.hostname,
+								status: result.status,
+								ssl_status: result.ssl_status,
+								project_id: result.project_id,
+								project_slug: result.project_slug,
+								verification: result.verification,
+								ownership_verification: result.ownership_verification,
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedAssignDomain(args.hostname, args.project_slug);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
+				case "unassign_domain": {
+					const args = UnassignDomainSchema.parse(request.params.arguments ?? {});
+
+					const wrappedUnassignDomain = withTelemetry(
+						"unassign_domain",
+						async (hostname: string) => {
+							const result = await unassignDomain(hostname);
+							return {
+								id: result.id,
+								hostname: result.hostname,
+								status: result.status,
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedUnassignDomain(args.hostname);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
+				case "disconnect_domain": {
+					const args = DisconnectDomainSchema.parse(request.params.arguments ?? {});
+
+					const wrappedDisconnectDomain = withTelemetry(
+						"disconnect_domain",
+						async (hostname: string) => {
+							const result = await disconnectDomain(hostname);
+							return {
+								success: result.success,
+								hostname: result.hostname,
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedDisconnectDomain(args.hostname);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
 				default:
 					throw new Error(`Unknown tool: ${toolName}`);
 			}

package/src/templates/index.ts

@@ -10,7 +10,16 @@ import type { Template } from "./types";
 // Resolve templates directory relative to this file (src/templates -> templates)
 const TEMPLATES_DIR = join(dirname(dirname(import.meta.dir)), "templates");
 
-export const BUILTIN_TEMPLATES = ["hello", "miniapp", "api", "nextjs", "saas", "simple-api-starter", "ai-chat", "semantic-search"];
+export const BUILTIN_TEMPLATES = [
+	"hello",
+	"miniapp",
+	"api",
+	"nextjs",
+	"saas",
+	"simple-api-starter",
+	"ai-chat",
+	"semantic-search",
+];
 
 /**
  * Resolved template with origin tracking for lineage

package/templates/ai-chat/.jack.json

@@ -17,11 +17,7 @@
 			{
 				"action": "box",
 				"title": "{{name}}",
-				"lines": [
-					"{{url}}",
-					"",
-					"jack open  to view in browser"
-				]
+				"lines": ["{{url}}", "", "jack open  to view in browser"]
 			}
 		]
 	}