@getjack/jack 0.1.2 → 0.1.3

package/src/commands/feedback.ts

@@ -0,0 +1,189 @@
+/**
+ * jack feedback - Submit feedback to the jack team
+ *
+ * Works without login. Auto-collects metadata.
+ * Free-form text input, no categories.
+ */
+
+import pkg from "../../package.json";
+import { getCredentials } from "../lib/auth/store.ts";
+import { getControlApiUrl } from "../lib/control-plane.ts";
+import { error, info, output, success } from "../lib/output.ts";
+import { getProject } from "../lib/registry.ts";
+import { getProjectNameFromDir } from "../lib/storage/index.ts";
+import { getTelemetryConfig } from "../lib/telemetry.ts";
+
+interface FeedbackMetadata {
+	jack_version: string;
+	os: string;
+	project_name: string | null;
+	deploy_mode: "managed" | "byo" | null;
+}
+
+/**
+ * Check if user has allowed telemetry (respects privacy preferences)
+ */
+async function shouldAttachPersonalInfo(): Promise<boolean> {
+	if (process.env.DO_NOT_TRACK === "1") return false;
+	if (process.env.CI === "true") return false;
+	if (process.env.JACK_TELEMETRY_DISABLED === "1") return false;
+
+	try {
+		const config = await getTelemetryConfig();
+		return config.enabled;
+	} catch {
+		return true;
+	}
+}
+
+export default async function feedback(): Promise<void> {
+	// Check for interactive terminal
+	if (!process.stdin.isTTY) {
+		error("Feedback requires interactive input.");
+		info("Run in a terminal, or open an issue at github.com/getjack-org/jack");
+		process.exit(1);
+	}
+
+	// Show prompt
+	console.error("");
+	info("Share feedback, report a bug, or suggest a feature.");
+	info("Press Enter on an empty line to submit. Escape to cancel.");
+	console.error("");
+
+	// Read multi-line input
+	const message = await readMultilineInput();
+
+	if (!message.trim()) {
+		info("No feedback provided.");
+		return;
+	}
+
+	// Check privacy preferences
+	const attachPersonalInfo = await shouldAttachPersonalInfo();
+
+	// Collect metadata (respects privacy settings)
+	const metadata = await collectMetadata(attachPersonalInfo);
+
+	// Get email if logged in AND telemetry is enabled
+	let email: string | null = null;
+	if (attachPersonalInfo) {
+		const creds = await getCredentials();
+		email = creds?.user?.email ?? null;
+	}
+
+	// Submit
+	output.start("Sending feedback...");
+
+	try {
+		const response = await fetch(`${getControlApiUrl()}/v1/feedback`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				message: message.trim(),
+				email,
+				metadata,
+			}),
+		});
+
+		output.stop();
+
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status}`);
+		}
+
+		success("Done! Thanks for your feedback.");
+	} catch (err) {
+		output.stop();
+
+		// Network errors
+		if (err instanceof TypeError && err.message.includes("fetch")) {
+			error("Could not reach jack servers.");
+			info("Check your internet connection and try again.");
+		} else {
+			error("Failed to submit feedback.");
+			info("Try again later, or open an issue at github.com/getjack-org/jack");
+		}
+		process.exit(1);
+	}
+}
+
+async function readMultilineInput(): Promise<string> {
+	const lines: string[] = [];
+	const rl = await import("node:readline");
+
+	// Enable keypress events on stdin
+	rl.emitKeypressEvents(process.stdin);
+
+	const readline = rl.createInterface({
+		input: process.stdin,
+		output: process.stderr,
+		prompt: "> ",
+	});
+
+	return new Promise((resolve) => {
+		let emptyLineCount = 0;
+		let cancelled = false;
+
+		// Listen for Escape key
+		const onKeypress = (_ch: string, key: { name: string; ctrl?: boolean }) => {
+			if (key?.name === "escape") {
+				cancelled = true;
+				readline.close();
+			}
+		};
+		process.stdin.on("keypress", onKeypress);
+
+		readline.prompt();
+
+		readline.on("line", (line) => {
+			if (line === "") {
+				emptyLineCount++;
+				if (emptyLineCount >= 1 && lines.length > 0) {
+					// Empty line after content = submit
+					readline.close();
+					return;
+				}
+			} else {
+				emptyLineCount = 0;
+				lines.push(line);
+			}
+			readline.prompt();
+		});
+
+		readline.on("close", () => {
+			process.stdin.removeListener("keypress", onKeypress);
+			resolve(cancelled ? "" : lines.join("\n"));
+		});
+
+		// Handle Ctrl+C gracefully
+		readline.on("SIGINT", () => {
+			cancelled = true;
+			readline.close();
+		});
+	});
+}
+
+async function collectMetadata(attachPersonalInfo: boolean): Promise<FeedbackMetadata> {
+	let projectName: string | null = null;
+	let deployMode: "managed" | "byo" | null = null;
+
+	// Only collect project info if telemetry is enabled
+	if (attachPersonalInfo) {
+		try {
+			projectName = await getProjectNameFromDir(process.cwd());
+			if (projectName) {
+				const project = await getProject(projectName);
+				deployMode = project?.deploy_mode ?? null;
+			}
+		} catch {
+			// Not in a project directory, that's fine
+		}
+	}
+
+	return {
+		jack_version: pkg.version,
+		os: process.platform,
+		project_name: projectName,
+		deploy_mode: deployMode,
+	};
+}

package/src/commands/init.ts

@@ -5,11 +5,7 @@ import {
 	updateAgent,
 } from "../lib/agents.ts";
 import { readConfig, writeConfig } from "../lib/config.ts";
-import {
-	getIdeDisplayName,
-	installMcpConfigsToAllIdes,
-	saveMcpConfig,
-} from "../lib/mcp-config.ts";
+import { getAppDisplayName, installMcpConfigsToAllApps, saveMcpConfig } from "../lib/mcp-config.ts";
 import { info, item, spinner, success } from "../lib/output.ts";
 import { ensureAuth, ensureWrangler, isAuthenticated } from "../lib/wrangler.ts";
 
@@ -79,20 +75,20 @@ export default async function init(options: InitOptions = {}): Promise<void> {
 		info("No agents detected (you can add them later with: jack agents add)");
 	}
 
-	// Step 4: Install MCP configs to detected IDEs (unless --skip-mcp)
+	// Step 4: Install MCP configs to detected apps (unless --skip-mcp)
 	if (!options.skipMcp) {
 		const mcpSpinner = spinner("Installing MCP server configs...");
 		try {
-			const installedIdes = await installMcpConfigsToAllIdes();
+			const installedApps = await installMcpConfigsToAllApps();
 			mcpSpinner.stop();
 
-			if (installedIdes.length > 0) {
-				success(`MCP server installed to ${installedIdes.length} IDE(s)`);
-				for (const ideId of installedIdes) {
-					item(`  ${getIdeDisplayName(ideId)}`);
+			if (installedApps.length > 0) {
+				success(`MCP server installed to ${installedApps.length} app(s)`);
+				for (const appId of installedApps) {
+					item(`  ${getAppDisplayName(appId)}`);
 				}
 			} else {
-				info("No supported IDEs detected for MCP installation");
+				info("No supported apps detected for MCP installation");
 			}
 		} catch (err) {
 			mcpSpinner.stop();

package/src/commands/login.ts

@@ -0,0 +1,88 @@
+import { type DeviceAuthResponse, pollDeviceToken, startDeviceAuth } from "../lib/auth/client.ts";
+import { type AuthCredentials, saveCredentials } from "../lib/auth/store.ts";
+import { error, info, spinner, success } from "../lib/output.ts";
+
+interface LoginOptions {
+	/** Skip the initial "Logging in..." message (used when called from auto-login) */
+	silent?: boolean;
+}
+
+export default async function login(options: LoginOptions = {}): Promise<void> {
+	if (!options.silent) {
+		info("Logging in to jack cloud...");
+		console.error("");
+	}
+
+	const spin = spinner("Starting login...");
+	let deviceAuth: DeviceAuthResponse;
+
+	try {
+		deviceAuth = await startDeviceAuth();
+		spin.stop();
+	} catch (err) {
+		spin.stop();
+		error(err instanceof Error ? err.message : "Failed to start login");
+		process.exit(1);
+	}
+
+	console.error("");
+	console.error("  ┌────────────────────────────────────┐");
+	console.error("  │                                    │");
+	console.error(`  │    Your code:  ${deviceAuth.user_code.padEnd(12)}      │`);
+	console.error("  │                                    │");
+	console.error("  └────────────────────────────────────┘");
+	console.error("");
+	info(`Opening ${deviceAuth.verification_uri} in your browser...`);
+	console.error("");
+
+	// Open browser - use Bun.spawn for cross-platform
+	try {
+		const platform = process.platform;
+		const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+		Bun.spawn([cmd, deviceAuth.verification_uri_complete]);
+	} catch {
+		info(`If the browser didn't open, go to: ${deviceAuth.verification_uri_complete}`);
+	}
+
+	const pollSpin = spinner("Waiting for you to complete login in browser...");
+	const interval = (deviceAuth.interval || 5) * 1000;
+	const expiresAt = Date.now() + deviceAuth.expires_in * 1000;
+
+	while (Date.now() < expiresAt) {
+		await sleep(interval);
+
+		try {
+			const tokens = await pollDeviceToken(deviceAuth.device_code);
+
+			if (tokens) {
+				pollSpin.stop();
+
+				// Default to 5 minutes if expires_in not provided
+				const expiresIn = tokens.expires_in ?? 300;
+				const creds: AuthCredentials = {
+					access_token: tokens.access_token,
+					refresh_token: tokens.refresh_token,
+					expires_at: Math.floor(Date.now() / 1000) + expiresIn,
+					user: tokens.user,
+				};
+				await saveCredentials(creds);
+
+				console.error("");
+				success(`Logged in as ${tokens.user.email}`);
+				return;
+			}
+		} catch (err) {
+			pollSpin.stop();
+			error(err instanceof Error ? err.message : "Login failed");
+			process.exit(1);
+		}
+	}
+
+	pollSpin.stop();
+	error("Login timed out. Please try again.");
+	process.exit(1);
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/commands/logout.ts

@@ -0,0 +1,14 @@
+import { deleteCredentials, getCredentials } from "../lib/auth/store.ts";
+import { info, success } from "../lib/output.ts";
+
+export default async function logout(): Promise<void> {
+	const creds = await getCredentials();
+
+	if (!creds) {
+		info("Not logged in");
+		return;
+	}
+
+	await deleteCredentials();
+	success("Logged out");
+}

package/src/commands/logs.ts

@@ -1,5 +1,7 @@
 import { existsSync } from "node:fs";
 import { output } from "../lib/output.ts";
+import { getProject } from "../lib/registry.ts";
+import { getProjectNameFromDir } from "../lib/storage/index.ts";
 
 // Lines containing these strings will be filtered out
 const FILTERED_PATTERNS = ["⛅️ wrangler"];
@@ -17,6 +19,25 @@ export default async function logs(): Promise<void> {
 		process.exit(1);
 	}
 
+	// Check if this is a managed project
+	let projectName: string | null = null;
+	try {
+		projectName = await getProjectNameFromDir(process.cwd());
+	} catch {
+		// Continue without project name - will fall through to wrangler tail
+	}
+
+	if (projectName) {
+		const project = await getProject(projectName);
+		if (project?.deploy_mode === "managed") {
+			output.warn("Real-time logs not yet available for managed projects");
+			output.info("Logs are being collected - web UI coming soon");
+			output.info("Track progress: https://github.com/getjack-org/jack/issues/2");
+			return;
+		}
+	}
+
+	// BYOC project - use wrangler tail
 	output.info("Streaming logs from Cloudflare Worker...");
 	output.info("Press Ctrl+C to stop\n");
 

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