@getjack/jack 0.1.2 → 0.1.4

package/src/lib/auth/index.ts

@@ -0,0 +1,18 @@
+export { getAuthApiUrl } from "./constants.ts";
+export {
+	getValidAccessToken,
+	authFetch,
+	pollDeviceToken,
+	refreshToken,
+	startDeviceAuth,
+} from "./client.ts";
+export { requireAuth, requireAuthOrLogin, getCurrentUser } from "./guard.ts";
+export {
+	deleteCredentials,
+	getCredentials,
+	isLoggedIn,
+	isTokenExpired,
+	saveCredentials,
+	type AuthCredentials,
+	type AuthUser,
+} from "./store.ts";

package/src/lib/auth/store.ts

@@ -0,0 +1,54 @@
+import { existsSync } from "node:fs";
+import { chmod } from "node:fs/promises";
+import { join } from "node:path";
+import { CONFIG_DIR } from "../config.ts";
+
+export interface AuthUser {
+	id: string;
+	email: string;
+	first_name: string | null;
+	last_name: string | null;
+}
+
+export interface AuthCredentials {
+	access_token: string;
+	refresh_token: string;
+	expires_at: number; // Unix timestamp (seconds)
+	user: AuthUser;
+}
+
+const AUTH_PATH = join(CONFIG_DIR, "auth.json");
+
+export async function getCredentials(): Promise<AuthCredentials | null> {
+	if (!existsSync(AUTH_PATH)) {
+		return null;
+	}
+	try {
+		return await Bun.file(AUTH_PATH).json();
+	} catch {
+		return null;
+	}
+}
+
+export async function saveCredentials(creds: AuthCredentials): Promise<void> {
+	await Bun.write(AUTH_PATH, JSON.stringify(creds, null, 2));
+	await chmod(AUTH_PATH, 0o600);
+}
+
+export async function deleteCredentials(): Promise<void> {
+	if (existsSync(AUTH_PATH)) {
+		const { unlink } = await import("node:fs/promises");
+		await unlink(AUTH_PATH);
+	}
+}
+
+export async function isLoggedIn(): Promise<boolean> {
+	const creds = await getCredentials();
+	return creds !== null;
+}
+
+export function isTokenExpired(creds: AuthCredentials): boolean {
+	const now = Math.floor(Date.now() / 1000);
+	const buffer = 5 * 60; // 5 minutes
+	return creds.expires_at < now + buffer;
+}

package/src/lib/binding-validator.ts

@@ -0,0 +1,136 @@
+/**
+ * Binding validator for jack cloud managed deployments.
+ *
+ * Validates that project bindings are supported by jack cloud and
+ * that required resources (like assets directories) exist.
+ */
+
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import type { WranglerConfig } from "./build-helper.ts";
+
+/**
+ * Bindings supported by jack cloud managed deployments.
+ */
+export const SUPPORTED_BINDINGS = ["d1_databases", "ai", "assets", "vars"] as const;
+
+/**
+ * Bindings not yet supported by jack cloud.
+ * These will cause validation errors if present in wrangler config.
+ */
+export const UNSUPPORTED_BINDINGS = [
+	"kv_namespaces",
+	"durable_objects",
+	"queues",
+	"services",
+	"r2_buckets",
+	"hyperdrive",
+	"vectorize",
+	"browser",
+	"mtls_certificates",
+] as const;
+
+/**
+ * Human-readable names for unsupported bindings.
+ */
+const BINDING_DISPLAY_NAMES: Record<string, string> = {
+	kv_namespaces: "KV Namespaces",
+	durable_objects: "Durable Objects",
+	queues: "Queues",
+	services: "Service Bindings",
+	r2_buckets: "R2 Buckets",
+	hyperdrive: "Hyperdrive",
+	vectorize: "Vectorize",
+	browser: "Browser Rendering",
+	mtls_certificates: "mTLS Certificates",
+};
+
+export interface BindingValidationResult {
+	valid: boolean;
+	errors: string[];
+}
+
+/**
+ * Validates that a wrangler config only uses supported bindings.
+ *
+ * @param config - Parsed wrangler configuration
+ * @param projectPath - Absolute path to project directory (for assets validation)
+ * @returns Validation result with errors if invalid
+ */
+export function validateBindings(
+	config: WranglerConfig,
+	projectPath: string,
+): BindingValidationResult {
+	const errors: string[] = [];
+
+	// Check for unsupported bindings
+	for (const binding of UNSUPPORTED_BINDINGS) {
+		const value = config[binding as keyof WranglerConfig];
+		if (value !== undefined && value !== null) {
+			const displayName = BINDING_DISPLAY_NAMES[binding] || binding;
+			// Special message for R2 - suggest using Workers Assets instead
+			if (binding === "r2_buckets") {
+				errors.push(
+					`✗ R2 buckets not supported in managed deploy.\n  For static files, use Workers Assets instead (assets.directory in wrangler.jsonc).\n  Fix: Replace r2_buckets with assets config, or use 'wrangler deploy' for full control.`,
+				);
+			} else {
+				errors.push(
+					`✗ ${displayName} not supported in managed deploy.\n  Managed deploy supports: D1, AI, Assets, vars.\n  Fix: Remove ${binding} from wrangler.jsonc, or use 'wrangler deploy' for full control.`,
+				);
+			}
+		}
+	}
+
+	// Validate assets directory if configured
+	const assetsValidation = validateAssetsDirectory(config, projectPath);
+	if (!assetsValidation.valid) {
+		errors.push(...assetsValidation.errors);
+	}
+
+	return {
+		valid: errors.length === 0,
+		errors,
+	};
+}
+
+/**
+ * Validates that the assets directory exists and is not empty.
+ *
+ * @param config - Parsed wrangler configuration
+ * @param projectPath - Absolute path to project directory
+ * @returns Validation result with errors if invalid
+ */
+export function validateAssetsDirectory(
+	config: WranglerConfig,
+	projectPath: string,
+): BindingValidationResult {
+	const errors: string[] = [];
+
+	if (config.assets?.directory) {
+		const assetsDir = config.assets.directory;
+		const assetsPath = join(projectPath, assetsDir);
+
+		if (!existsSync(assetsPath)) {
+			errors.push(
+				`✗ Assets directory not found: ${assetsDir}\n  The assets.directory specified in wrangler.jsonc does not exist.\n  Fix: Run your build command first, or update assets.directory in wrangler.jsonc.`,
+			);
+		} else {
+			// Check if directory is empty
+			try {
+				const files = readdirSync(assetsPath);
+				if (files.length === 0) {
+					errors.push(
+						`✗ Assets directory is empty: ${assetsDir}\n  No files found in the assets directory.\n  Fix: Run your build command to generate assets.`,
+					);
+				}
+			} catch {
+				// If we can't read the directory, the deploy will fail anyway
+			}
+		}
+	}
+
+	return {
+		valid: errors.length === 0,
+		errors,
+	};
+}

package/src/lib/build-helper.ts

@@ -0,0 +1,211 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { $ } from "bun";
+import { JackError, JackErrorCode } from "./errors.ts";
+import { parseJsonc } from "./jsonc.ts";
+import type { OperationReporter } from "./project-operations.ts";
+
+export interface BuildOutput {
+	outDir: string;
+	entrypoint: string;
+	assetsDir: string | null;
+	compatibilityDate: string;
+	compatibilityFlags: string[];
+	moduleFormat: "esm";
+}
+
+export interface BuildOptions {
+	projectPath: string;
+	reporter?: OperationReporter;
+}
+
+export interface WranglerConfig {
+	main?: string;
+	compatibility_date?: string;
+	compatibility_flags?: string[];
+	// Supported bindings
+	d1_databases?: Array<{ binding: string; database_name?: string; database_id?: string }>;
+	ai?: { binding?: string };
+	assets?: {
+		directory?: string;
+		binding?: string;
+		not_found_handling?: "single-page-application" | "404-page" | "none";
+		html_handling?: "auto-trailing-slash" | "force-trailing-slash" | "drop-trailing-slash" | "none";
+		run_worker_first?: boolean;
+	};
+	vars?: Record<string, string>;
+	// Unsupported bindings (for validation)
+	kv_namespaces?: unknown;
+	durable_objects?: unknown;
+	queues?: unknown;
+	services?: unknown;
+	r2_buckets?: unknown;
+	hyperdrive?: unknown;
+	vectorize?: unknown;
+	browser?: unknown;
+	mtls_certificates?: unknown;
+}
+
+/**
+ * Parses wrangler.jsonc configuration from project directory
+ * @param projectPath - Absolute path to project directory
+ * @returns Parsed wrangler configuration
+ */
+export async function parseWranglerConfig(projectPath: string): Promise<WranglerConfig> {
+	const wranglerPath = join(projectPath, "wrangler.jsonc");
+
+	if (!existsSync(wranglerPath)) {
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			"wrangler.jsonc not found",
+			"Ensure your project has a wrangler.jsonc configuration file",
+		);
+	}
+
+	const content = await readFile(wranglerPath, "utf-8");
+	return parseJsonc<WranglerConfig>(content);
+}
+
+/**
+ * Checks if project requires Vite build by detecting vite config files
+ * @param projectPath - Absolute path to project directory
+ * @returns true if vite.config.ts or vite.config.js exists
+ */
+export async function needsViteBuild(projectPath: string): Promise<boolean> {
+	return (
+		existsSync(join(projectPath, "vite.config.ts")) ||
+		existsSync(join(projectPath, "vite.config.js")) ||
+		existsSync(join(projectPath, "vite.config.mjs")) ||
+		existsSync(join(projectPath, "vite.config.mts"))
+	);
+}
+
+/**
+ * Runs Vite build for the project
+ * @param projectPath - Absolute path to project directory
+ * @throws JackError if build fails
+ */
+export async function runViteBuild(projectPath: string): Promise<void> {
+	// Jack controls the build for managed projects (omakase)
+	// Users wanting tsc can run `bun run build` manually before shipping
+	const buildResult = await $`bunx vite build`.cwd(projectPath).nothrow().quiet();
+
+	if (buildResult.exitCode !== 0) {
+		throw new JackError(
+			JackErrorCode.BUILD_FAILED,
+			"Vite build failed",
+			"Check your vite.config and source files for errors",
+			{
+				exitCode: buildResult.exitCode,
+				stderr: buildResult.stderr.toString(),
+			},
+		);
+	}
+}
+
+/**
+ * Builds a Cloudflare Worker project using wrangler dry-run
+ * @param options - Build options with project path and optional reporter
+ * @returns BuildOutput containing build artifacts and metadata
+ * @throws JackError if build fails
+ */
+export async function buildProject(options: BuildOptions): Promise<BuildOutput> {
+	const { projectPath, reporter } = options;
+
+	// Parse wrangler config first
+	const config = await parseWranglerConfig(projectPath);
+
+	// Check if Vite build is needed and run it
+	const hasVite = await needsViteBuild(projectPath);
+	if (hasVite) {
+		reporter?.start("Building with Vite...");
+		await runViteBuild(projectPath);
+		reporter?.stop();
+		reporter?.success("Built with Vite");
+	}
+
+	// Create unique temp directory for build output
+	const buildId = `jack-build-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+	const outDir = join(tmpdir(), buildId);
+	await mkdir(outDir, { recursive: true });
+
+	// Run wrangler dry-run to build without deploying
+	reporter?.start("Building worker...");
+
+	const dryRunResult = await $`wrangler deploy --dry-run --outdir=${outDir}`
+		.cwd(projectPath)
+		.nothrow()
+		.quiet();
+
+	if (dryRunResult.exitCode !== 0) {
+		reporter?.stop();
+		reporter?.error("Worker build failed");
+		throw new JackError(
+			JackErrorCode.BUILD_FAILED,
+			"Worker build failed",
+			"Check your wrangler.jsonc and worker code for errors",
+			{
+				exitCode: dryRunResult.exitCode,
+				stderr: dryRunResult.stderr.toString(),
+			},
+		);
+	}
+
+	reporter?.stop();
+	reporter?.success("Built worker");
+
+	const entrypoint = await resolveEntrypoint(outDir, config.main);
+
+	// Determine assets directory if configured
+	let assetsDir: string | null = null;
+	if (config.assets) {
+		// Default to "dist" if assets binding exists but directory not specified (Vite convention)
+		const directory = config.assets.directory || "dist";
+		const assetsDirPath = join(projectPath, directory);
+		if (existsSync(assetsDirPath)) {
+			assetsDir = assetsDirPath;
+		}
+	}
+
+	return {
+		outDir,
+		entrypoint,
+		assetsDir,
+		compatibilityDate: config.compatibility_date || "2024-01-01",
+		compatibilityFlags: config.compatibility_flags || [],
+		moduleFormat: "esm",
+	};
+}
+
+async function resolveEntrypoint(outDir: string, main?: string): Promise<string> {
+	const candidates: string[] = [];
+
+	if (main) {
+		const base = basename(main).replace(/\.[^.]+$/, "");
+		if (base) {
+			candidates.push(`${base}.js`, `${base}.mjs`);
+		}
+	}
+
+	candidates.push("index.js", "worker.js");
+
+	for (const candidate of candidates) {
+		if (existsSync(join(outDir, candidate))) {
+			return candidate;
+		}
+	}
+
+	const files = await readdir(outDir);
+	const jsFiles = files.filter((file) => file.endsWith(".js"));
+	if (jsFiles.length === 1) {
+		return jsFiles[0] as string;
+	}
+
+	throw new JackError(
+		JackErrorCode.BUILD_FAILED,
+		"Could not determine build entrypoint",
+		"Ensure wrangler outputs a single entry file (index.js or worker.js)",
+	);
+}

package/src/lib/cloudflare-api.ts

@@ -64,6 +64,30 @@ export async function deleteDatabase(dbName: string): Promise<void> {
 	}
 }
 
+/**
+ * List D1 databases for the current account
+ */
+export async function listD1Databases(): Promise<Array<{ name?: string; uuid?: string }>> {
+	const result = await $`wrangler d1 list --json`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		const stderr = result.stderr.toString().trim();
+		throw new Error(stderr || "Failed to list D1 databases");
+	}
+
+	try {
+		const output = result.stdout.toString().trim();
+		const parsed = JSON.parse(output);
+		if (Array.isArray(parsed)) return parsed;
+		if (Array.isArray(parsed?.result)) return parsed.result;
+		if (Array.isArray(parsed?.databases)) return parsed.databases;
+	} catch {
+		// Fall through to empty list
+	}
+
+	return [];
+}
+
 /**
  * List all workers for the current account
  * Parses the output of `wrangler deployments list` to extract worker names

package/src/lib/config.ts

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