@getjack/jack 0.1.7 → 0.1.8

package/package.json

@@ -1,13 +1,16 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.7",
+	"version": "0.1.8",
 	"description": "Ship before you forget why you started. The vibecoder's deployment CLI.",
 	"license": "Apache-2.0",
 	"type": "module",
 	"bin": {
 		"jack": "./src/index.ts"
 	},
-	"files": ["src", "templates"],
+	"files": [
+		"src",
+		"templates"
+	],
 	"engines": {
 		"bun": ">=1.0.0"
 	},

package/src/commands/down.ts

@@ -62,6 +62,7 @@ export interface DownFlags {
 export default async function down(projectName?: string, flags: DownFlags = {}): Promise<void> {
 	try {
 		// Get project name
+		const hasExplicitName = Boolean(projectName);
 		let name = projectName;
 		if (!name) {
 			try {
@@ -74,10 +75,12 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 		}
 
 		// Resolve project from all sources (local link + control plane)
-		const resolved = await resolveProject(name);
+		const resolved = await resolveProject(name, {
+			preferLocalLink: !hasExplicitName,
+		});
 
-		// Read local project link
-		const link = await readProjectLink(process.cwd());
+		// Read local project link (only when no explicit name provided)
+		const link = hasExplicitName ? null : await readProjectLink(process.cwd());
 
 		// Check if found only on control plane (orphaned managed project)
 		if (resolved?.sources.controlPlane && !resolved.sources.filesystem) {
@@ -85,6 +88,20 @@ export default async function down(projectName?: string, flags: DownFlags = {}):
 			info(`Found "${name}" on jack cloud, linking locally...`);
 		}
 
+
+		// Guard against mismatched resolutions when an explicit name is provided
+		if (hasExplicitName && resolved) {
+			const matches =
+				name === resolved.slug ||
+				name === resolved.name ||
+				name === resolved.remote?.projectId;
+			if (!matches) {
+				error(`Refusing to undeploy '${name}' because it resolves to '${resolved.slug}'.`);
+				info("Use the exact slug/name shown by 'jack info' and try again.");
+				process.exit(1);
+			}
+		}
+
 		if (!resolved && !link) {
 			// Not found anywhere
 			warn(`Project '${name}' not found`);

package/src/commands/mcp.ts

@@ -1,7 +1,13 @@
 import { spawn } from "node:child_process";
+import { rm, mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { error, info, success } from "../lib/output.ts";
 import { startMcpServer } from "../mcp/server.ts";
 
+const cliRoot = fileURLToPath(new URL("../..", import.meta.url));
+
 interface McpOptions {
 	project?: string;
 	debug?: boolean;
@@ -32,10 +38,19 @@ export default async function mcp(subcommand?: string, options: McpOptions = {})
  * Test MCP server by spawning it and sending test requests
  */
 async function testMcpServer(): Promise<void> {
+	const configDir = await mkdtemp(join(tmpdir(), "jack-config-"));
+
 	info("Testing MCP server...\n");
 
-	const proc = spawn("./src/index.ts", ["mcp", "serve"], {
+	const proc = spawn("bun", ["run", "src/index.ts", "mcp", "serve"], {
 		stdio: ["pipe", "pipe", "pipe"],
+		cwd: cliRoot,
+		env: {
+			...process.env,
+			CI: "1",
+			JACK_TELEMETRY_DISABLED: "1",
+			JACK_CONFIG_DIR: configDir,
+		},
 	});
 
 	const results: { test: string; passed: boolean; error?: string }[] = [];
@@ -126,6 +141,7 @@ async function testMcpServer(): Promise<void> {
 		error(`   ✗ Error: ${errorMsg}`);
 	} finally {
 		proc.kill();
+		await rm(configDir, { recursive: true, force: true });
 	}
 
 	// Summary

package/src/lib/agent-files.ts

@@ -21,7 +21,6 @@ This project is deployed to Cloudflare Workers using jack:
 \`\`\`bash
 jack ship    # Deploy to Cloudflare Workers
 jack logs    # Stream production logs
-jack dev     # Start local development server
 \`\`\`
 
 All deployment is handled by jack. Never run \`wrangler\` commands directly.
@@ -42,7 +41,6 @@ See [AGENTS.md](./AGENTS.md) for complete project context and deployment instruc
 
 - **Deploy**: \`jack ship\` - Deploy to Cloudflare Workers
 - **Logs**: \`jack logs\` - Stream production logs
-- **Dev**: \`jack dev\` - Start local development server
 
 ## Important
 

package/src/lib/build-helper.ts

@@ -172,19 +172,19 @@ export async function buildProject(options: BuildOptions): Promise<BuildOutput>
 	// Check if OpenNext build is needed (Next.js + Cloudflare)
 	const hasOpenNext = await needsOpenNextBuild(projectPath);
 	if (hasOpenNext) {
-		reporter?.start("Building...");
+		reporter?.start("Building assets...");
 		await runOpenNextBuild(projectPath);
 		reporter?.stop();
-		reporter?.success("Built");
+		reporter?.success("Built assets");
 	}
 
 	// Check if Vite build is needed and run it (skip if OpenNext already built)
 	const hasVite = await needsViteBuild(projectPath);
 	if (hasVite && !hasOpenNext) {
-		reporter?.start("Building...");
+		reporter?.start("Building assets...");
 		await runViteBuild(projectPath);
 		reporter?.stop();
-		reporter?.success("Built");
+		reporter?.success("Built assets");
 	}
 
 	// Create unique temp directory for build output
@@ -193,7 +193,7 @@ export async function buildProject(options: BuildOptions): Promise<BuildOutput>
 	await mkdir(outDir, { recursive: true });
 
 	// Run wrangler dry-run to build without deploying
-	reporter?.start("Building worker...");
+	reporter?.start("Bundling runtime...");
 
 	const dryRunResult = await $`wrangler deploy --dry-run --outdir=${outDir}`
 		.cwd(projectPath)
@@ -215,7 +215,7 @@ export async function buildProject(options: BuildOptions): Promise<BuildOutput>
 	}
 
 	reporter?.stop();
-	reporter?.success("Built worker");
+	reporter?.success("Bundled runtime");
 
 	const entrypoint = await resolveEntrypoint(outDir, config.main);
 

package/src/lib/config-generator.ts

@@ -33,6 +33,19 @@ export function generateWranglerConfig(
 			};
 
 		case "vite":
+			// Check if this is a Vite + Worker hybrid (has entryPoint)
+			if (entryPoint) {
+				// Hybrid mode: Vite frontend + custom Worker backend
+				return {
+					name: projectName,
+					main: entryPoint,
+					compatibility_date: COMPATIBILITY_DATE,
+					assets: {
+						directory: "./dist",
+						binding: "ASSETS",
+					},
+				};
+			}
 			// Pure Vite SPAs use assets-only mode (no worker entry)
 			// Cloudflare auto-generates a worker that serves static files
 			return {

package/src/lib/config.ts

@@ -40,7 +40,8 @@ export interface JackConfig {
 	sync?: SyncConfig;
 }
 
-export const CONFIG_DIR = join(homedir(), ".config", "jack");
+const DEFAULT_CONFIG_DIR = join(homedir(), ".config", "jack");
+export const CONFIG_DIR = process.env.JACK_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
 export const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 
 /**

package/src/lib/mcp-config.ts

@@ -3,6 +3,7 @@ import { mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { platform } from "node:os";
 import { dirname, join } from "node:path";
+import { CONFIG_DIR } from "./config.ts";
 
 /**
  * MCP server configuration structure
@@ -44,7 +45,7 @@ export const APP_MCP_CONFIGS: Record<string, AppMcpConfig> = {
 /**
  * Jack MCP configuration storage path
  */
-const JACK_MCP_CONFIG_DIR = join(homedir(), ".config", "jack", "mcp");
+const JACK_MCP_CONFIG_DIR = join(CONFIG_DIR, "mcp");
 const JACK_MCP_CONFIG_PATH = join(JACK_MCP_CONFIG_DIR, "config.json");
 
 /**

package/src/lib/output.ts

@@ -32,7 +32,27 @@ export const output = {
  * Create a spinner for long-running operations
  */
 export function spinner(text: string) {
-	return yoctoSpinner({ text }).start();
+	const spin = yoctoSpinner({ text }).start();
+
+	return {
+		success(message: string) {
+			spin.stop();
+			success(message);
+		},
+		error(message: string) {
+			spin.stop();
+			error(message);
+		},
+		stop() {
+			spin.stop();
+		},
+		get text() {
+			return spin.text;
+		},
+		set text(value: string | undefined) {
+			spin.text = value ?? "";
+		},
+	};
 }
 
 /**

package/src/lib/project-detection.ts

@@ -297,9 +297,28 @@ export function detectProjectType(projectPath: string): DetectionResult {
 	if (viteConfig && hasDep(pkg, "vite")) {
 		configFiles.push(viteConfig);
 		detectedDeps.push("vite");
+
+		// Check for Vite + Worker hybrid pattern
+		// This is indicated by @cloudflare/vite-plugin AND a worker entry file
+		const hasCloudflarePlugin = hasDep(pkg, "@cloudflare/vite-plugin");
+		let workerEntry: string | null = null;
+
+		if (hasCloudflarePlugin) {
+			detectedDeps.push("@cloudflare/vite-plugin");
+			// Check common worker entry locations
+			const workerCandidates = ["src/worker.ts", "src/worker.js", "worker.ts", "worker.js"];
+			for (const candidate of workerCandidates) {
+				if (existsSync(join(projectPath, candidate))) {
+					workerEntry = candidate;
+					break;
+				}
+			}
+		}
+
 		return {
 			type: "vite",
 			configFile: viteConfig,
+			entryPoint: workerEntry || undefined,
 			detectedDeps,
 			configFiles,
 		};

package/src/lib/project-operations.ts

@@ -1047,22 +1047,22 @@ export async function createProject(
 
 		// Build first if needed (wrangler needs built assets)
 		if (await needsOpenNextBuild(targetDir)) {
-			reporter.start("Building...");
+			reporter.start("Building assets...");
 			try {
 				await runOpenNextBuild(targetDir);
 				reporter.stop();
-				reporter.success("Built");
+				reporter.success("Built assets");
 			} catch (err) {
 				reporter.stop();
 				reporter.error("Build failed");
 				throw err;
 			}
 		} else if (await needsViteBuild(targetDir)) {
-			reporter.start("Building...");
+			reporter.start("Building assets...");
 			try {
 				await runViteBuild(targetDir);
 				reporter.stop();
-				reporter.success("Built");
+				reporter.success("Built assets");
 			} catch (err) {
 				reporter.stop();
 				reporter.error("Build failed");
@@ -1237,9 +1237,11 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 	}
 
 	// Validate mode availability
-	const modeError = await validateModeAvailability(deployMode);
-	if (modeError) {
-		throw new JackError(JackErrorCode.VALIDATION_ERROR, modeError);
+	if (!dryRun) {
+		const modeError = await validateModeAvailability(deployMode);
+		if (modeError) {
+			throw new JackError(JackErrorCode.VALIDATION_ERROR, modeError);
+		}
 	}
 
 	let workerUrl: string | null = null;
@@ -1264,19 +1266,19 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		// (deployToManagedProject handles its own build, so only build here for dry-run)
 		if (dryRun) {
 			if (await needsOpenNextBuild(projectPath)) {
-				const buildSpin = reporter.spinner("Building...");
+				const buildSpin = reporter.spinner("Building assets...");
 				try {
 					await runOpenNextBuild(projectPath);
-					buildSpin.success("Built");
+					buildSpin.success("Built assets");
 				} catch (err) {
 					buildSpin.error("Build failed");
 					throw err;
 				}
 			} else if (await needsViteBuild(projectPath)) {
-				const buildSpin = reporter.spinner("Building...");
+				const buildSpin = reporter.spinner("Building assets...");
 				try {
 					await runViteBuild(projectPath);
-					buildSpin.success("Built");
+					buildSpin.success("Built assets");
 				} catch (err) {
 					buildSpin.error("Build failed");
 					throw err;
@@ -1302,19 +1304,19 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 
 		// Build first if needed (wrangler needs built assets)
 		if (await needsOpenNextBuild(projectPath)) {
-			const buildSpin = reporter.spinner("Building...");
+			const buildSpin = reporter.spinner("Building assets...");
 			try {
 				await runOpenNextBuild(projectPath);
-				buildSpin.success("Built");
+				buildSpin.success("Built assets");
 			} catch (err) {
 				buildSpin.error("Build failed");
 				throw err;
 			}
 		} else if (await needsViteBuild(projectPath)) {
-			const buildSpin = reporter.spinner("Building...");
+			const buildSpin = reporter.spinner("Building assets...");
 			try {
 				await runViteBuild(projectPath);
-				buildSpin.success("Built");
+				buildSpin.success("Built assets");
 			} catch (err) {
 				buildSpin.error("Build failed");
 				throw err;
@@ -1396,16 +1398,16 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		}
 	}
 
-	if (includeSync) {
+	if (includeSync && deployMode !== "byo") {
 		const syncConfig = await getSyncConfig();
 		if (syncConfig.enabled && syncConfig.autoSync) {
-			const syncSpin = reporter.spinner("Syncing source to cloud...");
+			const syncSpin = reporter.spinner("Syncing source to jack storage...");
 			try {
 				const syncResult = await syncToCloud(projectPath);
 				if (syncResult.success) {
 					if (syncResult.filesUploaded > 0 || syncResult.filesDeleted > 0) {
 						syncSpin.success(
-							`Backed up ${syncResult.filesUploaded} files to jack-storage/${projectName}/`,
+							`Synced source to jack storage (${syncResult.filesUploaded} uploaded, ${syncResult.filesDeleted} removed)`,
 						);
 					} else {
 						syncSpin.success("Source already synced");

package/src/lib/project-resolver.ts

@@ -179,6 +179,8 @@ export interface ResolveProjectOptions {
 	projectPath?: string;
 	/** Allow fallback lookup by managed project name when slug lookup fails */
 	matchByName?: boolean;
+	/** Prefer local .jack/project.json when resolving (default true) */
+	preferLocalLink?: boolean;
 }
 
 /**
@@ -225,9 +227,10 @@ export async function resolveProject(
 	let resolved: ResolvedProject | null = null;
 	const matchByName = options?.matchByName !== false;
 	const projectPath = options?.projectPath || process.cwd();
+	const preferLocalLink = options?.preferLocalLink ?? true;
 
 	// First, check if we're resolving from a local path with .jack/project.json
-	const link = await readProjectLink(projectPath);
+	const link = preferLocalLink ? await readProjectLink(projectPath) : null;
 
 	if (link) {
 		// We have a local link - start with that

package/src/lib/secrets.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { chmod, mkdir, stat } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { CONFIG_DIR } from "./config.ts";
 
 export interface SecretEntry {
 	value: string;
@@ -14,7 +14,6 @@ export interface SecretsFile {
 	secrets: Record<string, SecretEntry>;
 }
 
-const CONFIG_DIR = join(homedir(), ".config", "jack");
 const SECRETS_PATH = join(CONFIG_DIR, "secrets.json");
 
 /**

package/src/lib/telemetry-config.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { CONFIG_DIR } from "./config.ts";
 
 /**
  * Telemetry configuration structure
@@ -12,8 +12,8 @@ export interface TelemetryConfig {
 	version: number; // config schema version (start at 1)
 }
 
-export const TELEMETRY_CONFIG_DIR = join(homedir(), ".config", "jack");
-export const TELEMETRY_CONFIG_PATH = join(TELEMETRY_CONFIG_DIR, "telemetry.json");
+export const TELEMETRY_CONFIG_DIR = CONFIG_DIR;
+export const TELEMETRY_CONFIG_PATH = join(CONFIG_DIR, "telemetry.json");
 
 /**
  * Cached telemetry config for memoization

package/src/mcp/test-utils.ts

@@ -0,0 +1,112 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+export interface McpClientOptions {
+	command: string;
+	args?: string[];
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	clientName?: string;
+	clientVersion?: string;
+}
+
+export interface McpTestClient {
+	client: Client;
+	transport: StdioClientTransport;
+	getStderr(): string;
+	close(): Promise<void>;
+}
+
+export async function openMcpTestClient(options: McpClientOptions): Promise<McpTestClient> {
+	const transport = new StdioClientTransport({
+		command: options.command,
+		args: options.args ?? [],
+		cwd: options.cwd,
+		env: options.env,
+		stderr: "pipe",
+	});
+
+	let stderr = "";
+	transport.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString();
+	});
+
+	const client = new Client({
+		name: options.clientName ?? "jack-mcp-test",
+		version: options.clientVersion ?? "0.1.0",
+	});
+
+	try {
+		await client.connect(transport);
+	} catch (error) {
+		await transport.close();
+		throw error;
+	}
+
+	return {
+		client,
+		transport,
+		getStderr: () => stderr,
+		close: () => transport.close(),
+	};
+}
+
+export function parseMcpToolResult(toolResult: {
+	content?: Array<{ type: string; text?: string }>;
+}): unknown {
+	const toolText = toolResult.content?.[0]?.type === "text" ? toolResult.content[0].text : null;
+	if (!toolText) {
+		throw new Error("MCP tool response missing text content");
+	}
+
+	const parsed = JSON.parse(toolText);
+	if (!parsed.success) {
+		const message = parsed.error?.message ?? "unknown error";
+		throw new Error(`MCP tool failed: ${message}`);
+	}
+
+	return parsed.data;
+}
+
+export async function verifyMcpToolsAndResources(client: Client): Promise<void> {
+	const tools = await client.listTools();
+	if (!tools.tools?.length) {
+		throw new Error("MCP server reported no tools");
+	}
+
+	const resources = await client.listResources();
+	if (!resources.resources?.length) {
+		throw new Error("MCP server reported no resources");
+	}
+
+	await client.readResource({ uri: "agents://context" });
+}
+
+export async function callMcpListProjects(
+	client: Client,
+	filter?: "all" | "local" | "deployed" | "cloud",
+): Promise<unknown[]> {
+	const response = await client.callTool({
+		name: "list_projects",
+		arguments: filter ? { filter } : {},
+	});
+
+	const data = parseMcpToolResult(response);
+	if (!Array.isArray(data)) {
+		throw new Error("MCP list_projects returned unexpected data");
+	}
+
+	return data;
+}
+
+export async function callMcpGetProjectStatus(
+	client: Client,
+	args: { name?: string; project_path?: string },
+): Promise<unknown> {
+	const response = await client.callTool({
+		name: "get_project_status",
+		arguments: args,
+	});
+
+	return parseMcpToolResult(response);
+}