@getjack/jack 0.1.31 → 0.1.33

package/src/lib/auth/store.ts

@@ -51,6 +51,9 @@ export type AuthState = "logged-in" | "not-logged-in" | "session-expired";
  * - "session-expired": had credentials but refresh failed
  */
 export async function getAuthState(): Promise<AuthState> {
+	// API token always counts as logged in
+	if (process.env.JACK_API_TOKEN) return "logged-in";
+
 	const creds = await getCredentials();
 	if (!creds) return "not-logged-in";
 

package/src/lib/claude-hooks-installer.ts

@@ -0,0 +1,55 @@
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+const HOOK_COMMAND = "jack mcp context 2>/dev/null || true";
+
+/**
+ * Install a Claude Code SessionStart hook to the project's .claude/settings.json.
+ * Only fires when Claude Code is opened in this project directory.
+ * Non-destructive: preserves existing hooks and deduplicates.
+ */
+export async function installClaudeCodeHooks(projectPath: string): Promise<boolean> {
+	try {
+		const claudeDir = join(projectPath, ".claude");
+		const settingsPath = join(claudeDir, "settings.json");
+
+		// Ensure .claude directory exists
+		if (!existsSync(claudeDir)) {
+			await mkdir(claudeDir, { recursive: true });
+		}
+
+		let settings: Record<string, unknown> = {};
+		if (existsSync(settingsPath)) {
+			try {
+				settings = await Bun.file(settingsPath).json();
+			} catch {
+				settings = {};
+			}
+		}
+
+		const hooks = (settings.hooks as Record<string, unknown[]>) ?? {};
+		const sessionStart = (hooks.SessionStart as Array<Record<string, unknown>>) ?? [];
+
+		// Check if jack hook is already installed
+		for (const entry of sessionStart) {
+			const entryHooks = entry.hooks as Array<Record<string, string>> | undefined;
+			if (entryHooks?.some((h) => h.command?.includes("jack mcp context"))) {
+				return true;
+			}
+		}
+
+		sessionStart.push({
+			matcher: "",
+			hooks: [{ type: "command", command: HOOK_COMMAND }],
+		});
+
+		hooks.SessionStart = sessionStart;
+		settings.hooks = hooks;
+
+		await Bun.write(settingsPath, JSON.stringify(settings, null, 2));
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/lib/control-plane.ts

@@ -3,7 +3,6 @@
  */
 
 import { debug } from "./debug.ts";
-import { formatSize } from "./format.ts";
 
 const DEFAULT_CONTROL_API_URL = "https://control.getjack.org";
 
@@ -16,12 +15,14 @@ export interface CreateProjectRequest {
 	slug?: string;
 	template?: string;
 	use_prebuilt?: boolean;
+	forked_from?: string;
 }
 
 export interface CreateManagedProjectOptions {
 	slug?: string;
 	template?: string;
 	usePrebuilt?: boolean;
+	forkedFrom?: string;
 }
 
 export interface CreateProjectResponse {
@@ -111,6 +112,9 @@ export async function createManagedProject(
 	if (options?.usePrebuilt !== undefined) {
 		requestBody.use_prebuilt = options.usePrebuilt;
 	}
+	if (options?.forkedFrom) {
+		requestBody.forked_from = options.forkedFrom;
+	}
 
 	debug("Creating managed project", {
 		name,
@@ -451,6 +455,79 @@ export async function fetchProjectResources(projectId: string): Promise<ProjectR
 	return data.resources;
 }
 
+export interface DeploymentInfo {
+	id: string;
+	status: "queued" | "building" | "live" | "failed";
+	source: string;
+	error_message: string | null;
+	message: string | null;
+	created_at: string;
+	updated_at: string;
+}
+
+export interface DeploymentListResult {
+	deployments: DeploymentInfo[];
+	total: number;
+}
+
+/**
+ * Fetch recent deployments for a managed project.
+ * Returns deployments (up to 10) and total count.
+ */
+export async function fetchDeployments(projectId: string): Promise<DeploymentListResult> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/deployments`);
+
+	if (!response.ok) {
+		return { deployments: [], total: 0 }; // Silent fail — deployment history is supplementary
+	}
+
+	const data = (await response.json()) as { deployments: DeploymentInfo[]; total: number };
+	return { deployments: data.deployments, total: data.total };
+}
+
+export interface RollbackResponse {
+	deployment: {
+		id: string;
+		status: string;
+		source: string;
+		created_at: string;
+		updated_at: string;
+	};
+}
+
+/**
+ * Rollback a managed project to a previous deployment.
+ * If no deploymentId given, rolls back to the previous successful deployment.
+ */
+export async function rollbackDeployment(
+	projectId: string,
+	deploymentId?: string,
+): Promise<RollbackResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const body: Record<string, string> = {};
+	if (deploymentId) {
+		body.deployment_id = deploymentId;
+	}
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/rollback`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body),
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Rollback failed: ${response.status}`);
+	}
+
+	return response.json() as Promise<RollbackResponse>;
+}
+
 /**
  * Create a resource for a managed project.
  * Uses POST /v1/projects/:id/resources/:type endpoint.
@@ -715,45 +792,6 @@ export async function getCurrentUserProfile(): Promise<UserProfile | null> {
 	}
 }
 
-export interface SourceSnapshotResponse {
-	success: boolean;
-	source_key: string;
-}
-
-/**
- * Upload a source snapshot for a project.
- * Used to enable project forking.
- */
-export async function uploadSourceSnapshot(
-	projectId: string,
-	sourceZipPath: string,
-): Promise<SourceSnapshotResponse> {
-	const { authFetch } = await import("./auth/index.ts");
-
-	const formData = new FormData();
-	const sourceFile = Bun.file(sourceZipPath);
-	formData.append("source", sourceFile);
-
-	const url = `${getControlApiUrl()}/v1/projects/${projectId}/source`;
-	debug(`Source snapshot: ${formatSize(sourceFile.size)}`);
-
-	const start = Date.now();
-	const response = await authFetch(url, {
-		method: "POST",
-		body: formData,
-	});
-	debug(`Source snapshot: ${response.status} (${((Date.now() - start) / 1000).toFixed(1)}s)`);
-
-	if (!response.ok) {
-		const error = (await response.json().catch(() => ({ message: "Upload failed" }))) as {
-			message?: string;
-		};
-		throw new Error(error.message || `Source upload failed: ${response.status}`);
-	}
-
-	return response.json() as Promise<SourceSnapshotResponse>;
-}
-
 /**
  * Publish a project to make it forkable by others.
  */

package/src/lib/debug.ts

@@ -1,6 +1,7 @@
 // Debug utilities for timing and verbose logging
 
-let debugEnabled = false;
+let debugEnabled =
+	process.env.JACK_DEBUG === "1" || process.env.JACK_DEBUG === "true";
 const timers: Map<string, number> = new Map();
 const startTime = Date.now();
 

package/src/lib/deploy-upload.ts

@@ -18,6 +18,7 @@ export interface DeployUploadOptions {
 	secretsPath?: string;
 	assetsZipPath?: string;
 	assetManifest?: AssetManifest;
+	message?: string;
 }
 
 export interface DeployUploadResult {
@@ -25,6 +26,7 @@ export interface DeployUploadResult {
 	project_id: string;
 	status: "queued" | "building" | "live" | "failed";
 	source: string;
+	error_message: string | null;
 	created_at: string;
 }
 
@@ -91,6 +93,10 @@ export async function uploadDeployment(options: DeployUploadOptions): Promise<De
 		totalSize += manifestJson.length;
 	}
 
+	if (options.message) {
+		formData.append("message", options.message);
+	}
+
 	const prepareMs = Date.now() - prepareStart;
 	debug(`Payload ready: ${formatSize(totalSize)} (${prepareMs}ms)`);
 

package/src/lib/hooks.ts

@@ -702,7 +702,9 @@ const actionHandlers: {
 		const proc = Bun.spawn(["sh", "-c", command], {
 			cwd,
 			stdin: interactive ? "inherit" : "ignore",
-			stdout: "inherit",
+			// In non-interactive mode (MCP), stdout must NOT inherit because it would
+			// write into the JSON-RPC stdio transport and corrupt the protocol.
+			stdout: interactive ? "inherit" : "pipe",
 			stderr: "inherit",
 		});
 		await proc.exited;

package/src/lib/managed-deploy.ts

@@ -7,7 +7,7 @@
 import { stat } from "node:fs/promises";
 import { validateBindings } from "./binding-validator.ts";
 import { buildProject, parseWranglerConfig } from "./build-helper.ts";
-import { createManagedProject, syncProjectTags, uploadSourceSnapshot } from "./control-plane.ts";
+import { createManagedProject, syncProjectTags } from "./control-plane.ts";
 import { debug } from "./debug.ts";
 import { uploadDeployment } from "./deploy-upload.ts";
 import { JackError, JackErrorCode } from "./errors.ts";
@@ -31,6 +31,7 @@ export interface ManagedCreateResult {
 export interface ManagedCreateOptions {
 	template?: string;
 	usePrebuilt?: boolean;
+	forkedFrom?: string;
 }
 
 /**
@@ -50,6 +51,7 @@ export async function createManagedProjectRemote(
 		const result = await createManagedProject(projectName, {
 			template: options?.template,
 			usePrebuilt: options?.usePrebuilt ?? true,
+			forkedFrom: options?.forkedFrom,
 		});
 
 		const runjackUrl = result.url || `https://${result.project.slug}.runjack.xyz`;
@@ -79,6 +81,7 @@ export interface ManagedCodeDeployOptions {
 	projectId: string;
 	projectPath: string;
 	reporter?: OperationReporter;
+	message?: string;
 }
 
 /**
@@ -88,7 +91,7 @@ export interface ManagedCodeDeployOptions {
  */
 export async function deployCodeToManagedProject(
 	options: ManagedCodeDeployOptions,
-): Promise<{ deploymentId: string; status: string }> {
+): Promise<{ deploymentId: string; status: string; errorMessage: string | null }> {
 	const { projectId, projectPath, reporter } = options;
 
 	// Track deploy start
@@ -161,6 +164,7 @@ export async function deployCodeToManagedProject(
 			secretsPath: pkg.secretsPath ?? undefined,
 			assetsZipPath: pkg.assetsZipPath ?? undefined,
 			assetManifest: pkg.assetManifest ?? undefined,
+			message: options.message,
 		});
 
 		uploadProgress.complete();
@@ -183,16 +187,13 @@ export async function deployCodeToManagedProject(
 			})
 			.catch(() => {});
 
-		// Upload source snapshot for forking (non-fatal, but must await before cleanup)
-		try {
-			await uploadSourceSnapshot(projectId, pkg.sourceZipPath);
-		} catch (err) {
-			debug("Source snapshot upload failed:", err instanceof Error ? err.message : String(err));
-		}
+		// Source snapshot for forking is now derived from deployment artifacts on the control plane.
+		// No separate upload needed — clone/fork reads from the latest live deployment's source.zip.
 
 		return {
 			deploymentId: result.id,
 			status: result.status,
+			errorMessage: result.error_message,
 		};
 	} catch (error) {
 		reporter?.stop();
@@ -218,10 +219,12 @@ export async function deployToManagedProject(
 	projectId: string,
 	projectPath: string,
 	reporter?: OperationReporter,
-): Promise<{ deploymentId: string; status: string }> {
+	message?: string,
+): Promise<{ deploymentId: string; status: string; errorMessage: string | null }> {
 	return deployCodeToManagedProject({
 		projectId,
 		projectPath,
 		reporter,
+		message,
 	});
 }

package/src/lib/project-link.ts

@@ -116,6 +116,12 @@ export async function linkProject(
 
 	// Auto-add .jack/ to .gitignore
 	await ensureGitignored(projectDir);
+
+	// Install Claude Code SessionStart hook to project-level .claude/settings.json
+	// Non-blocking, fire-and-forget — never delays project linking
+	import("./claude-hooks-installer.ts")
+		.then(({ installClaudeCodeHooks }) => installClaudeCodeHooks(projectDir))
+		.catch(() => {});
 }
 
 /**

package/src/lib/project-operations.ts

@@ -102,6 +102,7 @@ export interface DeployOptions {
 	managed?: boolean; // Force managed deploy mode
 	byo?: boolean; // Force BYO deploy mode
 	dryRun?: boolean; // Stop before actual deployment
+	message?: string; // Deploy message describing what changed
 }
 
 export interface DeployResult {
@@ -109,6 +110,9 @@ export interface DeployResult {
 	projectName: string;
 	deployOutput?: string;
 	deployMode: DeployMode; // The deploy mode used
+	deploymentId?: string;
+	deployStatus?: string;
+	errorMessage?: string | null;
 }
 
 export interface ProjectStatus {
@@ -126,6 +130,12 @@ export interface ProjectStatus {
 	missing: boolean;
 	backupFiles: number | null;
 	backupLastSync: string | null;
+	// Deploy tracking (managed projects only)
+	lastDeployAt: string | null;
+	deployCount: number;
+	lastDeployStatus: string | null;
+	lastDeploySource: string | null;
+	lastDeployMessage: string | null;
 }
 
 export interface StaleProject {
@@ -361,6 +371,7 @@ async function runParallelSetup(
 	options: {
 		template?: string;
 		usePrebuilt?: boolean;
+		forkedFrom?: string;
 		onRemoteReady?: (result: ManagedCreateResult) => void;
 	},
 ): Promise<{
@@ -391,6 +402,7 @@ async function runParallelSetup(
 	const remotePromise = createManagedProjectRemote(projectName, undefined, {
 		template: options.template || "hello",
 		usePrebuilt: options.usePrebuilt ?? true,
+		forkedFrom: options.forkedFrom,
 	}).then((result) => {
 		const duration = ((Date.now() - remoteStart) / 1000).toFixed(1);
 		debug(`Remote project created in ${duration}s (status: ${result.status})`);
@@ -793,11 +805,25 @@ export async function createProject(
 		}
 	}
 
-	// Check if jack init was run (throws if not)
+	// Auto-initialize on first run (replaces "Run: jack init" error)
 	const { isInitialized } = await import("../commands/init.ts");
 	const initialized = await isInitialized();
 	if (!initialized) {
-		throw new JackError(JackErrorCode.VALIDATION_ERROR, "jack is not set up yet", "Run: jack init");
+		const { writeConfig, readConfig } = await import("./config.ts");
+		const existingConfig = await readConfig();
+		await writeConfig({
+			version: 1,
+			initialized: true,
+			initializedAt: existingConfig?.initializedAt || new Date().toISOString(),
+			...existingConfig,
+		});
+
+		// Best-effort MCP config install (non-blocking)
+		try {
+			const { installMcpConfigsToAllApps, saveMcpConfig } = await import("./mcp-config.ts");
+			await installMcpConfigsToAllApps();
+			await saveMcpConfig();
+		} catch {}
 	}
 
 	// Auth gate - check/prompt for authentication before any work
@@ -1199,9 +1225,11 @@ export async function createProject(
 			reporter.start("Setting up project...");
 
 			try {
+				const forkedFrom = templateOrigin.type !== "builtin" ? templateOrigin.name : undefined;
 				const result = await runParallelSetup(targetDir, projectName, {
 					template: resolvedTemplate || "hello",
 					usePrebuilt: templateOrigin.type === "builtin", // Only builtin templates have prebuilt bundles
+					forkedFrom,
 					onRemoteReady: (remote) => {
 						// Show URL immediately when prebuilt succeeds
 						reporter.stop();
@@ -1355,22 +1383,8 @@ export async function createProject(
 					reporter.success(`Deployed: ${workerUrl}`);
 				}
 
-				// Upload source snapshot for forking (prebuilt path needs this too)
-				try {
-					const { createSourceZip } = await import("./zip-packager.ts");
-					const { uploadSourceSnapshot } = await import("./control-plane.ts");
-					const { rm } = await import("node:fs/promises");
-
-					const sourceZipPath = await createSourceZip(targetDir);
-					await uploadSourceSnapshot(remoteResult.projectId, sourceZipPath);
-					await rm(sourceZipPath, { force: true });
-					debug("Source snapshot uploaded for prebuilt project");
-				} catch (err) {
-					debug(
-						"Source snapshot upload failed (prebuilt):",
-						err instanceof Error ? err.message : String(err),
-					);
-				}
+				// source.zip is now stored in deployment artifacts by the control plane
+				// during prebuilt deploy — no client-side upload needed
 			} else {
 				// Prebuilt not available - fall back to fresh build
 				if (remoteResult.prebuiltFailed) {
@@ -1688,11 +1702,10 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		deployMode = link?.deploy_mode ?? "byo";
 	}
 
-	// Ensure agent integration is set up (JACK.md, MCP config)
+	// Ensure agent integration is set up (MCP config)
 	// This is idempotent and runs silently
 	try {
 		await ensureAgentIntegration(projectPath, {
-			projectName,
 			silent: true,
 		});
 	} catch (err) {
@@ -1723,6 +1736,7 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 
 	let workerUrl: string | null = null;
 	let deployOutput: string | undefined;
+	let managedDeployResult: { deploymentId: string; status: string; errorMessage: string | null } | undefined;
 
 	// Deploy based on mode
 	if (deployMode === "managed") {
@@ -1781,7 +1795,7 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		}
 
 		// deployToManagedProject now handles both template and code deploy
-		await deployToManagedProject(managedProjectId as string, projectPath, reporter);
+		managedDeployResult = await deployToManagedProject(managedProjectId as string, projectPath, reporter, options.message);
 
 		// Construct URL with username if available
 		workerUrl = link?.owner_username
@@ -1936,6 +1950,9 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		projectName,
 		deployOutput: workerUrl ? undefined : deployOutput,
 		deployMode,
+		deploymentId: managedDeployResult?.deploymentId,
+		deployStatus: managedDeployResult?.status,
+		errorMessage: managedDeployResult?.errorMessage,
 	};
 }
 
@@ -2025,11 +2042,35 @@ export async function getProjectStatus(
 		}
 	}
 
+	// Fetch real deployment data for managed projects
+	let lastDeployAt: string | null = null;
+	let deployCount = 0;
+	let lastDeployStatus: string | null = null;
+	let lastDeploySource: string | null = null;
+	let lastDeployMessage: string | null = null;
+
+	if (link?.deploy_mode === "managed") {
+		try {
+			const { fetchDeployments } = await import("./control-plane.ts");
+			const result = await fetchDeployments(link.project_id);
+			deployCount = result.total;
+			const latest = result.deployments[0];
+			if (latest) {
+				lastDeployAt = latest.created_at;
+				lastDeployStatus = latest.status;
+				lastDeploySource = latest.source;
+				lastDeployMessage = latest.message;
+			}
+		} catch {
+			// Silent fail — deploy tracking is supplementary
+		}
+	}
+
 	return {
 		name: projectName,
 		localPath,
 		workerUrl,
-		lastDeployed: link?.linked_at ?? null,
+		lastDeployed: lastDeployAt ?? link?.linked_at ?? null,
 		createdAt: link?.linked_at ?? null,
 		accountId: null, // No longer stored in registry
 		workerId: projectName,
@@ -2040,6 +2081,11 @@ export async function getProjectStatus(
 		missing: false,
 		backupFiles,
 		backupLastSync,
+		lastDeployAt,
+		deployCount,
+		lastDeployStatus,
+		lastDeploySource,
+		lastDeployMessage,
 	};
 }
 

package/src/lib/services/token-operations.ts

@@ -0,0 +1,84 @@
+/**
+ * Token operations service layer for jack cloud
+ *
+ * Provides shared API token management functions for both CLI and MCP.
+ * Returns pure data - no console.log or process.exit.
+ */
+
+import { authFetch } from "../auth/index.ts";
+import { getControlApiUrl } from "../control-plane.ts";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface CreateTokenResult {
+	token: string;
+	id: string;
+	name: string;
+	created_at: string;
+	expires_at: string | null;
+}
+
+export interface TokenInfo {
+	id: string;
+	name: string;
+	id_prefix: string;
+	created_at: string;
+	last_used_at: string | null;
+	expires_at: string | null;
+}
+
+// ============================================================================
+// Service Functions
+// ============================================================================
+
+/**
+ * Create a new API token for headless authentication.
+ */
+export async function createApiToken(
+	name: string,
+	expiresInDays?: number,
+): Promise<CreateTokenResult> {
+	const response = await authFetch(`${getControlApiUrl()}/v1/tokens`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ name, expires_in_days: expiresInDays }),
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({}))) as { message?: string };
+		throw new Error(err.message || `Failed to create token: ${response.status}`);
+	}
+
+	return response.json() as Promise<CreateTokenResult>;
+}
+
+/**
+ * List all active API tokens for the current user.
+ */
+export async function listApiTokens(): Promise<TokenInfo[]> {
+	const response = await authFetch(`${getControlApiUrl()}/v1/tokens`);
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({}))) as { message?: string };
+		throw new Error(err.message || `Failed to list tokens: ${response.status}`);
+	}
+
+	const data = (await response.json()) as { tokens: TokenInfo[] };
+	return data.tokens;
+}
+
+/**
+ * Revoke an API token by ID.
+ */
+export async function revokeApiToken(tokenId: string): Promise<void> {
+	const response = await authFetch(`${getControlApiUrl()}/v1/tokens/${tokenId}`, {
+		method: "DELETE",
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({}))) as { message?: string };
+		throw new Error(err.message || `Failed to revoke token: ${response.status}`);
+	}
+}

package/src/lib/telemetry.ts

@@ -44,6 +44,11 @@ export const Events = {
 	BYO_DEPLOY_STARTED: "byo_deploy_started",
 	BYO_DEPLOY_COMPLETED: "byo_deploy_completed",
 	BYO_DEPLOY_FAILED: "byo_deploy_failed",
+	// Token management events
+	TOKEN_CREATED: "token_created",
+	TOKEN_REVOKED: "token_revoked",
+	// Hook events
+	HOOK_SESSION_CONTEXT: "hook_session_context",
 } as const;
 
 type EventName = (typeof Events)[keyof typeof Events];
@@ -127,6 +132,7 @@ export interface UserProperties {
 	is_tty?: boolean;
 	locale?: string;
 	config_style?: "byoc" | "jack-cloud";
+	auth_method?: "oauth" | "token";
 }
 
 // Detect environment properties (for user profile - stable properties)

package/src/mcp/README.md

@@ -25,7 +25,7 @@ src/mcp/
 ### `tools/index.ts`
 - Centralized tool registration and dispatch
 - Implements 4 core tools:
-  - `create_project` - Create new Cloudflare Workers project
+  - `create_project` - Create new project (supports forking via template)
   - `deploy_project` - Deploy existing project
   - `get_project_status` - Get project status info
   - `list_projects` - List all projects with filters