@getjack/jack 0.1.31 → 0.1.33

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.31",
+	"version": "0.1.33",
 	"description": "Ship before you forget why you started. The vibecoder's deployment CLI.",
 	"license": "Apache-2.0",
 	"type": "module",

package/src/commands/deploys.ts

@@ -0,0 +1,95 @@
+import { fetchDeployments } from "../lib/control-plane.ts";
+import { error, info, item } from "../lib/output.ts";
+import { readProjectLink } from "../lib/project-link.ts";
+import { getProjectNameFromDir } from "../lib/storage/index.ts";
+
+const DEFAULT_LIMIT = 5;
+const ALL_LIMIT = 50;
+
+function humanizeSource(source: string): string {
+	if (source.startsWith("code:")) return "cli";
+	if (source.startsWith("prebuilt:")) return "template";
+	if (source.startsWith("template:")) return "template";
+	if (source.startsWith("rollback:")) return "rollback";
+	return source;
+}
+
+function humanizeStatus(status: string): string {
+	if (status === "queued") return "interrupted";
+	return status;
+}
+
+interface DeploysOptions {
+	all?: boolean;
+}
+
+/**
+ * List recent deployments for a project
+ */
+export default async function deploys(options: DeploysOptions = {}): Promise<void> {
+	const link = await readProjectLink(process.cwd());
+
+	if (!link) {
+		error("Not a jack project");
+		info("Run this command from a linked project directory");
+		process.exit(1);
+	}
+
+	if (link.deploy_mode !== "managed") {
+		info("Deploy history is available for managed projects only");
+		process.exit(0);
+	}
+
+	let result;
+	try {
+		result = await fetchDeployments(link.project_id);
+	} catch {
+		error("Could not fetch deployments");
+		info("Check your network connection and try again");
+		process.exit(1);
+	}
+
+	if (result.deployments.length === 0) {
+		info("No deployments yet");
+		return;
+	}
+
+	let projectName: string;
+	try {
+		projectName = await getProjectNameFromDir(process.cwd());
+	} catch {
+		projectName = link.project_id;
+	}
+
+	const limit = options.all ? ALL_LIMIT : DEFAULT_LIMIT;
+	const shown = result.deployments.slice(0, limit);
+
+	console.error("");
+	info(`Deployments for ${projectName} (${result.total} total)`);
+	console.error("");
+
+	//          icon + id       status        source       time
+	console.error("    ID        Status       Source     Deployed");
+	console.error("    ──        ──────       ──────     ────────");
+
+	for (const deploy of shown) {
+		const time = new Date(deploy.created_at).toLocaleString();
+		const shortId = deploy.id.length > 12 ? deploy.id.slice(4, 12) : deploy.id;
+		const status = humanizeStatus(deploy.status);
+		const source = humanizeSource(deploy.source);
+		const icon = status === "live" ? "✓" : status === "failed" ? "✗" : "○";
+		item(`${icon} ${shortId}  ${status.padEnd(12)} ${source.padEnd(10)} ${time}`);
+		if (deploy.message) {
+			console.error(`    "${deploy.message}"`);
+		}
+		if (deploy.error_message) {
+			console.error(`    ${deploy.error_message}`);
+		}
+	}
+
+	if (!options.all && result.total > DEFAULT_LIMIT) {
+		console.error("");
+		info(`Showing ${shown.length} of ${result.total}. Use --all to see more.`);
+	}
+	console.error("");
+}

package/src/commands/link.ts

@@ -32,6 +32,14 @@ export default async function link(projectName?: string, flags: LinkFlags = {}):
 			}
 		}
 
+		// Ensure hooks are installed for existing projects (idempotent)
+		try {
+			const { installClaudeCodeHooks } = await import("../lib/claude-hooks-installer.ts");
+			await installClaudeCodeHooks(process.cwd());
+		} catch {
+			// Non-critical
+		}
+
 		error("This directory is already linked");
 		info(`Linked to: ${projectDisplay}`);
 		info("To re-link, first run: jack unlink");

package/src/commands/mcp.ts

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
-import { mkdtemp, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -38,11 +39,19 @@ export default async function mcp(subcommand?: string, options: McpOptions = {})
 		return;
 	}
 
-	error("Unknown subcommand. Use: jack mcp serve, jack mcp install, or jack mcp test");
+	if (subcommand === "context") {
+		await outputProjectContext();
+		return;
+	}
+
+	error(
+		"Unknown subcommand. Use: jack mcp serve, jack mcp install, jack mcp test, or jack mcp context",
+	);
 	info("Usage:");
 	info("  jack mcp serve [--project /path] [--debug]  Start MCP server");
 	info("  jack mcp install                            Install/repair MCP config for AI agents");
 	info("  jack mcp test                               Test MCP server connectivity");
+	info("  jack mcp context                            Output project context for hooks");
 	process.exit(1);
 }
 
@@ -85,14 +94,14 @@ async function installMcpConfig(): Promise<void> {
 	}
 
 	if (skipped.length > 0) {
-		info(`\nSkipped (not installed):`);
+		info("\nSkipped (not installed):");
 		for (const app of skipped) {
 			item(`  ${app}`);
 		}
 	}
 
 	if (failed.length > 0) {
-		error(`\nFailed to install:`);
+		error("\nFailed to install:");
 		for (const app of failed) {
 			item(`  ${app}`);
 		}
@@ -105,6 +114,172 @@ async function installMcpConfig(): Promise<void> {
 	}
 }
 
+/**
+ * Parse wrangler config (jsonc or toml) and extract binding info.
+ * Returns null on any failure — never blocks session start.
+ */
+async function parseWranglerBindings(cwd: string): Promise<{
+	databases: string[];
+	buckets: string[];
+	vectorize: string[];
+	ai: boolean;
+	kv: string[];
+} | null> {
+	try {
+		const jsoncPath = join(cwd, "wrangler.jsonc");
+		const tomlPath = join(cwd, "wrangler.toml");
+
+		let config: Record<string, unknown> | null = null;
+
+		if (existsSync(jsoncPath)) {
+			const content = await readFile(jsoncPath, "utf-8");
+			const jsonContent = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+			config = JSON.parse(jsonContent);
+		} else if (existsSync(tomlPath)) {
+			// For toml, just check for key patterns — not worth a full parser here
+			const content = await readFile(tomlPath, "utf-8");
+			return {
+				databases: content.includes("d1_databases") ? ["(see wrangler.toml)"] : [],
+				buckets: content.includes("r2_buckets") ? ["(see wrangler.toml)"] : [],
+				vectorize: content.includes("vectorize") ? ["(see wrangler.toml)"] : [],
+				ai: content.includes("[ai]"),
+				kv: content.includes("kv_namespaces") ? ["(see wrangler.toml)"] : [],
+			};
+		}
+
+		if (!config) return null;
+
+		const databases =
+			(config.d1_databases as { database_name?: string; binding?: string }[])?.map(
+				(d) => d.database_name || d.binding || "unknown",
+			) ?? [];
+		const buckets =
+			(config.r2_buckets as { bucket_name?: string; binding?: string }[])?.map(
+				(b) => b.bucket_name || b.binding || "unknown",
+			) ?? [];
+		const vectorize =
+			(config.vectorize as { index_name?: string; binding?: string }[])?.map(
+				(v) => v.index_name || v.binding || "unknown",
+			) ?? [];
+		const ai = !!config.ai;
+		const kv =
+			(config.kv_namespaces as { binding?: string }[])?.map((k) => k.binding || "unknown") ?? [];
+
+		return { databases, buckets, vectorize, ai, kv };
+	} catch {
+		return null;
+	}
+}
+
+async function outputProjectContext(): Promise<void> {
+	try {
+		const cwd = process.cwd();
+		const { readProjectLink, readTemplateMetadata } = await import("../lib/project-link.ts");
+		const link = await readProjectLink(cwd);
+
+		// Silent exit if not a jack project — don't leak into non-jack sessions
+		if (!link) return;
+
+		// Fire-and-forget telemetry (no latency added)
+		const { track, Events } = await import("../lib/telemetry.ts");
+		track(Events.HOOK_SESSION_CONTEXT, {
+			deploy_mode: link.deploy_mode,
+		});
+
+		const sections: string[] = [];
+
+		const { getProjectNameFromDir } = await import("../lib/storage/index.ts");
+		let name = "unknown";
+		try {
+			name = await getProjectNameFromDir(cwd);
+		} catch {
+			// No wrangler config
+		}
+
+		// --- Section 1: Project identity ---
+		const lines = [`# Jack Project: ${name}`, ""];
+		if (link.deploy_mode === "managed" && link.owner_username) {
+			lines.push(`- **URL:** https://${link.owner_username}-${name}.runjack.xyz`);
+		}
+		lines.push(`- **Project ID:** ${link.project_id}`);
+		lines.push(
+			`- **Deploy mode:** ${link.deploy_mode === "managed" ? "Jack Cloud (managed)" : "BYO (bring your own Cloudflare account)"}`,
+		);
+
+		// Template origin
+		const templateMeta = await readTemplateMetadata(cwd);
+		if (templateMeta) {
+			lines.push(`- **Template:** ${templateMeta.name} (${templateMeta.type})`);
+		}
+
+		// --- Section 2: Detected services ---
+		const bindings = await parseWranglerBindings(cwd);
+		if (bindings) {
+			const services: string[] = [];
+			if (bindings.databases.length > 0)
+				services.push(`D1 databases: ${bindings.databases.join(", ")}`);
+			if (bindings.buckets.length > 0) services.push(`R2 storage: ${bindings.buckets.join(", ")}`);
+			if (bindings.vectorize.length > 0)
+				services.push(`Vectorize indexes: ${bindings.vectorize.join(", ")}`);
+			if (bindings.kv.length > 0) services.push(`KV namespaces: ${bindings.kv.join(", ")}`);
+			if (bindings.ai) services.push("AI (Workers AI)");
+
+			if (services.length > 0) {
+				lines.push("");
+				lines.push("### Services");
+				for (const svc of services) {
+					lines.push(`- ${svc}`);
+				}
+			}
+		}
+
+		// --- Section 3: Mode-specific guidance ---
+		lines.push("");
+		lines.push("## How to work with this project");
+		lines.push("");
+
+		if (link.deploy_mode === "managed") {
+			lines.push("This is a **Jack Cloud** project. All infrastructure is managed by jack.");
+			lines.push("");
+			lines.push("- Deploy: `mcp__jack__deploy_project` or `jack ship`");
+			lines.push("- Database: `mcp__jack__execute_sql` or `jack services db query`");
+			lines.push("- Logs: `mcp__jack__tail_logs` or `jack logs`");
+			lines.push("- Status: `mcp__jack__get_project_status` or `jack info`");
+			lines.push("");
+			lines.push(
+				"**Do NOT run `wrangler` commands.** This project uses Jack Cloud — there are no local Cloudflare credentials.",
+			);
+			lines.push(
+				"The `wrangler.jsonc` file is only used for local dev and build configuration, not for deployment.",
+			);
+		} else {
+			lines.push("This is a **BYO** (Bring Your Own) project deployed to your Cloudflare account.");
+			lines.push("");
+			lines.push("- Deploy: `mcp__jack__deploy_project` or `jack ship`");
+			lines.push("- Logs: `mcp__jack__tail_logs` or `jack logs`");
+			lines.push("- Status: `mcp__jack__get_project_status` or `jack info`");
+			lines.push("");
+			lines.push(
+				"Prefer `mcp__jack__*` tools or `jack` CLI over raw `wrangler` commands for consistency.",
+			);
+		}
+
+		lines.push("");
+		lines.push(
+			'To fork/clone a project: `mcp__jack__create_project` with `template: "username/slug"` or `template: "my-project"`.',
+		);
+		lines.push("");
+		lines.push(
+			"**Always prefer `mcp__jack__*` tools over CLI commands or wrangler** — they are cloud-aware and work in all deploy modes.",
+		);
+		sections.push(lines.join("\n"));
+
+		console.log(sections.join("\n\n---\n\n"));
+	} catch {
+		// Silent on failure — never break the session
+	}
+}
+
 /**
  * Test MCP server by spawning it and sending test requests
  */

package/src/commands/rollback.ts

@@ -0,0 +1,53 @@
+import { rollbackDeployment } from "../lib/control-plane.ts";
+import { error, info, spinner } from "../lib/output.ts";
+import { readProjectLink } from "../lib/project-link.ts";
+import { getProjectNameFromDir } from "../lib/storage/index.ts";
+
+/** Shorten a deployment ID for display: "dep_a1b2c3d4-..." → "a1b2c3d4" */
+function shortDeployId(id: string): string {
+	return id.startsWith("dep_") ? id.slice(4, 12) : id.slice(0, 8);
+}
+
+interface RollbackOptions {
+	to?: string;
+}
+
+/**
+ * Rollback to a previous deployment
+ */
+export default async function rollback(options: RollbackOptions = {}): Promise<void> {
+	const link = await readProjectLink(process.cwd());
+
+	if (!link) {
+		error("Not a jack project");
+		info("Run this command from a linked project directory");
+		process.exit(1);
+	}
+
+	if (link.deploy_mode !== "managed") {
+		error("Rollback is available for managed projects only");
+		info("BYO projects can be rolled back using wrangler directly");
+		process.exit(1);
+	}
+
+	let projectName: string;
+	try {
+		projectName = await getProjectNameFromDir(process.cwd());
+	} catch {
+		projectName = link.project_id;
+	}
+
+	const targetLabel = options.to ? shortDeployId(options.to) : "previous version";
+	const spin = spinner(`Rolling back ${projectName} to ${targetLabel}`);
+
+	try {
+		const result = await rollbackDeployment(link.project_id, options.to);
+		spin.success(`Rolled back to ${shortDeployId(result.deployment.id)}`);
+		info(`New deployment: ${result.deployment.id}`);
+		info("Code rolled back. Database state is unchanged.");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "Rollback failed";
+		spin.error(message);
+		process.exit(1);
+	}
+}

package/src/commands/services.ts

@@ -99,6 +99,7 @@ async function resolveDatabaseInfo(projectName: string): Promise<ResolvedDatabas
 
 interface ServiceOptions {
 	project?: string;
+	json?: boolean;
 }
 
 export default async function services(
@@ -209,17 +210,23 @@ async function resolveProjectName(options: ServiceOptions): Promise<string> {
  * Show database information
  */
 async function dbInfo(options: ServiceOptions): Promise<void> {
+	const jsonOutput = options.json ?? false;
 	const projectName = await resolveProjectName(options);
 	const projectDir = process.cwd();
 	const link = await readProjectLink(projectDir);
 
 	// For managed projects, use control plane API (no wrangler dependency)
 	if (link?.deploy_mode === "managed") {
-		outputSpinner.start("Fetching database info...");
+		if (!jsonOutput) outputSpinner.start("Fetching database info...");
 		try {
 			const { getManagedDatabaseInfo } = await import("../lib/control-plane.ts");
 			const dbInfo = await getManagedDatabaseInfo(link.project_id);
-			outputSpinner.stop();
+			if (!jsonOutput) outputSpinner.stop();
+
+			if (jsonOutput) {
+				console.log(JSON.stringify({ name: dbInfo.name, id: dbInfo.id, sizeBytes: dbInfo.sizeBytes, numTables: dbInfo.numTables, source: "managed" }));
+				return;
+			}
 
 			console.error("");
 			success(`Database: ${dbInfo.name}`);
@@ -231,7 +238,14 @@ async function dbInfo(options: ServiceOptions): Promise<void> {
 			console.error("");
 			return;
 		} catch (err) {
-			outputSpinner.stop();
+			if (!jsonOutput) outputSpinner.stop();
+			if (jsonOutput) {
+				const msg = err instanceof Error && err.message.includes("No database found")
+					? "No database configured. Run 'jack services db create' to create one."
+					: `Failed to fetch database info: ${err instanceof Error ? err.message : String(err)}`;
+				console.log(JSON.stringify({ success: false, error: msg }));
+				process.exit(1);
+			}
 			console.error("");
 			if (err instanceof Error && err.message.includes("No database found")) {
 				error("No database found for this project");
@@ -248,6 +262,10 @@ async function dbInfo(options: ServiceOptions): Promise<void> {
 	const dbInfo = await resolveDatabaseInfo(projectName);
 
 	if (!dbInfo) {
+		if (jsonOutput) {
+			console.log(JSON.stringify({ success: false, error: "No database found for this project" }));
+			return;
+		}
 		console.error("");
 		error("No database found for this project");
 		info("Create one with: jack services db create");
@@ -256,11 +274,15 @@ async function dbInfo(options: ServiceOptions): Promise<void> {
 	}
 
 	// Fetch detailed database info via wrangler
-	outputSpinner.start("Fetching database info...");
+	if (!jsonOutput) outputSpinner.start("Fetching database info...");
 	const wranglerDbInfo = await getWranglerDatabaseInfo(dbInfo.name);
-	outputSpinner.stop();
+	if (!jsonOutput) outputSpinner.stop();
 
 	if (!wranglerDbInfo) {
+		if (jsonOutput) {
+			console.log(JSON.stringify({ success: false, error: "Database not found" }));
+			process.exit(1);
+		}
 		console.error("");
 		error("Database not found");
 		info("It may have been deleted");
@@ -268,6 +290,11 @@ async function dbInfo(options: ServiceOptions): Promise<void> {
 		process.exit(1);
 	}
 
+	if (jsonOutput) {
+		console.log(JSON.stringify({ name: wranglerDbInfo.name, id: dbInfo.id || wranglerDbInfo.id, sizeBytes: wranglerDbInfo.sizeBytes, numTables: wranglerDbInfo.numTables, source: "byo" }));
+		return;
+	}
+
 	// Display info
 	console.error("");
 	success(`Database: ${wranglerDbInfo.name}`);
@@ -624,10 +651,16 @@ async function dbCreate(args: string[], options: ServiceOptions): Promise<void>
  * List all databases in the project
  */
 async function dbList(options: ServiceOptions): Promise<void> {
-	outputSpinner.start("Fetching databases...");
+	const jsonOutput = options.json ?? false;
+	if (!jsonOutput) outputSpinner.start("Fetching databases...");
 	try {
 		const databases = await listDatabases(process.cwd());
-		outputSpinner.stop();
+		if (!jsonOutput) outputSpinner.stop();
+
+		if (jsonOutput) {
+			console.log(JSON.stringify(databases));
+			return;
+		}
 
 		if (databases.length === 0) {
 			console.error("");
@@ -654,7 +687,11 @@ async function dbList(options: ServiceOptions): Promise<void> {
 			console.error("");
 		}
 	} catch (err) {
-		outputSpinner.stop();
+		if (!jsonOutput) outputSpinner.stop();
+		if (jsonOutput) {
+			console.log(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+			process.exit(1);
+		}
 		console.error("");
 		error(`Failed to list databases: ${err instanceof Error ? err.message : String(err)}`);
 		process.exit(1);
@@ -729,7 +766,8 @@ function parseExecuteArgs(args: string[]): ExecuteArgs {
 /**
  * Execute SQL against the database
  */
-async function dbExecute(args: string[], _options: ServiceOptions): Promise<void> {
+async function dbExecute(args: string[], options: ServiceOptions): Promise<void> {
+	const jsonOutput = options.json ?? false;
 	const execArgs = parseExecuteArgs(args);
 
 	// Validate input
@@ -766,7 +804,7 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 	const projectDir = process.cwd();
 
 	try {
-		outputSpinner.start("Executing SQL...");
+		if (!jsonOutput) outputSpinner.start("Executing SQL...");
 
 		let result;
 		if (execArgs.filePath) {
@@ -823,7 +861,7 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 			}
 
 			// NOW execute with confirmation
-			outputSpinner.start("Executing SQL...");
+			if (!jsonOutput) outputSpinner.start("Executing SQL...");
 			if (execArgs.filePath) {
 				result = await executeSqlFile({
 					projectDir,
@@ -857,12 +895,37 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 				error_type: "execution_failed",
 			});
 
+			if (jsonOutput) {
+				console.log(JSON.stringify({ success: false, error: result.error || "SQL execution failed" }));
+				process.exit(1);
+			}
+
 			console.error("");
 			error(result.error || "SQL execution failed");
 			console.error("");
 			process.exit(1);
 		}
 
+		// Track telemetry
+		track(Events.SQL_EXECUTED, {
+			success: true,
+			risk_level: result.risk,
+			statement_count: result.statements.length,
+			from_file: !!execArgs.filePath,
+		});
+
+		// JSON output mode — structured result for agents
+		if (jsonOutput) {
+			console.log(JSON.stringify({
+				success: true,
+				results: result.results ?? [],
+				meta: result.meta,
+				risk: result.risk,
+				warning: result.warning,
+			}));
+			return;
+		}
+
 		// Show results
 		console.error("");
 		success(`SQL executed (${getRiskDescription(result.risk)})`);
@@ -886,14 +949,6 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 			console.log(JSON.stringify(result.results, null, 2));
 		}
 		console.error("");
-
-		// Track telemetry
-		track(Events.SQL_EXECUTED, {
-			success: true,
-			risk_level: result.risk,
-			statement_count: result.statements.length,
-			from_file: !!execArgs.filePath,
-		});
 	} catch (err) {
 		outputSpinner.stop();
 
@@ -904,6 +959,11 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 				risk_level: err.risk,
 			});
 
+			if (jsonOutput) {
+				console.log(JSON.stringify({ success: false, error: err.message, suggestion: "Add --write flag" }));
+				process.exit(1);
+			}
+
 			console.error("");
 			error(err.message);
 			info("Add the --write flag to allow data modification:");
@@ -919,6 +979,11 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 				risk_level: "destructive",
 			});
 
+			if (jsonOutput) {
+				console.log(JSON.stringify({ success: false, error: err.message, suggestion: "Destructive operations require confirmation via CLI" }));
+				process.exit(1);
+			}
+
 			console.error("");
 			error(err.message);
 			info("Destructive operations require confirmation via CLI.");
@@ -931,6 +996,11 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 			error_type: "unknown",
 		});
 
+		if (jsonOutput) {
+			console.log(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
+			process.exit(1);
+		}
+
 		console.error("");
 		error(`SQL execution failed: ${err instanceof Error ? err.message : String(err)}`);
 		console.error("");
@@ -1284,7 +1354,17 @@ async function cronCreate(args: string[], options: ServiceOptions): Promise<void
 		item(`Schedule: ${result.description}`);
 		item(`Next run: ${result.nextRunAt}`);
 		console.error("");
-		info("Make sure your Worker handles POST /__scheduled requests.");
+		warn("Your worker must handle POST /__scheduled for crons to work.");
+		console.error("");
+		console.error("  Example (Hono):");
+		console.error("");
+		console.error("    app.post('/__scheduled', async (c) => {");
+		console.error("      // your cron logic here");
+		console.error("      return c.json({ ok: true });");
+		console.error("    });");
+		console.error("");
+		info("Cloudflare's native scheduled() export does NOT work with Jack Cloud.");
+		info("Jack invokes crons via HTTP, not the Workers scheduled event.");
 		console.error("");
 	} catch (err) {
 		outputSpinner.stop();