@getjack/jack 0.1.2 → 0.1.4

package/src/commands/mcp.ts

@@ -1,18 +1,145 @@
-import { error, info } from "../lib/output.ts";
+import { spawn } from "node:child_process";
+import { error, info, success } from "../lib/output.ts";
 import { startMcpServer } from "../mcp/server.ts";
 
 interface McpOptions {
 	project?: string;
+	debug?: boolean;
 }
 
 export default async function mcp(subcommand?: string, options: McpOptions = {}): Promise<void> {
-	if (subcommand !== "serve") {
-		error("Unknown subcommand. Use: jack mcp serve");
-		info("Usage: jack mcp serve [--project /path/to/project]");
-		process.exit(1);
+	if (subcommand === "serve") {
+		await startMcpServer({
+			projectPath: options.project,
+			debug: options.debug,
+		});
+		return;
+	}
+
+	if (subcommand === "test") {
+		await testMcpServer();
+		return;
 	}
 
-	await startMcpServer({
-		projectPath: options.project,
+	error("Unknown subcommand. Use: jack mcp serve or jack mcp test");
+	info("Usage:");
+	info("  jack mcp serve [--project /path] [--debug]  Start MCP server");
+	info("  jack mcp test                               Test MCP server connectivity");
+	process.exit(1);
+}
+
+/**
+ * Test MCP server by spawning it and sending test requests
+ */
+async function testMcpServer(): Promise<void> {
+	info("Testing MCP server...\n");
+
+	const proc = spawn("./src/index.ts", ["mcp", "serve"], {
+		stdio: ["pipe", "pipe", "pipe"],
 	});
+
+	const results: { test: string; passed: boolean; error?: string }[] = [];
+
+	const sendRequest = (id: number, method: string, params: object = {}): Promise<unknown> => {
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => reject(new Error("Timeout")), 10000);
+
+			const handler = (data: Buffer) => {
+				const lines = data.toString().split("\n").filter(Boolean);
+				for (const line of lines) {
+					try {
+						const response = JSON.parse(line);
+						if (response.id === id) {
+							clearTimeout(timeout);
+							proc.stdout.off("data", handler);
+							if (response.error) {
+								reject(new Error(response.error.message));
+							} else {
+								resolve(response.result);
+							}
+						}
+					} catch {
+						// Not JSON, ignore
+					}
+				}
+			};
+
+			proc.stdout.on("data", handler);
+			proc.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params, id })}\n`);
+		});
+	};
+
+	try {
+		// Test 1: Initialize
+		info("1. Testing initialize...");
+		const initResult = (await sendRequest(1, "initialize", {
+			protocolVersion: "2024-11-05",
+			capabilities: {},
+			clientInfo: { name: "jack-mcp-test", version: "1.0" },
+		})) as { serverInfo?: { name: string; version: string } };
+		if (initResult?.serverInfo?.name === "jack") {
+			results.push({ test: "initialize", passed: true });
+			success(`   ✓ Server info: ${initResult.serverInfo.name} v${initResult.serverInfo.version}`);
+		} else {
+			results.push({ test: "initialize", passed: false, error: "Invalid response" });
+		}
+
+		// Test 2: List tools
+		info("2. Testing tools/list...");
+		const toolsResult = (await sendRequest(2, "tools/list")) as { tools?: { name: string }[] };
+		const toolNames = toolsResult?.tools?.map((t) => t.name) ?? [];
+		if (toolNames.length > 0) {
+			results.push({ test: "tools/list", passed: true });
+			success(`   ✓ Found ${toolNames.length} tools: ${toolNames.join(", ")}`);
+		} else {
+			results.push({ test: "tools/list", passed: false, error: "No tools found" });
+		}
+
+		// Test 3: List resources
+		info("3. Testing resources/list...");
+		const resourcesResult = (await sendRequest(3, "resources/list")) as {
+			resources?: { name: string }[];
+		};
+		const resourceCount = resourcesResult?.resources?.length ?? 0;
+		results.push({ test: "resources/list", passed: true });
+		success(`   ✓ Found ${resourceCount} resource(s)`);
+
+		// Test 4: Call list_projects tool
+		info("4. Testing tools/call (list_projects)...");
+		const callResult = (await sendRequest(4, "tools/call", {
+			name: "list_projects",
+			arguments: {},
+		})) as { content?: { text: string }[] };
+		const responseText = callResult?.content?.[0]?.text;
+		if (responseText) {
+			const parsed = JSON.parse(responseText);
+			if (parsed.success) {
+				results.push({ test: "tools/call", passed: true });
+				success(`   ✓ list_projects returned ${parsed.data?.length ?? 0} projects`);
+			} else {
+				results.push({ test: "tools/call", passed: false, error: parsed.error?.message });
+			}
+		}
+	} catch (err) {
+		const errorMsg = err instanceof Error ? err.message : String(err);
+		results.push({ test: "unknown", passed: false, error: errorMsg });
+		error(`   ✗ Error: ${errorMsg}`);
+	} finally {
+		proc.kill();
+	}
+
+	// Summary
+	console.log("");
+	const passed = results.filter((r) => r.passed).length;
+	const failed = results.filter((r) => !r.passed).length;
+
+	if (failed === 0) {
+		success(`All ${passed} tests passed! MCP server is working correctly.`);
+	} else {
+		error(`${failed}/${results.length} tests failed.`);
+		for (const r of results.filter((r) => !r.passed)) {
+			error(`  - ${r.test}: ${r.error}`);
+		}
+		process.exit(1);
+	}
 }

package/src/commands/new.ts

@@ -2,22 +2,48 @@ import { getPreferredLaunchAgent, launchAgent } from "../lib/agents.ts";
 import { debug } from "../lib/debug.ts";
 import { getErrorDetails } from "../lib/errors.ts";
 import { promptSelect } from "../lib/hooks.ts";
+import { isIntentPhrase } from "../lib/intent.ts";
 import { output, spinner } from "../lib/output.ts";
 import { createProject } from "../lib/project-operations.ts";
 
 export default async function newProject(
-	name?: string,
-	options: { template?: string } = {},
+	nameOrPhrase?: string,
+	options: { template?: string; intent?: string; managed?: boolean; byo?: boolean; ci?: boolean } = {},
 ): Promise<void> {
 	// Immediate feedback
 	output.start("Starting...");
-	debug("newProject called", { name, options });
-	const isCi = process.env.CI === "true" || process.env.CI === "1";
+	debug("newProject called", { nameOrPhrase, options });
+	// CI mode: explicit --ci flag, JACK_CI env, or standard CI env
+	const isCi =
+		options.ci ||
+		process.env.JACK_CI === "1" ||
+		process.env.JACK_CI === "true" ||
+		process.env.CI === "true" ||
+		process.env.CI === "1";
+
+	// Determine if first arg is intent phrase or project name
+	let projectName: string | undefined;
+	let intentPhrase: string | undefined = options.intent;
+
+	if (nameOrPhrase) {
+		if (options.intent) {
+			// Explicit -m flag means first arg is definitely a name
+			projectName = nameOrPhrase;
+		} else if (isIntentPhrase(nameOrPhrase)) {
+			// Detected as intent phrase - name will be auto-generated
+			intentPhrase = nameOrPhrase;
+			projectName = undefined;
+		} else {
+			// Treat as project name
+			projectName = nameOrPhrase;
+		}
+	}
 
 	let result: Awaited<ReturnType<typeof createProject>>;
 	try {
-		result = await createProject(name, {
+		result = await createProject(projectName, {
 			template: options.template,
+			intent: intentPhrase,
 			reporter: {
 				start: output.start,
 				stop: output.stop,
@@ -29,6 +55,8 @@ export default async function newProject(
 				box: output.box,
 			},
 			interactive: !isCi,
+			managed: options.managed,
+			byo: options.byo,
 		});
 	} catch (error) {
 		const details = getErrorDetails(error);
@@ -37,9 +65,9 @@ export default async function newProject(
 			output.error(details.message);
 		}
 
-		const hasMissingSecrets = !!details.meta?.missingSecrets?.length;
-		if (hasMissingSecrets) {
-			for (const key of details.meta.missingSecrets) {
+		const missingSecrets = details.meta?.missingSecrets;
+		if (missingSecrets?.length) {
+			for (const key of missingSecrets) {
 				output.info(`  Run: jack secrets add ${key}`);
 			}
 		}
@@ -48,7 +76,7 @@ export default async function newProject(
 			console.error(details.meta.stderr);
 		}
 
-		if (details.suggestion && !details.meta?.reported && !hasMissingSecrets) {
+		if (details.suggestion && !details.meta?.reported && !missingSecrets?.length) {
 			output.info(details.suggestion);
 		}
 
@@ -63,8 +91,8 @@ export default async function newProject(
 	console.error("");
 	output.info(`Project: ${result.targetDir}`);
 
-	// Prompt to open preferred agent (only in interactive TTY)
-	if (process.stdout.isTTY) {
+	// Prompt to open preferred agent (only in interactive TTY, skip in CI mode)
+	if (process.stdout.isTTY && !isCi) {
 		const preferred = await getPreferredLaunchAgent();
 		if (preferred) {
 			console.error("");
@@ -73,12 +101,10 @@ export default async function newProject(
 			const choice = await promptSelect(["Yes", "No"]);
 
 			if (choice === 0) {
-				// Ensure terminal is in normal state before handoff
-				if (process.stdin.isTTY) {
-					process.stdin.setRawMode(false);
-				}
-
-				const launchResult = await launchAgent(preferred.launch, result.targetDir);
+				const launchResult = await launchAgent(preferred.launch, result.targetDir, {
+					projectName: result.projectName,
+					url: result.workerUrl,
+				});
 				if (!launchResult.success) {
 					output.warn(`Failed to launch ${preferred.definition.name}`);
 					if (launchResult.command?.length) {

package/src/commands/open.ts

@@ -1,6 +1,6 @@
 import { $ } from "bun";
 import { error, info } from "../lib/output.ts";
-import { getProject } from "../lib/registry.ts";
+import { resolveProject } from "../lib/project-resolver.ts";
 import { getProjectNameFromDir } from "../lib/storage/index.ts";
 
 export interface OpenFlags {
@@ -22,19 +22,26 @@ export default async function open(projectName?: string, flags: OpenFlags = {}):
 		}
 	}
 
-	// Get project from registry
-	const project = await getProject(name);
+	// Resolve project from registry and control plane
+	const project = await resolveProject(name);
 
-	// Determine URL based on flags
+	// Determine URL based on flags and deploy mode
 	let url: string;
 
 	if (flags.dash) {
+		// Dashboard URLs - use Cloudflare dash for now
 		url = `https://dash.cloudflare.com/workers/services/view/${name}`;
 	} else if (flags.logs) {
 		url = `https://dash.cloudflare.com/workers/services/view/${name}/logs`;
 	} else {
-		// Default: use worker URL from registry or construct it
-		url = project?.workerUrl || `https://${name}.workers.dev`;
+		// Default: use mode-appropriate URL
+		if (project?.sources.controlPlane && project.url) {
+			// Managed project: use runjack URL
+			url = project.url;
+		} else {
+			// BYO project: use workers.dev URL or stored URL
+			url = project?.url || `https://${name}.workers.dev`;
+		}
 	}
 
 	// Open browser using platform-specific command