@getjack/jack 0.1.32 → 0.1.34

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@getjack/jack",
-	"version": "0.1.32",
+	"version": "0.1.34",
 	"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/secrets.ts

@@ -219,11 +219,13 @@ async function setSecret(args: string[], options: SecretsOptions): Promise<void>
  */
 async function setSecretManaged(projectId: string, name: string, value: string): Promise<void> {
 	const { authFetch } = await import("../lib/auth/index.ts");
+	const { encryptSecretValue } = await import("../lib/crypto.ts");
 
+	const encryptedValue = await encryptSecretValue(value);
 	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/secrets`, {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify({ name, value }),
+		body: JSON.stringify({ name, value: encryptedValue }),
 	});
 
 	if (!response.ok) {

package/src/commands/services.ts

@@ -1354,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();

package/src/commands/ship.ts

@@ -3,7 +3,7 @@ import { createReporter, output } from "../lib/output.ts";
 import { deployProject } from "../lib/project-operations.ts";
 
 export default async function ship(
-	options: { managed?: boolean; byo?: boolean; dryRun?: boolean; json?: boolean } = {},
+	options: { managed?: boolean; byo?: boolean; dryRun?: boolean; json?: boolean; message?: string } = {},
 ): Promise<void> {
 	const isCi = process.env.CI === "true" || process.env.CI === "1";
 	const jsonOutput = options.json ?? false;
@@ -17,6 +17,7 @@ export default async function ship(
 			managed: options.managed,
 			byo: options.byo,
 			dryRun: options.dryRun,
+			message: options.message,
 		});
 
 		if (jsonOutput) {
@@ -26,6 +27,7 @@ export default async function ship(
 					projectName: result.projectName,
 					url: result.workerUrl,
 					deployMode: result.deployMode,
+					...(options.message && { message: options.message }),
 				}),
 			);
 			return;

package/src/commands/tokens.ts

@@ -51,6 +51,7 @@ function showHelp(): void {
 	console.error("");
 	console.error("Commands:");
 	console.error("  create [name]             Create a new API token");
+	console.error("    --expires <days>        Token expires after N days");
 	console.error("  list                      List active tokens");
 	console.error("  revoke <id>               Revoke a token");
 	console.error("");
@@ -69,7 +70,18 @@ async function createToken(args: string[], flags: Record<string, unknown> = {}):
 		name = args[0];
 	}
 
-	const data = await createApiToken(name);
+	// Parse --expires <days> flag
+	let expiresInDays: number | undefined;
+	if (flags.expires !== undefined) {
+		const parsed = Number(flags.expires);
+		if (!Number.isInteger(parsed) || parsed <= 0) {
+			error("--expires must be a positive integer (number of days)");
+			process.exit(1);
+		}
+		expiresInDays = parsed;
+	}
+
+	const data = await createApiToken(name, expiresInDays);
 
 	track(Events.TOKEN_CREATED);
 
@@ -78,6 +90,9 @@ async function createToken(args: string[], flags: Record<string, unknown> = {}):
 	console.error(`  ${data.token}`);
 	console.error("");
 	console.error("  Save this token -- it will not be shown again.");
+	if (data.expires_at) {
+		console.error(`  Expires: ${data.expires_at}`);
+	}
 	console.error("");
 	console.error("  Usage:");
 	console.error("    export JACK_API_TOKEN=<token>");

package/src/commands/whoami.ts

@@ -1,28 +1,63 @@
+import { authFetch } from "../lib/auth/index.ts";
 import { getCredentials } from "../lib/auth/store.ts";
-import { info, item, success } from "../lib/output.ts";
+import { getControlApiUrl } from "../lib/control-plane.ts";
+import { error, info, item, success } from "../lib/output.ts";
 
 export default async function whoami(): Promise<void> {
+	const apiToken = process.env.JACK_API_TOKEN;
 	const creds = await getCredentials();
 
-	if (!creds) {
+	if (!apiToken && !creds) {
 		info("Not logged in");
 		info("Run 'jack login' to sign in");
 		return;
 	}
 
 	console.error("");
+
+	if (apiToken && !creds) {
+		// Token-only: fetch user info from control plane
+		try {
+			const res = await authFetch(`${getControlApiUrl()}/v1/me`);
+			if (!res.ok) {
+				error("API token is invalid or expired");
+				return;
+			}
+			const data = (await res.json()) as {
+				user?: { email?: string; id?: string; first_name?: string; last_name?: string };
+			};
+			if (data.user) {
+				success("Logged in");
+				if (data.user.email) item(`Email: ${data.user.email}`);
+				if (data.user.id) item(`ID: ${data.user.id}`);
+				if (data.user.first_name) {
+					item(`Name: ${data.user.first_name}${data.user.last_name ? ` ${data.user.last_name}` : ""}`);
+				}
+			} else {
+				success("Authenticated");
+			}
+			item(`Auth: API token (${apiToken.slice(4, 12)}...)`);
+		} catch {
+			error("Failed to reach control plane");
+			item(`Auth: API token (${apiToken.slice(4, 12)}...)`);
+		}
+		console.error("");
+		return;
+	}
+
+	// Has stored creds (with or without API token)
 	success("Logged in");
-	item(`Email: ${creds.user.email}`);
-	item(`ID: ${creds.user.id}`);
+	item(`Email: ${creds!.user.email}`);
+	item(`ID: ${creds!.user.id}`);
 
-	if (creds.user.first_name) {
-		item(`Name: ${creds.user.first_name}${creds.user.last_name ? ` ${creds.user.last_name}` : ""}`);
+	if (creds!.user.first_name) {
+		item(`Name: ${creds!.user.first_name}${creds!.user.last_name ? ` ${creds!.user.last_name}` : ""}`);
 	}
 
-	if (process.env.JACK_API_TOKEN) {
+	if (apiToken) {
 		item("Auth: API token");
 	} else {
-		const expiresIn = creds.expires_at - Math.floor(Date.now() / 1000);
+		const expiresIn = creds!.expires_at - Math.floor(Date.now() / 1000);
 		if (expiresIn > 0) {
 			const hours = Math.floor(expiresIn / 3600);
 			const minutes = Math.floor((expiresIn % 3600) / 60);

package/src/index.ts

@@ -18,10 +18,12 @@ const cli = meow(
     new <name> [path]   Create and deploy a project
     vibe "<phrase>"     Create from an idea
     ship                Push changes to production
+    rollback            Roll back to previous deploy
 
   Projects
     open [name]         Open in browser
     logs                Stream live logs
+    deploys             List recent deployments
     down [name]         Undeploy from cloud
     ls                  List all projects
     info [name]         Show project details
@@ -185,6 +187,9 @@ const cli = meow(
 			name: {
 				type: "string",
 			},
+			to: {
+				type: "string",
+			},
 		},
 	},
 );
@@ -292,6 +297,7 @@ try {
 				byo: cli.flags.byo,
 				dryRun: cli.flags.dryRun,
 				json: cli.flags.json,
+				message: cli.flags.message,
 			});
 			break;
 		}
@@ -301,6 +307,16 @@ try {
 			await withTelemetry("logs", logs)({ label: cli.flags.label });
 			break;
 		}
+		case "deploys": {
+			const { default: deploys } = await import("./commands/deploys.ts");
+			await withTelemetry("deploys", deploys)({ all: cli.flags.all });
+			break;
+		}
+		case "rollback": {
+			const { default: rollback } = await import("./commands/rollback.ts");
+			await withTelemetry("rollback", rollback)({ to: cli.flags.to });
+			break;
+		}
 		case "agents": {
 			const { default: agents } = await import("./commands/agents.ts");
 			await withTelemetry("agents", agents, { subcommand: args[0] })(args[0], args.slice(1), {