@getjack/jack 0.1.2 → 0.1.4

package/src/lib/control-plane.ts

@@ -0,0 +1,295 @@
+/**
+ * Control Plane API client for jack cloud
+ */
+
+const DEFAULT_CONTROL_API_URL = "https://control.getjack.org";
+
+export function getControlApiUrl(): string {
+	return process.env.JACK_CONTROL_URL || DEFAULT_CONTROL_API_URL;
+}
+
+export interface CreateProjectRequest {
+	name: string;
+	slug?: string;
+	template?: string;
+	use_prebuilt?: boolean;
+}
+
+export interface CreateManagedProjectOptions {
+	slug?: string;
+	template?: string;
+	usePrebuilt?: boolean;
+}
+
+export interface CreateProjectResponse {
+	project: {
+		id: string;
+		org_id: string;
+		name: string;
+		slug: string;
+		status: string;
+		created_at: string;
+		updated_at: string;
+	};
+	resources: Array<{
+		id: string;
+		resource_type: string;
+		resource_name: string;
+		status: string;
+	}>;
+	status?: "live" | "created";
+	url?: string;
+	prebuilt_failed?: boolean;
+}
+
+export interface SlugAvailabilityResponse {
+	available: boolean;
+	slug: string;
+	error?: string;
+}
+
+export interface CreateDeploymentRequest {
+	source: string;
+}
+
+export interface CreateDeploymentResponse {
+	id: string;
+	project_id: string;
+	status: "queued" | "building" | "live" | "failed";
+	source: string;
+	created_at: string;
+}
+
+/**
+ * Create a managed project via the control plane.
+ */
+export async function createManagedProject(
+	name: string,
+	options?: CreateManagedProjectOptions,
+): Promise<CreateProjectResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+	const pkg = await import("../../package.json");
+
+	const requestBody: CreateProjectRequest = { name };
+	if (options?.slug) {
+		requestBody.slug = options.slug;
+	}
+	if (options?.template) {
+		requestBody.template = options.template;
+	}
+	if (options?.usePrebuilt !== undefined) {
+		requestBody.use_prebuilt = options.usePrebuilt;
+	}
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"X-Jack-Version": pkg.version,
+		},
+		body: JSON.stringify(requestBody),
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to create managed project: ${response.status}`);
+	}
+
+	return response.json() as Promise<CreateProjectResponse>;
+}
+
+/**
+ * Deploy to a managed project via the control plane.
+ */
+export async function deployManagedProject(
+	projectId: string,
+	source: string,
+): Promise<CreateDeploymentResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/deployments`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ source } satisfies CreateDeploymentRequest),
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Managed deploy failed: ${response.status}`);
+	}
+
+	return response.json() as Promise<CreateDeploymentResponse>;
+}
+
+/**
+ * Check if a project slug is available on jack cloud.
+ */
+export async function checkSlugAvailability(slug: string): Promise<SlugAvailabilityResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/slugs/${encodeURIComponent(slug)}/available`,
+	);
+
+	if (!response.ok) {
+		throw new Error(`Failed to check slug availability: ${response.status}`);
+	}
+
+	return response.json() as Promise<SlugAvailabilityResponse>;
+}
+
+export interface DatabaseExportResponse {
+	success: boolean;
+	download_url: string;
+	expires_in: number;
+}
+
+export interface DeleteProjectResponse {
+	success: boolean;
+	project_id: string;
+	deleted_at: string;
+	resources: Array<{ resource: string; success: boolean; error?: string }>;
+	warnings?: string;
+}
+
+export interface ManagedProject {
+	id: string;
+	org_id: string;
+	name: string;
+	slug: string;
+	status: "active" | "error" | "deleted";
+	created_at: string;
+	updated_at: string;
+}
+
+/**
+ * Export a managed project's D1 database.
+ */
+export async function exportManagedDatabase(projectId: string): Promise<DatabaseExportResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/${projectId}/database/export`,
+	);
+
+	if (response.status === 504) {
+		throw new Error("Database export timed out. The database may be too large.");
+	}
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to export database: ${response.status}`);
+	}
+
+	return response.json() as Promise<DatabaseExportResponse>;
+}
+
+/**
+ * Delete a managed project and all its resources.
+ */
+export async function deleteManagedProject(projectId: string): Promise<DeleteProjectResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}`, {
+		method: "DELETE",
+	});
+
+	// 404 means project doesn't exist - treat as already deleted
+	if (response.status === 404) {
+		return {
+			success: true,
+			project_id: projectId,
+			deleted_at: new Date().toISOString(),
+			resources: [],
+			warnings: "Project was already deleted or not found",
+		};
+	}
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to delete project: ${response.status}`);
+	}
+
+	return response.json() as Promise<DeleteProjectResponse>;
+}
+
+/**
+ * List all managed projects from the control plane.
+ */
+export async function listManagedProjects(): Promise<ManagedProject[]> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects`);
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to list managed projects: ${response.status}`);
+	}
+
+	const data = (await response.json()) as { projects: ManagedProject[] };
+	return data.projects;
+}
+
+/**
+ * Find a managed project by slug.
+ */
+export async function findProjectBySlug(slug: string): Promise<ManagedProject | null> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/by-slug/${encodeURIComponent(slug)}`,
+	);
+
+	if (response.status === 404) {
+		return null;
+	}
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to find project: ${response.status}`);
+	}
+
+	const data = (await response.json()) as { project: ManagedProject };
+	return data.project;
+}
+
+export interface ProjectResource {
+	id: string;
+	resource_type: string;
+	resource_name: string;
+	provider_id: string;
+	status: string;
+	created_at: string;
+}
+
+/**
+ * Fetch all resources for a managed project.
+ * Uses GET /v1/projects/:id/resources endpoint.
+ */
+export async function fetchProjectResources(projectId: string): Promise<ProjectResource[]> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/resources`);
+
+	if (!response.ok) {
+		if (response.status === 404) {
+			return [];
+		}
+		throw new Error(`Failed to fetch resources: ${response.status}`);
+	}
+
+	const data = (await response.json()) as { resources: ProjectResource[] };
+	return data.resources;
+}

package/src/lib/debug.ts

@@ -63,8 +63,10 @@ export async function time(label: string, fn: () => Promise<void>): Promise<numb
 	timerStart(label);
 	try {
 		await fn();
-	} finally {
 		return timerEnd(label);
+	} catch (error) {
+		timerEnd(label); // Clean up timer even on failure
+		throw error;
 	}
 }
 

package/src/lib/deploy-mode.ts

@@ -0,0 +1,93 @@
+/**
+ * Deploy mode selection and validation
+ */
+
+import { $ } from "bun";
+import { isLoggedIn } from "./auth/index.ts";
+import type { DeployMode } from "./registry.ts";
+import { Events, track } from "./telemetry.ts";
+
+export interface ModeFlags {
+	managed?: boolean;
+	byo?: boolean;
+}
+
+/**
+ * Check if wrangler CLI is available.
+ */
+export async function isWranglerAvailable(): Promise<boolean> {
+	try {
+		const result = await $`which wrangler`.nothrow().quiet();
+		return result.exitCode === 0;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Determine deploy mode based on login status and flags.
+ *
+ * Omakase behavior:
+ * - Logged in => managed
+ * - Logged out => BYO
+ *
+ * Explicit flags always override.
+ */
+export async function resolveDeployMode(flags: ModeFlags = {}): Promise<DeployMode> {
+	// Validate mutual exclusion
+	if (flags.managed && flags.byo) {
+		throw new Error("Cannot use both --managed and --byo flags. Choose one.");
+	}
+
+	// Explicit flag takes precedence
+	if (flags.managed) {
+		track(Events.DEPLOY_MODE_SELECTED, { mode: "managed", explicit: true });
+		return "managed";
+	}
+	if (flags.byo) {
+		track(Events.DEPLOY_MODE_SELECTED, { mode: "byo", explicit: true });
+		return "byo";
+	}
+
+	// Omakase default based on login status
+	const loggedIn = await isLoggedIn();
+	const mode = loggedIn ? "managed" : "byo";
+
+	track(Events.DEPLOY_MODE_SELECTED, { mode, explicit: false });
+
+	return mode;
+}
+
+/**
+ * Validate that the chosen mode is available.
+ *
+ * @returns Error message if unavailable, null if OK
+ */
+export async function validateModeAvailability(mode: DeployMode): Promise<string | null> {
+	if (mode === "managed") {
+		const loggedIn = await isLoggedIn();
+		if (!loggedIn) {
+			return "Not logged in. Run: jack login or use --byo";
+		}
+		const hasWrangler = await isWranglerAvailable();
+		if (!hasWrangler) {
+			return "wrangler not found. Install wrangler or use --byo";
+		}
+	}
+
+	if (mode === "byo") {
+		const hasWrangler = await isWranglerAvailable();
+		if (!hasWrangler) {
+			return "wrangler not found. Install wrangler or run: jack login";
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Get a human-readable label for the deploy mode.
+ */
+export function getDeployModeLabel(mode: DeployMode): string {
+	return mode === "managed" ? "jack cloud" : "wrangler (BYO)";
+}

package/src/lib/deploy-upload.ts

@@ -0,0 +1,92 @@
+/**
+ * Upload deployment artifacts to control plane via multipart form-data
+ */
+
+import { readFile } from "node:fs/promises";
+import type { AssetManifest } from "./asset-hash.ts";
+import { authFetch } from "./auth/index.ts";
+import { getControlApiUrl } from "./control-plane.ts";
+
+export interface DeployUploadOptions {
+	projectId: string;
+	bundleZipPath: string;
+	sourceZipPath: string;
+	manifestPath: string;
+	schemaPath?: string;
+	secretsPath?: string;
+	assetsZipPath?: string;
+	assetManifest?: AssetManifest;
+}
+
+export interface DeployUploadResult {
+	id: string;
+	project_id: string;
+	status: "queued" | "building" | "live" | "failed";
+	source: string;
+	created_at: string;
+}
+
+/**
+ * Upload deployment artifacts via multipart/form-data
+ */
+export async function uploadDeployment(options: DeployUploadOptions): Promise<DeployUploadResult> {
+	const formData = new FormData();
+
+	// Read files and add to form data
+	const manifestContent = await readFile(options.manifestPath);
+	formData.append(
+		"manifest",
+		new Blob([manifestContent], { type: "application/json" }),
+		"manifest.json",
+	);
+
+	const bundleContent = await readFile(options.bundleZipPath);
+	formData.append("bundle", new Blob([bundleContent], { type: "application/zip" }), "bundle.zip");
+
+	const sourceContent = await readFile(options.sourceZipPath);
+	formData.append("source", new Blob([sourceContent], { type: "application/zip" }), "source.zip");
+
+	// Optional files
+	if (options.schemaPath) {
+		const schemaContent = await readFile(options.schemaPath);
+		formData.append("schema", new Blob([schemaContent], { type: "text/sql" }), "schema.sql");
+	}
+
+	if (options.secretsPath) {
+		const secretsContent = await readFile(options.secretsPath);
+		formData.append(
+			"secrets",
+			new Blob([secretsContent], { type: "application/json" }),
+			"secrets.json",
+		);
+	}
+
+	if (options.assetsZipPath) {
+		const assetsContent = await readFile(options.assetsZipPath);
+		formData.append("assets", new Blob([assetsContent], { type: "application/zip" }), "assets.zip");
+	}
+
+	if (options.assetManifest) {
+		formData.append(
+			"asset-manifest",
+			new Blob([JSON.stringify(options.assetManifest)], { type: "application/json" }),
+			"asset-manifest.json",
+		);
+	}
+
+	// POST to control plane
+	const url = `${getControlApiUrl()}/v1/projects/${options.projectId}/deployments/upload`;
+	const response = await authFetch(url, {
+		method: "POST",
+		body: formData,
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Upload failed: ${response.status}`);
+	}
+
+	return response.json() as Promise<DeployUploadResult>;
+}

package/src/lib/errors.ts

@@ -1,6 +1,8 @@
 export enum JackErrorCode {
 	AUTH_FAILED = "AUTH_FAILED",
 	WRANGLER_AUTH_EXPIRED = "WRANGLER_AUTH_EXPIRED",
+	JACK_AUTH_REQUIRED = "JACK_AUTH_REQUIRED",
+	JACK_AUTH_EXPIRED = "JACK_AUTH_EXPIRED",
 	PROJECT_NOT_FOUND = "PROJECT_NOT_FOUND",
 	TEMPLATE_NOT_FOUND = "TEMPLATE_NOT_FOUND",
 	BUILD_FAILED = "BUILD_FAILED",

package/src/lib/github.ts

@@ -2,7 +2,9 @@ import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { $ } from "bun";
-import type { Template } from "../templates/types";
+import type { AgentContext, Capability, Template, TemplateHooks } from "../templates/types";
+import { parseJsonc } from "./jsonc.ts";
+import type { ServiceTypeKey } from "./services/index.ts";
 
 /**
  * Parse GitHub input: "user/repo" or "https://github.com/user/repo"
@@ -110,6 +112,34 @@ export async function fetchFromGitHub(input: string): Promise<Template> {
 			console.warn("  (no wrangler.toml or worker entry point found)\n");
 		}
 
+		// Read .jack.json metadata if it exists
+		const jackJsonContent = files[".jack.json"];
+		if (jackJsonContent) {
+			try {
+				const metadata = parseJsonc(jackJsonContent) as {
+					description?: string;
+					secrets?: string[];
+					capabilities?: Capability[];
+					requires?: ServiceTypeKey[];
+					hooks?: TemplateHooks;
+					agentContext?: AgentContext;
+				};
+				// Remove .jack.json from files (not needed in project)
+				const { ".jack.json": _, ...filesWithoutJackJson } = files;
+				return {
+					description: metadata.description || `GitHub: ${owner}/${repo}`,
+					secrets: metadata.secrets,
+					capabilities: metadata.capabilities,
+					requires: metadata.requires,
+					hooks: metadata.hooks,
+					agentContext: metadata.agentContext,
+					files: filesWithoutJackJson,
+				};
+			} catch {
+				// Invalid JSON, fall through to default
+			}
+		}
+
 		return {
 			description: `GitHub: ${owner}/${repo}`,
 			files,

package/src/lib/hooks.ts

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { HookAction } from "../templates/types";
 import { getSavedSecrets } from "./secrets";
+import { restoreTty } from "./tty";
 
 export interface HookContext {
 	domain?: string; // deployed domain (e.g., "my-app.username.workers.dev")
@@ -71,10 +72,7 @@ export async function promptSelect(options: string[]): Promise<number> {
 
 		const cleanup = () => {
 			process.stdin.removeListener("data", onData);
-			if (process.stdin.isTTY) {
-				process.stdin.setRawMode(false);
-			}
-			process.stdin.pause();
+			restoreTty();
 		};
 
 		process.stdin.on("data", onData);
@@ -98,19 +96,13 @@ async function waitForEnter(message?: string): Promise<void> {
 			// Enter, Space, or any key to continue
 			if (char === "\r" || char === "\n" || char === " ") {
 				process.stdin.removeListener("data", onData);
-				if (process.stdin.isTTY) {
-					process.stdin.setRawMode(false);
-				}
-				process.stdin.pause();
+				restoreTty();
 				resolve();
 			}
 			// Esc to skip
 			if (char === "\x1b") {
 				process.stdin.removeListener("data", onData);
-				if (process.stdin.isTTY) {
-					process.stdin.setRawMode(false);
-				}
-				process.stdin.pause();
+				restoreTty();
 				resolve();
 			}
 		};

package/src/lib/intent.ts

@@ -0,0 +1,88 @@
+import { BUILTIN_TEMPLATES, resolveTemplateWithOrigin } from "../templates/index.ts";
+
+export interface IntentMatchResult {
+	template: string;
+	matchedKeywords: string[];
+}
+
+/**
+ * Match an intent phrase against template keywords
+ * Uses case-insensitive partial matching
+ */
+export function matchTemplateByIntent(
+	phrase: string,
+	templates: Array<{ name: string; keywords: string[] }>,
+): IntentMatchResult[] {
+	const normalizedPhrase = phrase.toLowerCase();
+	const matches: IntentMatchResult[] = [];
+
+	for (const template of templates) {
+		const matchedKeywords: string[] = [];
+
+		for (const keyword of template.keywords) {
+			// Case-insensitive partial match - keyword appears anywhere in phrase
+			if (normalizedPhrase.includes(keyword.toLowerCase())) {
+				matchedKeywords.push(keyword);
+			}
+		}
+
+		if (matchedKeywords.length > 0) {
+			matches.push({
+				template: template.name,
+				matchedKeywords,
+			});
+		}
+	}
+
+	return matches;
+}
+
+/**
+ * Detect if the first arg is an intent phrase vs a project name
+ * Heuristics:
+ * - Contains spaces -> intent phrase
+ * - Contains special characters (except hyphen/underscore) -> intent phrase
+ * - Matches common intent indicator words -> intent phrase
+ * - Otherwise -> project name
+ */
+export function isIntentPhrase(arg: string): boolean {
+	// Contains spaces -> definitely intent
+	if (arg.includes(" ")) return true;
+
+	// Contains special chars (except hyphen/underscore) -> intent
+	if (/[^a-zA-Z0-9_-]/.test(arg)) return true;
+
+	// Common intent indicator words (single words that suggest intent)
+	const intentWords = ["api", "webhook", "miniapp", "dashboard", "frontend", "backend", "endpoint"];
+	const lower = arg.toLowerCase();
+
+	// Exact match or compound word containing the intent word
+	for (const word of intentWords) {
+		if (lower === word) return true;
+	}
+
+	return false;
+}
+
+/**
+ * Load all templates and extract their intent keywords
+ */
+export async function loadTemplateKeywords(): Promise<Array<{ name: string; keywords: string[] }>> {
+	const templates: Array<{ name: string; keywords: string[] }> = [];
+
+	for (const name of BUILTIN_TEMPLATES) {
+		try {
+			const { template } = await resolveTemplateWithOrigin(name);
+			if (template.intent?.keywords && template.intent.keywords.length > 0) {
+				templates.push({
+					name,
+					keywords: template.intent.keywords,
+				});
+			}
+		} catch {
+			// Skip templates that fail to load
+		}
+	}
+
+	return templates;
+}