@getjack/jack 0.1.33 → 0.1.35

package/src/lib/schema.ts

@@ -4,6 +4,7 @@ import { $ } from "bun";
 import { debug } from "./debug.ts";
 import { parseJsonc } from "./jsonc.ts";
 import { output } from "./output.ts";
+import { findWranglerConfig } from "./wrangler-config.ts";
 
 /**
  * Execute schema.sql on a D1 database after deploy
@@ -47,9 +48,9 @@ export async function applySchema(bindingOrDbName: string, projectDir: string):
  * Check if project has D1 database configured (has d1_databases in wrangler config)
  */
 export async function hasD1Config(projectDir: string): Promise<boolean> {
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir);
 
-	if (!existsSync(wranglerPath)) {
+	if (!wranglerPath) {
 		return false;
 	}
 
@@ -71,9 +72,9 @@ export interface D1Binding {
  * Read D1 bindings from wrangler.jsonc
  */
 export async function getD1Bindings(projectDir: string): Promise<D1Binding[]> {
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir);
 
-	if (!existsSync(wranglerPath)) {
+	if (!wranglerPath) {
 		return [];
 	}
 
@@ -91,20 +92,15 @@ export async function getD1Bindings(projectDir: string): Promise<D1Binding[]> {
  * Returns the database_name field which is needed for wrangler d1 execute
  */
 export async function getD1DatabaseName(projectDir: string): Promise<string | null> {
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir);
 
-	if (!existsSync(wranglerPath)) {
+	if (!wranglerPath) {
 		return null;
 	}
 
 	try {
 		const content = await Bun.file(wranglerPath).text();
-		// Strip comments for parsing
-		// 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);
+		const config = parseJsonc<{ d1_databases?: { database_name?: string }[] }>(content);
 
 		return config.d1_databases?.[0]?.database_name || null;
 	} catch {

package/src/lib/services/db-create.ts

@@ -9,7 +9,7 @@ import { $ } from "bun";
 import { createProjectResource } from "../control-plane.ts";
 import { readProjectLink } from "../project-link.ts";
 import { getProjectNameFromDir } from "../storage/index.ts";
-import { addD1Binding, getExistingD1Bindings } from "../wrangler-config.ts";
+import { addD1Binding, findWranglerConfig, getExistingD1Bindings } from "../wrangler-config.ts";
 
 export interface CreateDatabaseOptions {
 	name?: string;
@@ -135,7 +135,7 @@ export async function createDatabase(
 	const projectName = await getProjectNameFromDir(projectDir);
 
 	// Get existing D1 bindings to determine naming
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir) ?? join(projectDir, "wrangler.jsonc");
 	const existingBindings = await getExistingD1Bindings(wranglerPath);
 	const existingCount = existingBindings.length;
 

package/src/lib/services/db-execute.ts

@@ -9,11 +9,14 @@
  */
 
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { $ } from "bun";
 import { type ExecuteSqlResponse, executeManagedSql } from "../control-plane.ts";
 import { readProjectLink } from "../project-link.ts";
-import { type D1BindingConfig, getExistingD1Bindings } from "../wrangler-config.ts";
+import {
+	type D1BindingConfig,
+	findWranglerConfig,
+	getExistingD1Bindings,
+} from "../wrangler-config.ts";
 import {
 	type ClassifiedStatement,
 	type RiskLevel,
@@ -98,9 +101,9 @@ export class DestructiveOperationError extends Error {
  * Get the first D1 database configured for a project
  */
 export async function getDefaultDatabase(projectDir: string): Promise<D1BindingConfig | null> {
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir);
 
-	if (!existsSync(wranglerPath)) {
+	if (!wranglerPath) {
 		return null;
 	}
 
@@ -119,9 +122,9 @@ export async function getDatabaseByName(
 	projectDir: string,
 	databaseName: string,
 ): Promise<D1BindingConfig | null> {
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir);
 
-	if (!existsSync(wranglerPath)) {
+	if (!wranglerPath) {
 		return null;
 	}
 

package/src/lib/services/db-list.ts

@@ -5,9 +5,8 @@
  * For managed projects, fetches metadata via control plane instead of wrangler.
  */
 
-import { join } from "node:path";
 import { readProjectLink } from "../project-link.ts";
-import { getExistingD1Bindings } from "../wrangler-config.ts";
+import { findWranglerConfig, getExistingD1Bindings } from "../wrangler-config.ts";
 import { getDatabaseInfo } from "./db.ts";
 
 export interface DatabaseListEntry {
@@ -25,9 +24,12 @@ export interface DatabaseListEntry {
  * For BYO projects: reads bindings from wrangler.jsonc and fetches metadata via wrangler.
  */
 export async function listDatabases(projectDir: string): Promise<DatabaseListEntry[]> {
-	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const wranglerPath = findWranglerConfig(projectDir);
+	if (!wranglerPath) {
+		return [];
+	}
 
-	// Get existing D1 bindings from wrangler.jsonc
+	// Get existing D1 bindings from wrangler config
 	const bindings = await getExistingD1Bindings(wranglerPath);
 
 	if (bindings.length === 0) {

package/src/lib/services/endpoint-test.ts

@@ -0,0 +1,275 @@
+/**
+ * Endpoint testing service
+ *
+ * Makes HTTP requests to deployed workers and optionally captures
+ * runtime logs during the request. Used by MCP (test_endpoint tool).
+ */
+
+import { readProjectLink } from "../project-link.ts";
+import { getProjectStatus } from "../project-operations.ts";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface TestEndpointOptions {
+	/** Path to project directory */
+	projectDir: string;
+	/** URL path to test, e.g. /api/todos */
+	path: string;
+	/** HTTP method */
+	method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+	/** Request headers */
+	headers?: Record<string, string>;
+	/** Request body (JSON string for POST/PUT/PATCH) */
+	body?: string;
+	/** Capture runtime logs during the request (managed mode only) */
+	includeLogs?: boolean;
+}
+
+export interface TestEndpointResult {
+	request: {
+		method: string;
+		url: string;
+		headers: Record<string, string>;
+		body: string | null;
+	};
+	response: {
+		status: number;
+		status_text: string;
+		headers: Record<string, string>;
+		body: string;
+		duration_ms: number;
+	};
+	logs: LogEntry[];
+}
+
+export interface LogEntry {
+	level: string;
+	message: unknown[];
+	timestamp: string;
+}
+
+// ============================================================================
+// Main Function
+// ============================================================================
+
+const REQUEST_TIMEOUT_MS = 30_000;
+const LOG_SETTLE_DELAY_MS = 500;
+const LOG_FLUSH_DELAY_MS = 1_500;
+const LOG_COLLECT_DURATION_MS = 3_000;
+const MAX_RESPONSE_BODY_SIZE = 1_000_000; // 1MB
+
+/**
+ * Test a deployed endpoint by making an HTTP request and optionally capturing logs.
+ */
+export async function testEndpoint(options: TestEndpointOptions): Promise<TestEndpointResult> {
+	const { projectDir, path, method = "GET", headers = {}, body, includeLogs = true } = options;
+
+	// 1. Resolve project URL
+	const link = await readProjectLink(projectDir);
+	const status = await getProjectStatus(undefined, projectDir);
+
+	if (!status?.workerUrl) {
+		throw new Error("Project has no deployed URL. Deploy first with 'jack ship'.");
+	}
+
+	const baseUrl = status.workerUrl.replace(/\/$/, "");
+	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+
+	// Validate path stays on the same origin (prevent URL manipulation)
+	const resolvedUrl = new URL(normalizedPath, baseUrl);
+	if (resolvedUrl.origin !== new URL(baseUrl).origin) {
+		throw new Error("Path must not redirect to a different host");
+	}
+	const fullUrl = resolvedUrl.href;
+
+	// 2. Optionally start log session (managed only)
+	let logSessionCleanup: (() => void) | null = null;
+	let logCollector: Promise<LogEntry[]> | null = null;
+
+	const isManaged = link?.deploy_mode === "managed" && link.project_id;
+	if (includeLogs && isManaged) {
+		const logResult = await startLogCollection(link.project_id);
+		logSessionCleanup = logResult.cleanup;
+		logCollector = logResult.collector;
+
+		// Small delay for SSE connection to establish
+		await sleep(LOG_SETTLE_DELAY_MS);
+	}
+
+	// 3. Make the HTTP request
+	const requestHeaders: Record<string, string> = { ...headers };
+	if (body && !requestHeaders["content-type"]) {
+		requestHeaders["content-type"] = "application/json";
+	}
+
+	const requestStart = Date.now();
+	let response: Response;
+	try {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+
+		response = await fetch(fullUrl, {
+			method,
+			headers: requestHeaders,
+			body: body || undefined,
+			signal: controller.signal,
+			redirect: "follow",
+		});
+
+		clearTimeout(timeout);
+	} catch (error) {
+		logSessionCleanup?.();
+		if (error instanceof Error && error.name === "AbortError") {
+			throw new Error(`Request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`);
+		}
+		throw new Error(`Request failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+
+	const durationMs = Date.now() - requestStart;
+
+	// 4. Read response + collect logs, ensuring cleanup on any failure
+	try {
+		const rawBody = await response.text();
+		// Truncate large responses to prevent MCP message bloat (1MB limit)
+		const responseBody =
+			rawBody.length > MAX_RESPONSE_BODY_SIZE
+				? `${rawBody.slice(0, MAX_RESPONSE_BODY_SIZE)}\n... [truncated, ${rawBody.length} bytes total]`
+				: rawBody;
+		const responseHeaders: Record<string, string> = {};
+		response.headers.forEach((value, key) => {
+			responseHeaders[key] = value;
+		});
+
+		// 5. Collect logs if started
+		let logs: LogEntry[] = [];
+		if (logCollector) {
+			// Wait for logs to flush from the worker
+			await sleep(LOG_FLUSH_DELAY_MS);
+			logSessionCleanup?.();
+			logSessionCleanup = null;
+			logs = await logCollector;
+		}
+
+		return {
+			request: {
+				method,
+				url: fullUrl,
+				headers: requestHeaders,
+				body: body ?? null,
+			},
+			response: {
+				status: response.status,
+				status_text: response.statusText,
+				headers: responseHeaders,
+				body: responseBody,
+				duration_ms: durationMs,
+			},
+			logs,
+		};
+	} finally {
+		// Ensure log session is always cleaned up
+		logSessionCleanup?.();
+	}
+}
+
+// ============================================================================
+// Internal Helpers
+// ============================================================================
+
+/**
+ * Start collecting logs from a managed project's SSE stream.
+ * Returns a collector promise that resolves with accumulated log entries
+ * and a cleanup function to stop the stream.
+ */
+async function startLogCollection(
+	projectId: string,
+): Promise<{ collector: Promise<LogEntry[]>; cleanup: () => void }> {
+	const { startLogSession, getControlApiUrl } = await import("../control-plane.ts");
+	const { authFetch } = await import("../auth/index.ts");
+
+	const session = await startLogSession(projectId, "endpoint-test");
+	const streamUrl = `${getControlApiUrl()}${session.stream.url}`;
+
+	const controller = new AbortController();
+	const cleanup = () => controller.abort();
+
+	const collector = collectLogEvents(streamUrl, controller, authFetch);
+
+	return { collector, cleanup };
+}
+
+/**
+ * Read log events from an SSE stream until aborted or timeout.
+ */
+async function collectLogEvents(
+	streamUrl: string,
+	controller: AbortController,
+	authFetch: (url: string, init?: RequestInit) => Promise<Response>,
+): Promise<LogEntry[]> {
+	const events: LogEntry[] = [];
+
+	// Auto-timeout for safety
+	const timeout = setTimeout(() => controller.abort(), LOG_COLLECT_DURATION_MS);
+
+	try {
+		const response = await authFetch(streamUrl, {
+			method: "GET",
+			headers: { Accept: "text/event-stream" },
+			signal: controller.signal,
+		});
+
+		if (!response.ok || !response.body) {
+			return events;
+		}
+
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+
+			for (const line of lines) {
+				if (!line.startsWith("data:")) continue;
+				const data = line.slice(5).trim();
+				if (!data) continue;
+
+				try {
+					const parsed = JSON.parse(data) as {
+						type?: string;
+						level?: string;
+						message?: unknown[];
+						timestamp?: string;
+					};
+					if (parsed.type === "event") {
+						events.push({
+							level: parsed.level ?? "log",
+							message: parsed.message ?? [],
+							timestamp: parsed.timestamp ?? new Date().toISOString(),
+						});
+					}
+				} catch {}
+			}
+		}
+	} catch (error) {
+		// Abort is normal (cleanup or timeout). Non-abort errors: return whatever we collected.
+		if (error instanceof Error && error.name !== "AbortError") {
+			// Silently swallow — partial logs are better than no response
+		}
+	} finally {
+		clearTimeout(timeout);
+	}
+
+	return events;
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/lib/services/project-delete.ts

@@ -0,0 +1,190 @@
+/**
+ * Project deletion service — shared between CLI (jack down --force) and MCP (delete_project).
+ *
+ * Handles both managed (control plane) and BYO (wrangler) deploy modes.
+ * Non-fatal failures (export, individual resource) populate warnings[], not thrown.
+ */
+
+import { mkdirSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import {
+	checkWorkerExists,
+	deleteDatabase,
+	deleteWorker,
+	exportDatabase,
+} from "../cloudflare-api.ts";
+import { getJackHome } from "../config.ts";
+import {
+	deleteManagedProject,
+	exportManagedDatabase,
+	fetchProjectResources,
+} from "../control-plane.ts";
+import { readProjectLink } from "../project-link.ts";
+import { parseWranglerResources } from "../resources.ts";
+import { getProjectNameFromDir } from "../storage/index.ts";
+
+export interface DeleteProjectOptions {
+	exportDatabase?: boolean;
+	exportDir?: string;
+}
+
+export interface DeleteProjectResult {
+	projectName: string;
+	deployMode: "managed" | "byo";
+	workerDeleted: boolean;
+	databaseDeleted: boolean;
+	databaseName: string | null;
+	databaseExportPath: string | null;
+	resourceResults?: Array<{ resource: string; success: boolean; error?: string }>;
+	warnings: string[];
+}
+
+export async function deleteProject(
+	projectDir: string,
+	options?: DeleteProjectOptions,
+): Promise<DeleteProjectResult> {
+	const exportDb = options?.exportDatabase ?? false;
+	const warnings: string[] = [];
+
+	const projectName = await getProjectNameFromDir(projectDir);
+	const link = await readProjectLink(projectDir);
+	const deployMode = link?.deploy_mode ?? "byo";
+
+	if (deployMode === "managed" && link) {
+		return deleteManagedFlow(link.project_id, projectName, projectDir, exportDb, options, warnings);
+	}
+
+	return deleteByoFlow(projectName, projectDir, exportDb, options, warnings);
+}
+
+async function deleteManagedFlow(
+	projectId: string,
+	projectName: string,
+	projectDir: string,
+	exportDb: boolean,
+	options: DeleteProjectOptions | undefined,
+	warnings: string[],
+): Promise<DeleteProjectResult> {
+	let databaseName: string | null = null;
+	let databaseExportPath: string | null = null;
+
+	// Resolve database name from control plane
+	try {
+		const resources = await fetchProjectResources(projectId);
+		const d1 = resources.find((r) => r.resource_type === "d1");
+		databaseName = d1?.resource_name ?? null;
+	} catch {
+		// Can't resolve — continue without DB info
+	}
+
+	// Optional export before deletion
+	if (exportDb && databaseName) {
+		const exportDir = options?.exportDir ?? projectDir ?? join(getJackHome(), projectName);
+		mkdirSync(exportDir, { recursive: true });
+		const exportPath = join(exportDir, `${projectName}-backup.sql`);
+
+		try {
+			const exportResult = await exportManagedDatabase(projectId);
+			const response = await fetch(exportResult.download_url);
+			if (!response.ok) {
+				throw new Error(`Failed to download export: ${response.statusText}`);
+			}
+			const sqlContent = await response.text();
+			await writeFile(exportPath, sqlContent, "utf-8");
+			databaseExportPath = exportPath;
+		} catch (err) {
+			warnings.push(`Database export failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+
+	// Delete everything via control plane
+	const result = await deleteManagedProject(projectId);
+
+	for (const resource of result.resources) {
+		if (!resource.success) {
+			warnings.push(`Failed to delete ${resource.resource}: ${resource.error}`);
+		}
+	}
+
+	return {
+		projectName,
+		deployMode: "managed",
+		workerDeleted: true,
+		databaseDeleted: databaseName !== null,
+		databaseName,
+		databaseExportPath,
+		resourceResults: result.resources,
+		warnings,
+	};
+}
+
+async function deleteByoFlow(
+	projectName: string,
+	projectDir: string,
+	exportDb: boolean,
+	options: DeleteProjectOptions | undefined,
+	warnings: string[],
+): Promise<DeleteProjectResult> {
+	let databaseName: string | null = null;
+	let databaseExportPath: string | null = null;
+	let databaseDeleted = false;
+	let workerDeleted = false;
+
+	// Resolve DB name from wrangler.jsonc
+	try {
+		const resources = await parseWranglerResources(projectDir);
+		databaseName = resources.d1?.name ?? null;
+	} catch {
+		// Can't parse — continue without DB info
+	}
+
+	// Optional export before deletion
+	if (exportDb && databaseName) {
+		const exportDir = options?.exportDir ?? projectDir ?? join(getJackHome(), projectName);
+		mkdirSync(exportDir, { recursive: true });
+		const exportPath = join(exportDir, `${databaseName}-backup.sql`);
+
+		try {
+			await exportDatabase(databaseName, exportPath);
+			databaseExportPath = exportPath;
+		} catch (err) {
+			warnings.push(`Database export failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+
+	// Delete worker
+	const workerExists = await checkWorkerExists(projectName);
+	if (workerExists) {
+		try {
+			await deleteWorker(projectName);
+			workerDeleted = true;
+		} catch (err) {
+			warnings.push(`Worker deletion failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	} else {
+		warnings.push(`Worker '${projectName}' not found — may already be deleted`);
+	}
+
+	// Delete database
+	if (databaseName) {
+		try {
+			await deleteDatabase(databaseName);
+			databaseDeleted = true;
+		} catch (err) {
+			warnings.push(
+				`Database deletion failed: ${err instanceof Error ? err.message : String(err)}`,
+			);
+		}
+	}
+
+	return {
+		projectName,
+		deployMode: "byo",
+		workerDeleted,
+		databaseDeleted,
+		databaseName,
+		databaseExportPath,
+		warnings,
+	};
+}