@getjack/jack 0.1.2 → 0.1.4

package/src/lib/agents.ts

@@ -1,8 +1,10 @@
-import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, extname, join } from "node:path";
 import { type AgentConfig, type AgentLaunchConfig, readConfig, writeConfig } from "./config.ts";
+import { debug, isDebug } from "./debug.ts";
+import { restoreTty } from "./tty";
 
 // Re-export AgentConfig for consumers
 export type { AgentConfig } from "./config.ts";
@@ -39,6 +41,12 @@ export interface DetectionResult {
 	total: number;
 }
 
+export interface OneShotReporter {
+	info(message: string): void;
+	warn(message: string): void;
+	status?(message: string): void;
+}
+
 /**
  * Result of validating agent paths
  */
@@ -113,9 +121,7 @@ function findExecutable(command: string): string | null {
 	if (process.platform === "win32") {
 		const extension = extname(command);
 		const extensions =
-			extension.length > 0
-				? [""]
-				: (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";");
+			extension.length > 0 ? [""] : (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";");
 
 		for (const basePath of paths) {
 			for (const ext of extensions) {
@@ -374,14 +380,11 @@ export async function getAgentLaunch(id: string): Promise<AgentLaunchConfig | nu
 	return resolved ?? null;
 }
 
-export async function getPreferredLaunchAgent(): Promise<
-	| {
-			id: string;
-			definition: AgentDefinition;
-			launch: AgentLaunchConfig;
-	  }
-	| null
-> {
+export async function getPreferredLaunchAgent(): Promise<{
+	id: string;
+	definition: AgentDefinition;
+	launch: AgentLaunchConfig;
+} | null> {
 	const config = await readConfig();
 	if (!config?.agents) return null;
 
@@ -417,22 +420,48 @@ export async function getPreferredLaunchAgent(): Promise<
 	return null;
 }
 
+/**
+ * Context to pass to the agent on launch
+ */
+export interface AgentLaunchContext {
+	projectName?: string;
+	url?: string | null;
+}
+
+/**
+ * Build the initial prompt for the agent based on launch context
+ */
+function buildInitialPrompt(context: AgentLaunchContext): string | null {
+	if (!context.url) return null;
+
+	return `[jack] Project "${context.projectName}" is live at ${context.url} - say hi and let's build!`;
+}
+
 function buildLaunchCommand(
 	launch: AgentLaunchConfig,
 	projectDir: string,
-):
-	| {
-			command: string;
-			args: string[];
-			options: { cwd?: string; stdio: "inherit" | "ignore"; detached?: boolean };
-			waitForExit: boolean;
-	  }
-	| null {
+	context?: AgentLaunchContext,
+): {
+	command: string;
+	args: string[];
+	options: { cwd?: string; stdio: "inherit" | "ignore"; detached?: boolean };
+	waitForExit: boolean;
+} | null {
 	if (launch.type !== "cli") return null;
 
+	const args = launch.args ? [...launch.args] : [];
+
+	// Add initial prompt if context is provided
+	if (context) {
+		const initialPrompt = buildInitialPrompt(context);
+		if (initialPrompt) {
+			args.push(initialPrompt);
+		}
+	}
+
 	return {
 		command: launch.command,
-		args: launch.args ?? [],
+		args,
 		options: { cwd: projectDir, stdio: "inherit" },
 		waitForExit: true,
 	};
@@ -441,14 +470,16 @@ function buildLaunchCommand(
 export async function launchAgent(
 	launch: AgentLaunchConfig,
 	projectDir: string,
+	context?: AgentLaunchContext,
 ): Promise<{ success: boolean; error?: string; command?: string[]; exitCode?: number | null }> {
-	const launchCommand = buildLaunchCommand(launch, projectDir);
+	const launchCommand = buildLaunchCommand(launch, projectDir, context);
 	if (!launchCommand) {
 		return { success: false, error: "No supported launch command found" };
 	}
 
 	const { command, args, options, waitForExit } = launchCommand;
 	const displayCommand = [command, ...args];
+	restoreTty();
 
 	return await new Promise((resolve) => {
 		const child = spawn(command, args, options);
@@ -543,3 +574,340 @@ export function getDefaultPreferredAgent(
 
 	return withPriority[0]?.id ?? null;
 }
+
+/**
+ * Agents that support one-shot mode (non-interactive execution)
+ */
+export const ONE_SHOT_CAPABLE_AGENTS = ["claude-code", "codex"] as const;
+type OneShotAgent = (typeof ONE_SHOT_CAPABLE_AGENTS)[number];
+
+/**
+ * Check if an agent supports one-shot mode
+ */
+export function isOneShotCapable(agentId: string): agentId is OneShotAgent {
+	return ONE_SHOT_CAPABLE_AGENTS.includes(agentId as OneShotAgent);
+}
+
+/**
+ * Get preferred agent for one-shot execution
+ * Returns null if no capable agent is available
+ */
+export async function getOneShotAgent(): Promise<OneShotAgent | null> {
+	const preferred = await getPreferredAgent();
+
+	if (preferred && isOneShotCapable(preferred)) {
+		return preferred;
+	}
+
+	// Try to find any capable agent that's installed
+	for (const agentId of ONE_SHOT_CAPABLE_AGENTS) {
+		const launch = await getAgentLaunch(agentId);
+		if (launch) {
+			return agentId;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Build customization prompt for project personalization
+ */
+function buildCustomizationPrompt(projectDir: string, intent: string): string {
+	return `You are customizing a new project based on this intent: "${intent}"
+
+This is the first customization from a template. The project has been scaffolded but not yet personalized.
+
+Instructions:
+1. Read AGENTS.md and CLAUDE.md for project context
+2. Modify code and configuration to match the intent
+3. Focus on code/config changes, not documentation
+4. Keep changes minimal and focused
+5. End with a short report:
+   - SUMMARY: 2-4 bullet points
+   - BLOCKER: none | <short reason>
+
+Project directory: ${projectDir}
+
+Please customize the project to match the intent.`;
+}
+
+/**
+ * Run agent in one-shot mode for project customization
+ */
+export async function runAgentOneShot(
+	agentId: OneShotAgent,
+	projectDir: string,
+	intent: string,
+	reporter?: OneShotReporter,
+): Promise<{ success: boolean; error?: string }> {
+	const launch = await getAgentLaunch(agentId);
+	if (!launch || launch.type !== "cli") {
+		return { success: false, error: `Agent ${agentId} not available` };
+	}
+
+	const prompt = buildCustomizationPrompt(projectDir, intent);
+	const debugEnabled = isDebug();
+	const agentLabel = getAgentDefinition(agentId)?.name ?? agentId;
+
+	// Build command based on agent type
+	let args: string[];
+	let streamJson = false;
+	let jsonMode: "claude" | "codex" | null = null;
+	if (agentId === "claude-code") {
+		streamJson = true;
+		jsonMode = "claude";
+		args = [
+			"-p",
+			prompt,
+			"--permission-mode",
+			"acceptEdits",
+			"--output-format",
+			"stream-json",
+			"--include-partial-messages",
+			"--verbose",
+		];
+		if (debugEnabled) {
+			args.push("--debug");
+		}
+	} else if (agentId === "codex") {
+		streamJson = true;
+		jsonMode = "codex";
+		args = ["exec", prompt, "--json", "--skip-git-repo-check"];
+	} else {
+		return { success: false, error: `Unsupported agent: ${agentId}` };
+	}
+
+	if (debugEnabled) {
+		debug("One-shot agent command", { command: launch.command, args, cwd: projectDir });
+		debug("One-shot prompt", prompt);
+	}
+
+	restoreTty();
+
+	return new Promise((resolve) => {
+		const child = spawn(launch.command, args, {
+			cwd: projectDir,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+
+		let stdoutBuffer = "";
+		let stderrBuffer = "";
+		let fullOutput = "";
+		const summaryLines: string[] = [];
+		let blockerMessage: string | null = null;
+		let statusMessage: string | null = null;
+
+		const reportSummary = () => {
+			if (!reporter) return;
+			if (summaryLines.length > 0) {
+				reporter.info(`Summary: ${summaryLines.join(" | ")}`);
+			}
+			if (blockerMessage && blockerMessage.toLowerCase() !== "none") {
+				reporter.warn(`Blocker: ${blockerMessage}`);
+			}
+		};
+
+		const updateStatus = (message: string) => {
+			if (!reporter?.status) return;
+			const next = `${agentLabel}: ${message}`;
+			if (next === statusMessage) return;
+			statusMessage = next;
+			reporter.status(next);
+		};
+
+		const extractSummary = (text: string) => {
+			const lines = text.split(/\r?\n/).map((line) => line.trim());
+			let inSummary = false;
+
+			for (const line of lines) {
+				if (!line) {
+					if (inSummary) {
+						inSummary = false;
+					}
+					continue;
+				}
+
+				if (line.toUpperCase().startsWith("SUMMARY:")) {
+					inSummary = true;
+					const after = line.slice("SUMMARY:".length).trim();
+					if (after) {
+						summaryLines.push(after.replace(/^[-•]\s*/, ""));
+					}
+					continue;
+				}
+
+				if (line.toUpperCase().startsWith("BLOCKER:")) {
+					blockerMessage = line.slice("BLOCKER:".length).trim();
+					inSummary = false;
+					continue;
+				}
+
+				if (inSummary) {
+					summaryLines.push(line.replace(/^[-•]\s*/, ""));
+				}
+			}
+		};
+
+		const handleClaudeLine = (line: string) => {
+			if (!line.trim()) return;
+			if (debugEnabled) {
+				process.stderr.write(`${line}\n`);
+			}
+			try {
+				const parsed = JSON.parse(line) as {
+					type?: string;
+					event?: {
+						type?: string;
+						content_block?: { type?: string; name?: string };
+						delta?: { type?: string; text_delta?: string };
+					};
+					result?: string;
+					is_error?: boolean;
+					permission_denials?: Array<{ reason?: string }>;
+				};
+
+				if (parsed.type === "result") {
+					if (typeof parsed.result === "string" && parsed.result.trim().length > 0) {
+						fullOutput = parsed.result;
+					}
+					if (parsed.permission_denials?.length && reporter) {
+						const details = parsed.permission_denials
+							.map((denial) => denial.reason)
+							.filter(Boolean)
+							.join(" | ");
+						reporter.warn(details ? `Permission denied: ${details}` : "Permission denied");
+						updateStatus("permission denied");
+					}
+					if (parsed.is_error) {
+						stderrBuffer = stderrBuffer || "Claude returned an error";
+					}
+					return;
+				}
+
+				if (parsed.type === "stream_event") {
+					const eventType = parsed.event?.type;
+					const blockType = parsed.event?.content_block?.type;
+					if (eventType === "message_start") {
+						updateStatus("thinking");
+					} else if (eventType === "content_block_start") {
+						if (blockType === "tool_use") {
+							const toolName = parsed.event?.content_block?.name;
+							updateStatus(toolName ? `running ${toolName}` : "running tool");
+						} else if (blockType === "text") {
+							updateStatus("responding");
+						}
+					} else if (eventType === "message_stop") {
+						updateStatus("finalizing");
+					}
+					const delta = parsed.event?.delta;
+					if (delta?.type === "text_delta" && delta.text_delta) {
+						fullOutput += delta.text_delta;
+					}
+				}
+			} catch {
+				// Ignore malformed lines in non-debug mode
+			}
+		};
+
+		const handleCodexLine = (line: string) => {
+			if (!line.trim()) return;
+			if (debugEnabled) {
+				process.stderr.write(`${line}\n`);
+			}
+			try {
+				const parsed = JSON.parse(line) as {
+					type?: string;
+					item?: { type?: string; text?: string };
+					error?: { message?: string };
+				};
+
+				if (parsed.type === "thread.started") {
+					updateStatus("starting");
+				}
+				if (parsed.type === "turn.started") {
+					updateStatus("thinking");
+				}
+
+				if (parsed.type === "item.completed" && parsed.item?.type === "agent_message") {
+					if (parsed.item.text) {
+						fullOutput += parsed.item.text;
+					}
+					updateStatus("responding");
+				}
+				if (parsed.type === "item.completed" && parsed.item?.type === "reasoning") {
+					updateStatus("reasoning");
+				}
+
+				if (parsed.type === "error") {
+					if (parsed.error?.message) {
+						stderrBuffer = parsed.error.message;
+					} else {
+						stderrBuffer = stderrBuffer || "Codex returned an error";
+					}
+					updateStatus("error");
+				}
+				if (parsed.type === "turn.completed") {
+					updateStatus("finalizing");
+				}
+			} catch {
+				// Ignore malformed lines in non-debug mode
+			}
+		};
+
+		const handleJsonLine =
+			jsonMode === "claude" ? handleClaudeLine : jsonMode === "codex" ? handleCodexLine : null;
+
+		child.stdout.on("data", (chunk) => {
+			const text = chunk.toString();
+			if (!streamJson) {
+				fullOutput += text;
+				if (debugEnabled) {
+					process.stderr.write(text);
+				}
+				return;
+			}
+
+			stdoutBuffer += text;
+			let newlineIndex = stdoutBuffer.indexOf("\n");
+			while (newlineIndex !== -1) {
+				const line = stdoutBuffer.slice(0, newlineIndex);
+				stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
+				handleJsonLine?.(line);
+				newlineIndex = stdoutBuffer.indexOf("\n");
+			}
+		});
+
+		child.stderr.on("data", (chunk) => {
+			const text = chunk.toString();
+			stderrBuffer += text;
+			if (debugEnabled) {
+				process.stderr.write(text);
+			}
+		});
+
+		child.once("error", (err) => {
+			resolve({ success: false, error: err.message });
+		});
+
+		child.once("exit", (code) => {
+			if (streamJson && stdoutBuffer.trim().length > 0) {
+				handleJsonLine?.(stdoutBuffer);
+				stdoutBuffer = "";
+			}
+
+			const exitOk = code === 0;
+			if (!debugEnabled && fullOutput.trim().length > 0) {
+				extractSummary(fullOutput);
+				reportSummary();
+			}
+
+			if (!exitOk && stderrBuffer.trim().length > 0) {
+				resolve({ success: false, error: stderrBuffer.trim() });
+				return;
+			}
+
+			resolve(exitOk ? { success: true } : { success: false, error: `Exit code ${code}` });
+		});
+	});
+}

package/src/lib/asset-hash.ts

@@ -0,0 +1,50 @@
+/**
+ * Asset hash computation utilities for content-addressable asset management.
+ * Uses SHA-256 hashing with base64 content and file extension.
+ */
+
+/**
+ * Represents a single entry in the asset manifest.
+ */
+export interface AssetManifestEntry {
+	hash: string;
+	size: number;
+}
+
+/**
+ * Maps asset paths to their manifest entries.
+ */
+export type AssetManifest = Record<string, AssetManifestEntry>;
+
+/**
+ * Computes a content-addressable hash for an asset.
+ *
+ * Algorithm: SHA-256(base64(content) + extension).slice(0, 32)
+ * - Extension is extracted from filePath without the leading dot
+ * - Uses Web Crypto API for SHA-256 computation
+ *
+ * @param content - The raw binary content of the asset
+ * @param filePath - The file path used to extract the extension
+ * @returns A 32-character hex hash string
+ */
+export async function computeAssetHash(content: Uint8Array, filePath: string): Promise<string> {
+	// Extract extension without the dot (e.g., "js" not ".js")
+	const extension = filePath.includes(".") ? filePath.split(".").pop() || "" : "";
+
+	// Convert content to base64
+	const base64 = Buffer.from(content).toString("base64");
+
+	// Create hash input: base64 content + extension
+	const hashInput = new TextEncoder().encode(base64 + extension);
+
+	// Compute SHA-256 hash using Web Crypto API
+	const hashBuffer = await crypto.subtle.digest("SHA-256", hashInput);
+
+	// Convert to hex string and truncate to 32 characters
+	const hashArray = new Uint8Array(hashBuffer);
+	const hashHex = Array.from(hashArray)
+		.map((b) => b.toString(16).padStart(2, "0"))
+		.join("");
+
+	return hashHex.slice(0, 32);
+}

package/src/lib/auth/client.ts

@@ -0,0 +1,115 @@
+import { getAuthApiUrl } from "./constants.ts";
+import { type AuthCredentials, getCredentials, isTokenExpired, saveCredentials } from "./store.ts";
+
+export interface DeviceAuthResponse {
+	device_code: string;
+	user_code: string;
+	verification_uri: string;
+	verification_uri_complete: string;
+	expires_in: number;
+	interval: number;
+}
+
+export interface TokenResponse {
+	access_token: string;
+	refresh_token: string;
+	expires_in: number;
+	user: {
+		id: string;
+		email: string;
+		first_name: string | null;
+		last_name: string | null;
+	};
+}
+
+export async function startDeviceAuth(): Promise<DeviceAuthResponse> {
+	const response = await fetch(`${getAuthApiUrl()}/auth/device/authorize`, {
+		method: "POST",
+	});
+
+	if (!response.ok) {
+		const errorBody = (await response.json().catch(() => ({}))) as { message?: string };
+		throw new Error(errorBody.message || "Failed to start device authorization");
+	}
+
+	return response.json() as Promise<DeviceAuthResponse>;
+}
+
+export async function pollDeviceToken(deviceCode: string): Promise<TokenResponse | null> {
+	const response = await fetch(`${getAuthApiUrl()}/auth/device/token`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ device_code: deviceCode }),
+	});
+
+	if (response.status === 202) {
+		return null;
+	}
+
+	if (response.status === 410) {
+		throw new Error("Device code expired. Please try again.");
+	}
+
+	if (!response.ok) {
+		const errorBody = (await response.json().catch(() => ({}))) as { message?: string };
+		throw new Error(errorBody.message || "Failed to get token");
+	}
+
+	return response.json() as Promise<TokenResponse>;
+}
+
+export async function refreshToken(refreshTokenValue: string): Promise<TokenResponse> {
+	const response = await fetch(`${getAuthApiUrl()}/auth/refresh`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ refresh_token: refreshTokenValue }),
+	});
+
+	if (!response.ok) {
+		throw new Error("Failed to refresh token. Please login again.");
+	}
+
+	return response.json() as Promise<TokenResponse>;
+}
+
+export async function getValidAccessToken(): Promise<string | null> {
+	const creds = await getCredentials();
+	if (!creds) {
+		return null;
+	}
+
+	if (isTokenExpired(creds)) {
+		try {
+			const newTokens = await refreshToken(creds.refresh_token);
+			// Default to 5 minutes if expires_in not provided
+			const expiresIn = newTokens.expires_in ?? 300;
+			const newCreds: AuthCredentials = {
+				access_token: newTokens.access_token,
+				refresh_token: newTokens.refresh_token,
+				expires_at: Math.floor(Date.now() / 1000) + expiresIn,
+				user: newTokens.user,
+			};
+			await saveCredentials(newCreds);
+			return newCreds.access_token;
+		} catch {
+			return null;
+		}
+	}
+
+	return creds.access_token;
+}
+
+export async function authFetch(url: string, options: RequestInit = {}): Promise<Response> {
+	const token = await getValidAccessToken();
+	if (!token) {
+		throw new Error("Not authenticated. Run 'jack login' first.");
+	}
+
+	return fetch(url, {
+		...options,
+		headers: {
+			...options.headers,
+			Authorization: `Bearer ${token}`,
+		},
+	});
+}

package/src/lib/auth/constants.ts

@@ -0,0 +1,5 @@
+export const AUTH_API_URL = "https://auth.getjack.org";
+
+export function getAuthApiUrl(): string {
+	return process.env.JACK_AUTH_URL || AUTH_API_URL;
+}

package/src/lib/auth/guard.ts

@@ -0,0 +1,57 @@
+import { JackError, JackErrorCode } from "../errors.ts";
+import { info } from "../output.ts";
+import { getValidAccessToken } from "./client.ts";
+import { getCredentials } from "./store.ts";
+
+/**
+ * Require auth - throws error if not logged in (for non-interactive contexts)
+ */
+export async function requireAuth(): Promise<string> {
+	const token = await getValidAccessToken();
+
+	if (!token) {
+		throw new JackError(
+			JackErrorCode.AUTH_FAILED,
+			"Not logged in",
+			"Run 'jack login' to sign in to jack cloud",
+		);
+	}
+
+	return token;
+}
+
+/**
+ * Require auth with auto-login - starts login flow if needed (omakase style)
+ * Use this for interactive CLI commands that need auth.
+ */
+export async function requireAuthOrLogin(): Promise<string> {
+	const token = await getValidAccessToken();
+
+	if (token) {
+		return token;
+	}
+
+	// Auto-start login flow
+	info("Signing in to jack cloud...");
+
+	const { default: login } = await import("../../commands/login.ts");
+	await login({ silent: true });
+
+	// After login, get the token
+	const newToken = await getValidAccessToken();
+	if (!newToken) {
+		throw new JackError(
+			JackErrorCode.AUTH_FAILED,
+			"Login failed",
+			"Please try again with 'jack login'",
+		);
+	}
+
+	console.error(""); // Space before continuing with original command
+	return newToken;
+}
+
+export async function getCurrentUser() {
+	const creds = await getCredentials();
+	return creds?.user ?? null;
+}