@getjack/jack 0.1.0 → 0.1.1

package/src/lib/agents.ts

@@ -1,6 +1,8 @@
 import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
 import { homedir } from "node:os";
-import { type AgentConfig, readConfig, writeConfig } from "./config.ts";
+import { delimiter, extname, join } from "node:path";
+import { type AgentConfig, type AgentLaunchConfig, readConfig, writeConfig } from "./config.ts";
 
 // Re-export AgentConfig for consumers
 export type { AgentConfig } from "./config.ts";
@@ -20,16 +22,20 @@ export interface ProjectFile {
 export interface AgentDefinition {
 	id: string;
 	name: string;
-	searchPaths: string[];
 	projectFiles: ProjectFile[];
 	priority: number; // Lower = higher priority for default selection (claude-code=1, codex=2, etc.)
+	launch?: AgentLaunchDefinition;
+}
+
+export interface AgentLaunchDefinition {
+	cliCommands?: Array<{ command: string; args?: string[] }>;
 }
 
 /**
  * Result of scanning for agents
  */
 export interface DetectionResult {
-	detected: Array<{ id: string; path: string }>;
+	detected: Array<{ id: string; path: string; launch?: AgentLaunchConfig }>;
 	total: number;
 }
 
@@ -51,11 +57,9 @@ export const AGENT_REGISTRY: AgentDefinition[] = [
 		id: "claude-code",
 		name: "Claude Code",
 		priority: 1,
-		searchPaths: [
-			"~/.claude",
-			"~/.config/claude",
-			"%APPDATA%/Claude", // Windows
-		],
+		launch: {
+			cliCommands: [{ command: "claude" }],
+		},
 		projectFiles: [
 			{ path: "CLAUDE.md", template: "claude-md" },
 			{ path: "AGENTS.md", template: "agents-md", shared: true },
@@ -65,41 +69,11 @@ export const AGENT_REGISTRY: AgentDefinition[] = [
 		id: "codex",
 		name: "Codex",
 		priority: 2,
-		searchPaths: [
-			"~/.codex",
-			"%APPDATA%/codex", // Windows
-		],
+		launch: {
+			cliCommands: [{ command: "codex" }],
+		},
 		projectFiles: [{ path: "AGENTS.md", template: "agents-md", shared: true }],
 	},
-	{
-		id: "cursor",
-		name: "Cursor",
-		priority: 10,
-		searchPaths: [
-			"/Applications/Cursor.app",
-			"~/.cursor",
-			"%PROGRAMFILES%/Cursor", // Windows
-			"/usr/share/cursor", // Linux
-		],
-		projectFiles: [
-			{ path: ".cursorrules", template: "cursorrules" },
-			{ path: "AGENTS.md", template: "agents-md", shared: true },
-		],
-	},
-	{
-		id: "windsurf",
-		name: "Windsurf",
-		priority: 10,
-		searchPaths: [
-			"/Applications/Windsurf.app",
-			"~/.windsurf",
-			"%PROGRAMFILES%/Windsurf", // Windows
-		],
-		projectFiles: [
-			{ path: ".windsurfrules", template: "windsurfrules" },
-			{ path: "AGENTS.md", template: "agents-md", shared: true },
-		],
-	},
 ];
 
 /**
@@ -127,6 +101,72 @@ export function pathExists(path: string): boolean {
 	}
 }
 
+function findExecutable(command: string): string | null {
+	const expanded = expandPath(command);
+	if (expanded.includes("/") || expanded.includes("\\")) {
+		return existsSync(expanded) ? expanded : null;
+	}
+
+	const pathEnv = process.env.PATH ?? "";
+	const paths = pathEnv.split(delimiter).filter(Boolean);
+
+	if (process.platform === "win32") {
+		const extension = extname(command);
+		const extensions =
+			extension.length > 0
+				? [""]
+				: (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";");
+
+		for (const basePath of paths) {
+			for (const ext of extensions) {
+				const candidate = join(basePath, `${command}${ext}`);
+				if (existsSync(candidate)) {
+					return candidate;
+				}
+			}
+		}
+		return null;
+	}
+
+	for (const basePath of paths) {
+		const candidate = join(basePath, command);
+		if (existsSync(candidate)) {
+			return candidate;
+		}
+	}
+
+	return null;
+}
+
+function resolveCliLaunch(definition: AgentDefinition): AgentLaunchConfig | null {
+	const candidates = definition.launch?.cliCommands ?? [];
+	for (const candidate of candidates) {
+		const resolved = findExecutable(candidate.command);
+		if (resolved) {
+			return { type: "cli", command: resolved, args: candidate.args };
+		}
+	}
+	return null;
+}
+
+function resolveAgentLaunch(definition: AgentDefinition): AgentLaunchConfig | null {
+	return resolveCliLaunch(definition);
+}
+
+function normalizeLaunchConfig(launch: AgentLaunchConfig): AgentLaunchConfig | null {
+	if (launch.type === "cli") {
+		const resolved = findExecutable(launch.command);
+		if (!resolved) return null;
+		return { type: "cli", command: resolved, args: launch.args };
+	}
+	return null;
+}
+
+function getLaunchPath(launch: AgentLaunchConfig): string | null {
+	if (launch.type === "cli") return launch.command;
+	return null;
+}
+
 /**
  * Get agent definition by ID
  */
@@ -135,17 +175,16 @@ export function getAgentDefinition(id: string): AgentDefinition | undefined {
 }
 
 /**
- * Scan for installed agents by checking known paths
+ * Scan for installed agents by checking launch commands
  */
 export async function scanAgents(): Promise<DetectionResult> {
-	const detected: Array<{ id: string; path: string }> = [];
+	const detected: Array<{ id: string; path: string; launch?: AgentLaunchConfig }> = [];
 
 	for (const agent of AGENT_REGISTRY) {
-		for (const searchPath of agent.searchPaths) {
-			if (pathExists(searchPath)) {
-				detected.push({ id: agent.id, path: expandPath(searchPath) });
-				break; // Use first found path
-			}
+		const launch = resolveAgentLaunch(agent);
+		const installPath = launch ? getLaunchPath(launch) : null;
+		if (launch && installPath && pathExists(installPath)) {
+			detected.push({ id: agent.id, path: installPath, launch });
 		}
 	}
 
@@ -194,25 +233,25 @@ export async function updateAgent(id: string, config: AgentConfig): Promise<void
 /**
  * Add agent to config (auto-detect or use custom path)
  */
-export async function addAgent(id: string, path?: string): Promise<void> {
+export async function addAgent(
+	id: string,
+	options: { launch?: AgentLaunchConfig } = {},
+): Promise<void> {
 	const definition = getAgentDefinition(id);
 	if (!definition) {
 		throw new Error(`Unknown agent: ${id}`);
 	}
 
-	// If no custom path, try to detect
-	let detectedPath = path;
-	if (!detectedPath) {
-		for (const searchPath of definition.searchPaths) {
-			if (pathExists(searchPath)) {
-				detectedPath = expandPath(searchPath);
-				break;
-			}
-		}
+	const launchOverride = options.launch ? normalizeLaunchConfig(options.launch) : null;
+	const detectedLaunch = launchOverride ?? resolveAgentLaunch(definition);
+	const detectedPath = detectedLaunch ? getLaunchPath(detectedLaunch) : null;
+
+	if (!detectedLaunch) {
+		throw new Error(`Could not detect ${definition.name}`);
 	}
 
 	if (!detectedPath) {
-		throw new Error(`Could not detect ${definition.name}`);
+		throw new Error(`Could not determine install path for ${definition.name}`);
 	}
 
 	if (!pathExists(detectedPath)) {
@@ -221,8 +260,9 @@ export async function addAgent(id: string, path?: string): Promise<void> {
 
 	await updateAgent(id, {
 		active: true,
-		path: detectedPath,
+		path: expandPath(detectedPath),
 		detectedAt: new Date().toISOString(),
+		launch: detectedLaunch,
 	});
 }
 
@@ -287,10 +327,12 @@ export async function validateAgentPaths(): Promise<ValidationResult> {
 
 	for (const [id, agentConfig] of Object.entries(agents)) {
 		if (agentConfig.active) {
-			if (pathExists(agentConfig.path)) {
-				valid.push({ id, path: agentConfig.path });
+			const launch = agentConfig.launch ? normalizeLaunchConfig(agentConfig.launch) : null;
+			const path = launch ? getLaunchPath(launch) : agentConfig.path;
+			if (launch && path && pathExists(path)) {
+				valid.push({ id, path });
 			} else {
-				invalid.push({ id, path: agentConfig.path });
+				invalid.push({ id, path: path ?? agentConfig.path });
 			}
 		}
 	}
@@ -298,6 +340,138 @@ export async function validateAgentPaths(): Promise<ValidationResult> {
 	return { valid, invalid };
 }
 
+function launchConfigsEqual(
+	left?: AgentLaunchConfig | null,
+	right?: AgentLaunchConfig | null,
+): boolean {
+	if (!left || !right) return left === right;
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+
+export async function getAgentLaunch(id: string): Promise<AgentLaunchConfig | null> {
+	const definition = getAgentDefinition(id);
+	if (!definition) return null;
+
+	const config = await readConfig();
+	const agentConfig = config?.agents?.[id];
+
+	const normalized = agentConfig?.launch ? normalizeLaunchConfig(agentConfig.launch) : null;
+	if (normalized) {
+		if (agentConfig && config && !launchConfigsEqual(normalized, agentConfig.launch)) {
+			agentConfig.launch = normalized;
+			await writeConfig(config);
+		}
+		return normalized;
+	}
+
+	const resolved = resolveAgentLaunch(definition);
+	if (resolved && agentConfig && config) {
+		if (!launchConfigsEqual(resolved, agentConfig.launch)) {
+			agentConfig.launch = resolved;
+			await writeConfig(config);
+		}
+	}
+	return resolved ?? null;
+}
+
+export async function getPreferredLaunchAgent(): Promise<
+	| {
+			id: string;
+			definition: AgentDefinition;
+			launch: AgentLaunchConfig;
+	  }
+	| null
+> {
+	const config = await readConfig();
+	if (!config?.agents) return null;
+
+	const activeAgents: Array<{ id: string; config: AgentConfig; definition: AgentDefinition }> = [];
+	for (const [id, agentConfig] of Object.entries(config.agents)) {
+		if (!agentConfig.active) continue;
+		const definition = getAgentDefinition(id);
+		if (definition) {
+			activeAgents.push({ id, config: agentConfig, definition });
+		}
+	}
+
+	if (activeAgents.length === 0) return null;
+
+	if (config.preferredAgent) {
+		const preferred = activeAgents.find((agent) => agent.id === config.preferredAgent);
+		if (preferred) {
+			const launch = await getAgentLaunch(preferred.id);
+			if (launch) {
+				return { id: preferred.id, definition: preferred.definition, launch };
+			}
+		}
+	}
+
+	activeAgents.sort((a, b) => a.definition.priority - b.definition.priority);
+	for (const agent of activeAgents) {
+		const launch = await getAgentLaunch(agent.id);
+		if (launch) {
+			return { id: agent.id, definition: agent.definition, launch };
+		}
+	}
+
+	return null;
+}
+
+function buildLaunchCommand(
+	launch: AgentLaunchConfig,
+	projectDir: string,
+):
+	| {
+			command: string;
+			args: string[];
+			options: { cwd?: string; stdio: "inherit" | "ignore"; detached?: boolean };
+			waitForExit: boolean;
+	  }
+	| null {
+	if (launch.type !== "cli") return null;
+
+	return {
+		command: launch.command,
+		args: launch.args ?? [],
+		options: { cwd: projectDir, stdio: "inherit" },
+		waitForExit: true,
+	};
+}
+
+export async function launchAgent(
+	launch: AgentLaunchConfig,
+	projectDir: string,
+): Promise<{ success: boolean; error?: string; command?: string[]; exitCode?: number | null }> {
+	const launchCommand = buildLaunchCommand(launch, projectDir);
+	if (!launchCommand) {
+		return { success: false, error: "No supported launch command found" };
+	}
+
+	const { command, args, options, waitForExit } = launchCommand;
+	const displayCommand = [command, ...args];
+
+	return await new Promise((resolve) => {
+		const child = spawn(command, args, options);
+
+		child.once("error", (err) => {
+			resolve({ success: false, error: err.message, command: displayCommand });
+		});
+
+		child.once("spawn", () => {
+			if (!waitForExit) {
+				child.unref();
+				resolve({ success: true, command: displayCommand });
+			}
+		});
+
+		if (waitForExit) {
+			child.once("exit", (code) => {
+				resolve({ success: true, command: displayCommand, exitCode: code });
+			});
+		}
+	});
+}
+
 /**
  * Get the user's preferred agent ID
  * Falls back to highest priority detected agent if not set
@@ -355,7 +529,7 @@ export async function setPreferredAgent(id: string): Promise<void> {
  * Used during jack init to set initial preference
  */
 export function getDefaultPreferredAgent(
-	detected: Array<{ id: string; path: string }>,
+	detected: Array<{ id: string; path: string; launch?: AgentLaunchConfig }>,
 ): string | null {
 	if (detected.length === 0) return null;
 

package/src/lib/cloudflare-api.ts

@@ -34,10 +34,11 @@ export async function checkWorkerExists(name: string): Promise<boolean> {
  * Delete a worker with force flag (no confirmation)
  */
 export async function deleteWorker(name: string): Promise<void> {
-	const result = await $`wrangler delete ${name} --force`.nothrow().quiet();
+	const result = await $`wrangler delete --name ${name} --force`.nothrow().quiet();
 
 	if (result.exitCode !== 0) {
-		throw new Error(`Failed to delete worker ${name}`);
+		const stderr = result.stderr.toString().trim();
+		throw new Error(stderr || `Failed to delete worker ${name}`);
 	}
 }
 

package/src/lib/config.ts

@@ -6,10 +6,18 @@ import { join } from "node:path";
 /**
  * Agent configuration stored in jack config
  */
+export type AgentLaunchConfig =
+	| {
+			type: "cli";
+			command: string;
+			args?: string[];
+	  };
+
 export interface AgentConfig {
 	active: boolean;
 	path: string;
 	detectedAt: string;
+	launch?: AgentLaunchConfig;
 }
 
 /**

package/src/lib/errors.ts

@@ -0,0 +1,53 @@
+export enum JackErrorCode {
+	AUTH_FAILED = "AUTH_FAILED",
+	WRANGLER_AUTH_EXPIRED = "WRANGLER_AUTH_EXPIRED",
+	PROJECT_NOT_FOUND = "PROJECT_NOT_FOUND",
+	TEMPLATE_NOT_FOUND = "TEMPLATE_NOT_FOUND",
+	BUILD_FAILED = "BUILD_FAILED",
+	DEPLOY_FAILED = "DEPLOY_FAILED",
+	VALIDATION_ERROR = "VALIDATION_ERROR",
+	INTERNAL_ERROR = "INTERNAL_ERROR",
+}
+
+export interface JackErrorMeta {
+	exitCode?: number;
+	missingSecrets?: string[];
+	stderr?: string;
+	reported?: boolean;
+}
+
+export class JackError extends Error {
+	code: JackErrorCode;
+	suggestion?: string;
+	meta?: JackErrorMeta;
+
+	constructor(code: JackErrorCode, message: string, suggestion?: string, meta?: JackErrorMeta) {
+		super(message);
+		this.name = "JackError";
+		this.code = code;
+		this.suggestion = suggestion;
+		this.meta = meta;
+	}
+}
+
+export function isJackError(error: unknown): error is JackError {
+	return error instanceof JackError;
+}
+
+export function getErrorDetails(error: unknown): {
+	message: string;
+	suggestion?: string;
+	meta?: JackErrorMeta;
+	code?: JackErrorCode;
+} {
+	if (isJackError(error)) {
+		return {
+			message: error.message,
+			suggestion: error.suggestion,
+			meta: error.meta,
+			code: error.code,
+		};
+	}
+
+	return { message: error instanceof Error ? error.message : String(error) };
+}

package/src/lib/hooks.ts

@@ -1,7 +1,6 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { HookAction } from "../templates/types";
-import { output } from "./output";
 import { getSavedSecrets } from "./secrets";
 
 export interface HookContext {
@@ -11,6 +10,27 @@ export interface HookContext {
 	projectDir?: string; // absolute path to project directory
 }
 
+export interface HookOutput {
+	info(message: string): void;
+	warn(message: string): void;
+	error(message: string): void;
+	success(message: string): void;
+	box(title: string, lines: string[]): void;
+}
+
+export interface HookOptions {
+	interactive?: boolean;
+	output?: HookOutput;
+}
+
+const noopOutput: HookOutput = {
+	info() {},
+	warn() {},
+	error() {},
+	success() {},
+	box() {},
+};
+
 /**
  * Prompt user with numbered options (Claude Code style)
  * Returns the selected option index (0-based) or -1 if cancelled
@@ -197,99 +217,127 @@ async function checkEnvExists(env: string, projectDir?: string): Promise<boolean
  * Execute a single hook action
  * Returns true if should continue, false if should abort
  */
-async function executeAction(action: HookAction, context: HookContext): Promise<boolean> {
+async function executeAction(
+	action: HookAction,
+	context: HookContext,
+	options?: HookOptions,
+): Promise<boolean> {
+	const interactive = options?.interactive !== false;
+	const ui = options?.output ?? noopOutput;
+
 	switch (action.action) {
 		case "message": {
-			output.info(substituteVars(action.text, context));
+			ui.info(substituteVars(action.text, context));
 			return true;
 		}
 
 		case "box": {
 			const title = substituteVars(action.title, context);
 			const lines = action.lines.map((line) => substituteVars(line, context));
-			output.box(title, lines);
+			ui.box(title, lines);
 			return true;
 		}
 
-		case "link": {
+		case "url": {
 			const url = substituteVars(action.url, context);
 			const label = action.label ?? "Link";
+			if (!interactive) {
+				ui.info(`${label}: ${url}`);
+				return true;
+			}
 			console.error("");
 			console.error(`  ${label}: \x1b[36m${url}\x1b[0m`);
 
+			if (action.open) {
+				ui.info(`Opening: ${url}`);
+				await openBrowser(url);
+				return true;
+			}
+
 			if (action.prompt !== false) {
 				console.error("");
 				const choice = await promptSelect(["Open in browser", "Skip"]);
 				if (choice === 0) {
 					await openBrowser(url);
-					output.success("Opened in browser");
+					ui.success("Opened in browser");
 				}
 			}
 			return true;
 		}
 
-		case "open": {
-			const url = substituteVars(action.url, context);
-			output.info(`Opening: ${url}`);
-			await openBrowser(url);
-			return true;
-		}
-
-		case "checkSecret": {
-			const result = await checkSecretExists(action.secret, context.projectDir);
-			if (!result.exists) {
-				const message = action.message ?? `Missing required secret: ${action.secret}`;
-				output.error(message);
-				output.info(`Run: jack secrets add ${action.secret}`);
-
-				// Offer to open setup URL if provided
-				if (action.setupUrl) {
-					console.error("");
-					const choice = await promptSelect(["Open setup page", "Skip"]);
-					if (choice === 0) {
-						await openBrowser(action.setupUrl);
+		case "require": {
+			if (action.source === "secret") {
+				const result = await checkSecretExists(action.key, context.projectDir);
+				if (!result.exists) {
+					const message = action.message ?? `Missing required secret: ${action.key}`;
+					ui.error(message);
+					ui.info(`Run: jack secrets add ${action.key}`);
+
+					if (action.setupUrl) {
+						if (interactive) {
+							console.error("");
+							const choice = await promptSelect(["Open setup page", "Skip"]);
+							if (choice === 0) {
+								await openBrowser(action.setupUrl);
+							}
+						} else {
+							ui.info(`Setup: ${action.setupUrl}`);
+						}
 					}
+					return false;
 				}
-				return false;
+				return true;
 			}
-			return true;
-		}
 
-		case "checkEnv": {
-			const exists = await checkEnvExists(action.env, context.projectDir);
+			const exists = await checkEnvExists(action.key, context.projectDir);
 			if (!exists) {
-				const message = action.message ?? `Missing required env var: ${action.env}`;
-				output.error(message);
+				const message = action.message ?? `Missing required env var: ${action.key}`;
+				ui.error(message);
+				if (action.setupUrl) {
+					ui.info(`Setup: ${action.setupUrl}`);
+				}
 				return false;
 			}
 			return true;
 		}
 
-		case "copy": {
+		case "clipboard": {
 			const text = substituteVars(action.text, context);
+			if (!interactive) {
+				ui.info(text);
+				return true;
+			}
 			const success = await copyToClipboard(text);
 			if (success) {
 				const message = action.message ?? "Copied to clipboard";
-				output.success(message);
+				ui.success(message);
 			} else {
-				output.warn("Could not copy to clipboard");
+				ui.warn("Could not copy to clipboard");
 			}
 			return true;
 		}
 
-		case "wait": {
+		case "pause": {
+			if (!interactive) {
+				return true;
+			}
 			await waitForEnter(action.message);
 			return true;
 		}
 
-		case "run": {
+		case "shell": {
 			const command = substituteVars(action.command, context);
 			if (action.message) {
-				output.info(action.message);
+				ui.info(action.message);
 			}
 			const cwd = action.cwd === "project" ? context.projectDir : undefined;
+			// Resume stdin in case previous prompts paused it
+			if (interactive) {
+				process.stdin.resume();
+			}
 			const proc = Bun.spawn(["sh", "-c", command], {
 				cwd,
+				stdin: interactive ? "inherit" : "ignore",
 				stdout: "inherit",
 				stderr: "inherit",
 			});
@@ -306,9 +354,13 @@ async function executeAction(action: HookAction, context: HookContext): Promise<
  * Run a list of hook actions
  * Returns true if all succeeded, false if any failed (for preDeploy checks)
  */
-export async function runHook(actions: HookAction[], context: HookContext): Promise<boolean> {
+export async function runHook(
+	actions: HookAction[],
+	context: HookContext,
+	options?: HookOptions,
+): Promise<boolean> {
 	for (const action of actions) {
-		const shouldContinue = await executeAction(action, context);
+		const shouldContinue = await executeAction(action, context, options);
 		if (!shouldContinue) {
 			return false;
 		}