@getjack/jack 0.1.2 → 0.1.3

package/src/lib/resources.ts

@@ -0,0 +1,196 @@
+/**
+ * Resource types and utilities for Jack CLI
+ *
+ * Resources are fetched on-demand from control plane (managed)
+ * or parsed from wrangler.jsonc (BYO).
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { parseJsonc } from "./jsonc.ts";
+
+// Resource types matching control plane schema
+export type ResourceType =
+	| "worker"
+	| "d1"
+	| "r2_content"
+	| "kv"
+	| "queue"
+	| "ai"
+	| "hyperdrive"
+	| "vectorize";
+
+// Resource from control plane API
+export interface ControlPlaneResource {
+	id: string;
+	project_id: string;
+	resource_type: ResourceType;
+	resource_name: string;
+	provider_id: string;
+	status: "active" | "provisioning" | "error" | "deleted";
+	metadata?: Record<string, unknown>;
+	created_at: string;
+}
+
+// Unified resource view (used by CLI)
+export interface ResolvedResources {
+	d1?: { binding: string; name: string; id?: string };
+	ai?: { binding: string };
+	assets?: { binding: string; directory: string };
+	kv?: Array<{ binding: string; id: string; name?: string }>;
+	r2?: Array<{ binding: string; name: string }>;
+	queues?: Array<{ binding: string; name: string }>;
+	vars?: Record<string, string>;
+}
+
+/**
+ * Convert control plane resources to unified format
+ */
+export function convertControlPlaneResources(resources: ControlPlaneResource[]): ResolvedResources {
+	const result: ResolvedResources = {};
+
+	for (const r of resources) {
+		switch (r.resource_type) {
+			case "d1":
+				result.d1 = {
+					binding: "DB",
+					name: r.resource_name,
+					id: r.provider_id,
+				};
+				break;
+			case "kv":
+				result.kv = result.kv || [];
+				result.kv.push({
+					binding: r.resource_name.toUpperCase().replace(/-/g, "_"),
+					id: r.provider_id,
+					name: r.resource_name,
+				});
+				break;
+			case "r2_content":
+				result.r2 = result.r2 || [];
+				result.r2.push({
+					binding: "BUCKET",
+					name: r.resource_name,
+				});
+				break;
+			// AI doesn't need provider_id, just indicates it's available
+			case "ai":
+				result.ai = { binding: "AI" };
+				break;
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Parse resources from wrangler.jsonc for BYO projects.
+ * Returns a unified resource view.
+ */
+export async function parseWranglerResources(projectPath: string): Promise<ResolvedResources> {
+	const wranglerPath = join(projectPath, "wrangler.jsonc");
+
+	if (!existsSync(wranglerPath)) {
+		return {};
+	}
+
+	try {
+		// Read and parse JSONC (strip comments)
+		const content = await Bun.file(wranglerPath).text();
+		const config = parseJsonc<WranglerConfig>(content);
+
+		const resources: ResolvedResources = {};
+
+		// D1 databases
+		if (config.d1_databases?.[0]) {
+			const d1 = config.d1_databases[0];
+			resources.d1 = {
+				binding: d1.binding || "DB",
+				name: d1.database_name || d1.binding || "DB",
+				id: d1.database_id,
+			};
+		}
+
+		// AI binding
+		if (config.ai) {
+			resources.ai = {
+				binding: config.ai.binding || "AI",
+			};
+		}
+
+		// Assets
+		if (config.assets?.directory) {
+			resources.assets = {
+				binding: config.assets.binding || "ASSETS",
+				directory: config.assets.directory,
+			};
+		}
+
+		// KV namespaces
+		if (config.kv_namespaces && config.kv_namespaces.length > 0) {
+			resources.kv = config.kv_namespaces.map((kv) => ({
+				binding: kv.binding,
+				id: kv.id,
+			}));
+		}
+
+		// R2 buckets
+		if (config.r2_buckets && config.r2_buckets.length > 0) {
+			resources.r2 = config.r2_buckets.map((r2) => ({
+				binding: r2.binding,
+				name: r2.bucket_name,
+			}));
+		}
+
+		// Queues
+		if (config.queues?.producers && config.queues.producers.length > 0) {
+			resources.queues = config.queues.producers.map((q) => ({
+				binding: q.binding,
+				name: q.queue,
+			}));
+		}
+
+		// Environment variables (vars)
+		if (config.vars && Object.keys(config.vars).length > 0) {
+			resources.vars = config.vars;
+		}
+
+		return resources;
+	} catch {
+		// Failed to parse, return empty
+		return {};
+	}
+}
+
+/**
+ * Wrangler config shape (partial, for resource parsing)
+ */
+interface WranglerConfig {
+	d1_databases?: Array<{
+		binding: string;
+		database_name?: string;
+		database_id?: string;
+	}>;
+	ai?: {
+		binding?: string;
+	};
+	assets?: {
+		binding?: string;
+		directory: string;
+	};
+	kv_namespaces?: Array<{
+		binding: string;
+		id: string;
+	}>;
+	r2_buckets?: Array<{
+		binding: string;
+		bucket_name: string;
+	}>;
+	queues?: {
+		producers?: Array<{
+			binding: string;
+			queue: string;
+		}>;
+	};
+	vars?: Record<string, string>;
+}

package/src/lib/schema.ts

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { $ } from "bun";
 import { debug } from "./debug.ts";
+import { parseJsonc } from "./jsonc.ts";
 import { output } from "./output.ts";
 
 /**
@@ -60,6 +61,31 @@ export async function hasD1Config(projectDir: string): Promise<boolean> {
 	}
 }
 
+export interface D1Binding {
+	binding?: string;
+	database_id?: string;
+	database_name?: string;
+}
+
+/**
+ * Read D1 bindings from wrangler.jsonc
+ */
+export async function getD1Bindings(projectDir: string): Promise<D1Binding[]> {
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+
+	if (!existsSync(wranglerPath)) {
+		return [];
+	}
+
+	try {
+		const content = await Bun.file(wranglerPath).text();
+		const config = parseJsonc(content) as { d1_databases?: D1Binding[] };
+		return Array.isArray(config.d1_databases) ? config.d1_databases : [];
+	} catch {
+		return [];
+	}
+}
+
 /**
  * Get the D1 database name from wrangler config
  * Returns the database_name field which is needed for wrangler d1 execute
@@ -74,7 +100,10 @@ export async function getD1DatabaseName(projectDir: string): Promise<string | nu
 	try {
 		const content = await Bun.file(wranglerPath).text();
 		// Strip comments for parsing
-		const cleaned = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+		// Note: Only remove line comments at the start of a line to avoid breaking URLs
+		const cleaned = content
+			.replace(/\/\*[\s\S]*?\*\//g, "") // block comments
+			.replace(/^\s*\/\/.*$/gm, ""); // line comments at start of line only
 		const config = JSON.parse(cleaned);
 
 		return config.d1_databases?.[0]?.database_name || null;

package/src/lib/storage/file-filter.ts

@@ -43,6 +43,7 @@ export const DEFAULT_EXCLUDES: string[] = [
 	".env",
 	".env.*",
 	".dev.vars",
+	".secrets.json",
 	"*.log",
 	".DS_Store",
 	"dist/**",

package/src/lib/storage/index.ts

@@ -80,7 +80,11 @@ export async function getProjectNameFromDir(projectDir: string): Promise<string>
 	try {
 		const content = await Bun.file(jsoncPath).text();
 		// Remove comments and parse JSON
-		const jsonContent = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+		// Note: Only remove line comments at the start of a line (with optional whitespace)
+		// to avoid breaking URLs like https://example.com
+		const jsonContent = content
+			.replace(/\/\*[\s\S]*?\*\//g, "") // block comments
+			.replace(/^\s*\/\/.*$/gm, ""); // line comments at start of line only
 		const config = JSON.parse(jsonContent);
 		if (config.name) {
 			return config.name;

package/src/lib/telemetry.ts

@@ -16,6 +16,20 @@ export const Events = {
 	PROJECT_CREATED: "project_created",
 	DEPLOY_STARTED: "deploy_started",
 	CONFIG_CHANGED: "config_changed",
+
+	// Intent-driven creation events
+	INTENT_MATCHED: "intent_matched",
+	INTENT_NO_MATCH: "intent_no_match",
+	INTENT_CUSTOMIZATION_STARTED: "intent_customization_started",
+	INTENT_CUSTOMIZATION_COMPLETED: "intent_customization_completed",
+	INTENT_CUSTOMIZATION_FAILED: "intent_customization_failed",
+
+	// Deploy mode events
+	DEPLOY_MODE_SELECTED: "deploy_mode_selected",
+	MANAGED_PROJECT_CREATED: "managed_project_created",
+	MANAGED_DEPLOY_STARTED: "managed_deploy_started",
+	MANAGED_DEPLOY_COMPLETED: "managed_deploy_completed",
+	MANAGED_DEPLOY_FAILED: "managed_deploy_failed",
 } as const;
 
 type EventName = (typeof Events)[keyof typeof Events];

package/src/lib/tty.ts

@@ -0,0 +1,15 @@
+export function restoreTty(): void {
+	if (!process.stdin.isTTY) return;
+
+	try {
+		process.stdin.setRawMode(false);
+	} catch {
+		// Ignore if stdin does not support raw mode
+	}
+
+	process.stdin.pause();
+
+	if (process.stderr.isTTY) {
+		process.stderr.write("\x1b[?25h");
+	}
+}

package/src/lib/zip-packager.ts

@@ -0,0 +1,255 @@
+import { existsSync } from "node:fs";
+import { createWriteStream } from "node:fs";
+import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, relative } from "node:path";
+import archiver from "archiver";
+import { type AssetManifest, computeAssetHash } from "./asset-hash.ts";
+import type { BuildOutput, WranglerConfig } from "./build-helper.ts";
+import { scanProjectFiles } from "./storage/file-filter.ts";
+
+export interface ZipPackageResult {
+	bundleZipPath: string;
+	sourceZipPath: string;
+	manifestPath: string;
+	schemaPath: string | null;
+	secretsPath: string | null;
+	assetsZipPath: string | null;
+	assetManifest: AssetManifest | null;
+	cleanup: () => Promise<void>;
+}
+
+export interface ManifestData {
+	version: 1;
+	entrypoint: string;
+	compatibility_date: string;
+	compatibility_flags?: string[];
+	module_format: "esm";
+	assets_dir?: string;
+	built_at: string;
+	bindings?: {
+		d1?: { binding: string };
+		ai?: { binding: string };
+		assets?: {
+			binding: string;
+			directory: string;
+			not_found_handling?: "single-page-application" | "404-page" | "none";
+			html_handling?:
+				| "auto-trailing-slash"
+				| "force-trailing-slash"
+				| "drop-trailing-slash"
+				| "none";
+		};
+		vars?: Record<string, string>;
+	};
+}
+
+/**
+ * Creates a ZIP archive from source directory
+ * @param outputPath - Absolute path for output ZIP file
+ * @param sourceDir - Absolute path to directory to archive
+ * @param files - Optional list of specific files to include (relative to sourceDir)
+ * @returns Promise that resolves when ZIP is created
+ */
+async function createZipArchive(
+	outputPath: string,
+	sourceDir: string,
+	files?: string[],
+): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const output = createWriteStream(outputPath);
+		const archive = archiver("zip", { zlib: { level: 9 } });
+
+		output.on("close", () => resolve());
+		archive.on("error", (err) => reject(err));
+
+		archive.pipe(output);
+
+		if (files) {
+			// Add specific files
+			for (const file of files) {
+				const filePath = join(sourceDir, file);
+				archive.file(filePath, { name: file });
+			}
+		} else {
+			// Add entire directory
+			archive.directory(sourceDir, false);
+		}
+
+		archive.finalize();
+	});
+}
+
+/**
+ * Recursively collects all file paths in a directory
+ */
+async function collectAllFiles(dir: string, baseDir: string = dir): Promise<string[]> {
+	const entries = await readdir(dir, { withFileTypes: true });
+	const files: string[] = [];
+
+	for (const entry of entries) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...(await collectAllFiles(fullPath, baseDir)));
+		} else if (entry.isFile()) {
+			files.push(fullPath);
+		}
+	}
+
+	return files;
+}
+
+/**
+ * Creates an asset manifest for all files in a directory.
+ * Maps paths starting with "/" (e.g., "/index.html", "/assets/app.js")
+ * to their content-addressable hashes.
+ *
+ * @param assetsDir - Absolute path to the assets directory
+ * @returns Asset manifest mapping paths to hash entries
+ */
+export async function createAssetManifest(assetsDir: string): Promise<AssetManifest> {
+	const allFiles = await collectAllFiles(assetsDir);
+
+	const entries = await Promise.all(
+		allFiles.map(async (filePath) => {
+			const content = await readFile(filePath);
+			const hash = await computeAssetHash(new Uint8Array(content), filePath);
+			const fileStats = await stat(filePath);
+			const relativePath = "/" + relative(assetsDir, filePath);
+			return [relativePath, { hash, size: fileStats.size }] as const;
+		}),
+	);
+
+	return Object.fromEntries(entries);
+}
+
+/**
+ * Extracts binding intent from wrangler config for the manifest.
+ * Returns undefined if no bindings are configured.
+ */
+function extractBindingsFromConfig(config?: WranglerConfig): ManifestData["bindings"] | undefined {
+	if (!config) return undefined;
+
+	const bindings: NonNullable<ManifestData["bindings"]> = {};
+
+	// Extract D1 database binding (use first one if multiple)
+	if (config.d1_databases && config.d1_databases.length > 0) {
+		const firstDb = config.d1_databases[0];
+		if (firstDb) {
+			bindings.d1 = { binding: firstDb.binding };
+		}
+	}
+
+	// Extract AI binding (default binding name: "AI")
+	if (config.ai) {
+		bindings.ai = { binding: config.ai.binding || "AI" };
+	}
+
+	// Extract assets binding (defaults: binding="ASSETS", directory="./dist")
+	if (config.assets) {
+		bindings.assets = {
+			binding: config.assets.binding || "ASSETS",
+			directory: config.assets.directory || "./dist",
+			not_found_handling: config.assets.not_found_handling,
+			html_handling: config.assets.html_handling,
+		};
+	}
+
+	// Extract vars
+	if (config.vars && Object.keys(config.vars).length > 0) {
+		bindings.vars = config.vars;
+	}
+
+	// Return undefined if no bindings were extracted
+	return Object.keys(bindings).length > 0 ? bindings : undefined;
+}
+
+/**
+ * Packages a built project for deployment to jack cloud
+ * @param projectPath - Absolute path to project directory
+ * @param buildOutput - Build output from buildProject()
+ * @param config - Optional wrangler config to extract binding intent
+ * @returns Package result with ZIP paths and cleanup function
+ */
+export async function packageForDeploy(
+	projectPath: string,
+	buildOutput: BuildOutput,
+	config?: WranglerConfig,
+): Promise<ZipPackageResult> {
+	// Create temp directory for package artifacts
+	const packageId = `jack-package-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+	const packageDir = join(tmpdir(), packageId);
+	await mkdir(packageDir, { recursive: true });
+
+	// Define artifact paths
+	const bundleZipPath = join(packageDir, "bundle.zip");
+	const sourceZipPath = join(packageDir, "source.zip");
+	const manifestPath = join(packageDir, "manifest.json");
+
+	// 1. Create bundle.zip from build output directory
+	await createZipArchive(bundleZipPath, buildOutput.outDir);
+
+	// 2. Create source.zip from project files (filtered)
+	const projectFiles = await scanProjectFiles(projectPath);
+	const sourceFiles = projectFiles.map((f) => f.path);
+	await createZipArchive(sourceZipPath, projectPath, sourceFiles);
+
+	// 3. Create manifest.json
+	const manifest: ManifestData = {
+		version: 1,
+		entrypoint: buildOutput.entrypoint,
+		compatibility_date: buildOutput.compatibilityDate,
+		compatibility_flags:
+			buildOutput.compatibilityFlags.length > 0 ? buildOutput.compatibilityFlags : undefined,
+		module_format: "esm",
+		assets_dir: buildOutput.assetsDir ? "assets" : undefined,
+		built_at: new Date().toISOString(),
+		bindings: extractBindingsFromConfig(config),
+	};
+
+	await Bun.write(manifestPath, JSON.stringify(manifest, null, 2));
+
+	// 4. Check for optional files (schema.sql and .secrets.json)
+	let schemaPath: string | null = null;
+	const schemaSrcPath = join(projectPath, "schema.sql");
+	if (existsSync(schemaSrcPath)) {
+		schemaPath = join(packageDir, "schema.sql");
+		await Bun.write(schemaPath, await readFile(schemaSrcPath));
+	}
+
+	let secretsPath: string | null = null;
+	const secretsSrcPath = join(projectPath, ".secrets.json");
+	if (existsSync(secretsSrcPath)) {
+		secretsPath = join(packageDir, ".secrets.json");
+		await Bun.write(secretsPath, await readFile(secretsSrcPath));
+	}
+
+	// 5. If assets directory exists, create assets.zip and asset manifest
+	let assetsZipPath: string | null = null;
+	let assetManifest: AssetManifest | null = null;
+	if (buildOutput.assetsDir) {
+		// Create zip and manifest in parallel for speed
+		const [, manifest] = await Promise.all([
+			createZipArchive(join(packageDir, "assets.zip"), buildOutput.assetsDir),
+			createAssetManifest(buildOutput.assetsDir),
+		]);
+		assetsZipPath = join(packageDir, "assets.zip");
+		assetManifest = manifest;
+	}
+
+	// Return package result with cleanup function
+	return {
+		bundleZipPath,
+		sourceZipPath,
+		manifestPath,
+		schemaPath,
+		secretsPath,
+		assetsZipPath,
+		assetManifest,
+		cleanup: async () => {
+			await rm(packageDir, { recursive: true, force: true });
+			// Also cleanup build output directory
+			await rm(buildOutput.outDir, { recursive: true, force: true });
+		},
+	};
+}

package/src/mcp/resources/index.ts

@@ -5,11 +5,16 @@ import {
 	ListResourcesRequestSchema,
 	ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
-import type { McpServerOptions } from "../types.ts";
+import type { DebugLogger, McpServerOptions } from "../types.ts";
 
-export function registerResources(server: McpServer, options: McpServerOptions) {
+export function registerResources(
+	server: McpServer,
+	options: McpServerOptions,
+	debug: DebugLogger,
+) {
 	// Register resource list handler
 	server.setRequestHandler(ListResourcesRequestSchema, async () => {
+		debug("resources/list requested");
 		return {
 			resources: [
 				{
@@ -26,6 +31,7 @@ export function registerResources(server: McpServer, options: McpServerOptions)
 	// Register resource read handler
 	server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
 		const uri = request.params.uri;
+		debug("resources/read requested", { uri });
 
 		if (uri === "agents://context") {
 			const projectPath = options.projectPath ?? process.cwd();

package/src/mcp/server.ts

@@ -5,7 +5,25 @@ import { registerResources } from "./resources/index.ts";
 import { registerTools } from "./tools/index.ts";
 import type { McpServerOptions } from "./types.ts";
 
+/**
+ * Debug logger that writes to stderr (doesn't interfere with stdio MCP protocol)
+ */
+export function createDebugLogger(enabled: boolean) {
+	return (message: string, data?: unknown) => {
+		if (!enabled) return;
+		const timestamp = new Date().toISOString();
+		const line = data
+			? `[jack-mcp ${timestamp}] ${message}: ${JSON.stringify(data)}`
+			: `[jack-mcp ${timestamp}] ${message}`;
+		console.error(line);
+	};
+}
+
 export async function createMcpServer(options: McpServerOptions = {}) {
+	const debug = createDebugLogger(options.debug ?? false);
+
+	debug("Creating MCP server", { version: pkg.version, options });
+
 	const server = new McpServer(
 		{
 			name: "jack",
@@ -19,14 +37,24 @@ export async function createMcpServer(options: McpServerOptions = {}) {
 		},
 	);
 
-	registerTools(server, options);
-	registerResources(server, options);
+	registerTools(server, options, debug);
+	registerResources(server, options, debug);
 
-	return server;
+	return { server, debug };
 }
 
 export async function startMcpServer(options: McpServerOptions = {}) {
-	const server = await createMcpServer(options);
+	const { server, debug } = await createMcpServer(options);
 	const transport = new StdioServerTransport();
+
+	debug("Starting MCP server on stdio transport");
+
+	// Always log startup to stderr so user knows it's running
+	console.error(
+		`[jack-mcp] Server started (v${pkg.version})${options.debug ? " [debug mode]" : ""}`,
+	);
+
 	await server.connect(transport);
+
+	debug("MCP server connected and ready");
 }