@getjack/jack 0.1.30 → 0.1.31

package/src/lib/picker.ts

@@ -86,7 +86,9 @@ export function requireTTY(): void {
  * Interactive project picker using @clack/core primitives
  * @param options.cloudOnly - If true, only shows cloud-only projects (for linking)
  */
-export async function pickProject(options?: PickProjectOptions): Promise<PickerResult | PickerCancelResult> {
+export async function pickProject(
+	options?: PickProjectOptions,
+): Promise<PickerResult | PickerCancelResult> {
 	// Fetch all projects
 	let allProjects: ProjectListItem[];
 	try {

package/src/lib/project-operations.ts

@@ -47,7 +47,7 @@ import { debug, isDebug, printTimingSummary, timerEnd, timerStart } from "./debu
 import { ensureWranglerInstalled, validateModeAvailability } from "./deploy-mode.ts";
 import { detectSecrets, generateEnvFile, generateSecretsJson } from "./env-parser.ts";
 import { JackError, JackErrorCode } from "./errors.ts";
-import { type HookOutput, runHook } from "./hooks.ts";
+import { type HookOutput, promptSelect, runHook } from "./hooks.ts";
 import { loadTemplateKeywords, matchTemplateByIntent } from "./intent.ts";
 import {
 	type ManagedCreateResult,
@@ -1605,13 +1605,36 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 			// User is logged into Jack Cloud - create managed project
 			const orphanedProjectName = await getProjectNameFromDir(projectPath);
 
-			reporter.info(`Linking "${orphanedProjectName}" to jack cloud...`);
-
-			// Get username for URL construction
+			// Get username for confirmation prompt and URL construction
 			const { getCurrentUserProfile } = await import("./control-plane.ts");
 			const profile = await getCurrentUserProfile();
 			const ownerUsername = profile?.username ?? undefined;
 
+			// Confirm before creating new project
+			if (interactive) {
+				reporter.info("This project isn't linked to jack cloud.");
+				const choice = await promptSelect(
+					["Yes", "No"],
+					`Create new project "${orphanedProjectName}" under @${ownerUsername ?? "unknown"}?`,
+				);
+				if (choice !== 0) {
+					reporter.info("Cancelled. To link to an existing project, use: jack link <project-id>");
+					return {
+						projectName: orphanedProjectName,
+						workerUrl: null,
+						deployMode: "managed" as DeployMode,
+					};
+				}
+			} else {
+				throw new JackError(
+					JackErrorCode.PROJECT_NOT_FOUND,
+					"Project not linked to jack cloud (non-interactive mode)",
+					"Run interactively or use: jack link <project-id>",
+				);
+			}
+
+			reporter.info(`Linking "${orphanedProjectName}" to jack cloud...`);
+
 			// Create managed project on jack cloud
 			const remoteResult = await createManagedProjectRemote(orphanedProjectName, reporter, {
 				usePrebuilt: false,
@@ -1716,6 +1739,17 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 			);
 		}
 
+		// Show current identity for visibility (managed mode only, not dry run)
+		if (!dryRun) {
+			const { getCurrentUserProfile } = await import("./control-plane.ts");
+			const profile = await getCurrentUserProfile();
+			if (profile?.username) {
+				reporter.info(`Deploying as @${profile.username}...`);
+			} else if (profile?.email) {
+				reporter.info(`Deploying as ${profile.email}...`);
+			}
+		}
+
 		// Dry run: build for validation then stop before actual deployment
 		// (deployToManagedProject handles its own build, so only build here for dry-run)
 		if (dryRun) {

package/src/lib/services/cron-create.ts

@@ -0,0 +1,73 @@
+/**
+ * Cron schedule creation logic for jack services cron create
+ *
+ * Validates cron expression, checks minimum interval, and calls control plane API.
+ * Only supported for managed (Jack Cloud) projects.
+ */
+
+import { createCronSchedule as createCronScheduleApi } from "../control-plane.ts";
+import { readProjectLink } from "../project-link.ts";
+import { checkMinimumInterval, validateCronExpression } from "./cron-utils.ts";
+
+// Minimum interval between cron runs (in minutes)
+const MIN_INTERVAL_MINUTES = 15;
+
+export interface CreateCronScheduleOptions {
+	interactive?: boolean;
+}
+
+export interface CreateCronScheduleResult {
+	id: string;
+	expression: string;
+	description: string;
+	nextRunAt: string;
+	created: boolean;
+}
+
+/**
+ * Create a cron schedule for the current project.
+ *
+ * For managed projects: calls control plane POST /v1/projects/:id/crons
+ * For BYO projects: throws error (not supported)
+ */
+export async function createCronSchedule(
+	projectDir: string,
+	expression: string,
+	options: CreateCronScheduleOptions = {},
+): Promise<CreateCronScheduleResult> {
+	// Validate expression
+	const validation = validateCronExpression(expression);
+	if (!validation.valid) {
+		throw new Error(`Invalid cron expression: ${validation.error}`);
+	}
+
+	const normalizedExpression = validation.normalized!;
+
+	// Check minimum interval (15 minutes)
+	if (!checkMinimumInterval(normalizedExpression, MIN_INTERVAL_MINUTES)) {
+		throw new Error(
+			`Cron schedules must run at least ${MIN_INTERVAL_MINUTES} minutes apart. ` +
+				"This limit helps ensure reliable execution.",
+		);
+	}
+
+	// Must be managed mode
+	const link = await readProjectLink(projectDir);
+	if (!link || link.deploy_mode !== "managed") {
+		throw new Error(
+			"Cron schedules are only supported for Jack Cloud (managed) projects.\n" +
+				"BYO projects can use native Cloudflare cron triggers in wrangler.toml.",
+		);
+	}
+
+	// Create via control plane
+	const result = await createCronScheduleApi(link.project_id, normalizedExpression);
+
+	return {
+		id: result.id,
+		expression: result.expression,
+		description: result.description,
+		nextRunAt: result.next_run_at,
+		created: true,
+	};
+}

package/src/lib/services/cron-delete.ts

@@ -0,0 +1,66 @@
+/**
+ * Cron schedule deletion logic for jack services cron delete
+ *
+ * Finds schedule by expression and deletes via control plane API.
+ * Only supported for managed (Jack Cloud) projects.
+ */
+
+import {
+	deleteCronSchedule as deleteCronScheduleApi,
+	listCronSchedules as listCronSchedulesApi,
+} from "../control-plane.ts";
+import { readProjectLink } from "../project-link.ts";
+import { normalizeCronExpression } from "./cron-utils.ts";
+
+export interface DeleteCronScheduleOptions {
+	interactive?: boolean;
+}
+
+export interface DeleteCronScheduleResult {
+	expression: string;
+	deleted: boolean;
+}
+
+/**
+ * Delete a cron schedule by its expression.
+ *
+ * For managed projects: finds the schedule by expression and calls DELETE API
+ * For BYO projects: throws error (not supported)
+ */
+export async function deleteCronSchedule(
+	projectDir: string,
+	expression: string,
+	options: DeleteCronScheduleOptions = {},
+): Promise<DeleteCronScheduleResult> {
+	const normalizedExpression = normalizeCronExpression(expression);
+
+	// Must be managed mode
+	const link = await readProjectLink(projectDir);
+	if (!link || link.deploy_mode !== "managed") {
+		throw new Error(
+			"Cron schedules are only supported for Jack Cloud (managed) projects.\n" +
+				"BYO projects can use native Cloudflare cron triggers in wrangler.toml.",
+		);
+	}
+
+	// Find the schedule by expression
+	const schedules = await listCronSchedulesApi(link.project_id);
+	const schedule = schedules.find(
+		(s) => normalizeCronExpression(s.expression) === normalizedExpression,
+	);
+
+	if (!schedule) {
+		throw new Error(
+			`No cron schedule found with expression "${normalizedExpression}".\n` +
+				"Use 'jack services cron list' to see all schedules.",
+		);
+	}
+
+	// Delete via control plane
+	await deleteCronScheduleApi(link.project_id, schedule.id);
+
+	return {
+		expression: normalizedExpression,
+		deleted: true,
+	};
+}

package/src/lib/services/cron-list.ts

@@ -0,0 +1,59 @@
+/**
+ * Cron schedule listing logic for jack services cron list
+ *
+ * Fetches cron schedules from control plane API.
+ * Only supported for managed (Jack Cloud) projects.
+ */
+
+import {
+	type CronScheduleInfo,
+	listCronSchedules as listCronSchedulesApi,
+} from "../control-plane.ts";
+import { readProjectLink } from "../project-link.ts";
+
+export interface CronScheduleListEntry {
+	id: string;
+	expression: string;
+	description: string;
+	enabled: boolean;
+	nextRunAt: string;
+	lastRunAt: string | null;
+	lastRunStatus: string | null;
+	lastRunDurationMs: number | null;
+	consecutiveFailures: number;
+	createdAt: string;
+}
+
+/**
+ * List all cron schedules for the current project.
+ *
+ * For managed projects: calls control plane GET /v1/projects/:id/crons
+ * For BYO projects: throws error (not supported)
+ */
+export async function listCronSchedules(projectDir: string): Promise<CronScheduleListEntry[]> {
+	// Must be managed mode
+	const link = await readProjectLink(projectDir);
+	if (!link || link.deploy_mode !== "managed") {
+		throw new Error(
+			"Cron schedules are only supported for Jack Cloud (managed) projects.\n" +
+				"BYO projects can use native Cloudflare cron triggers in wrangler.toml.",
+		);
+	}
+
+	// Fetch from control plane
+	const schedules = await listCronSchedulesApi(link.project_id);
+
+	// Map to our format
+	return schedules.map((s: CronScheduleInfo) => ({
+		id: s.id,
+		expression: s.expression,
+		description: s.description,
+		enabled: s.enabled,
+		nextRunAt: s.next_run_at,
+		lastRunAt: s.last_run_at,
+		lastRunStatus: s.last_run_status,
+		lastRunDurationMs: s.last_run_duration_ms,
+		consecutiveFailures: s.consecutive_failures,
+		createdAt: s.created_at,
+	}));
+}

package/src/lib/services/cron-test.ts

@@ -0,0 +1,93 @@
+/**
+ * Cron schedule testing logic for jack services cron test
+ *
+ * Validates expression, shows human-readable description and next times.
+ * Optionally triggers the schedule on production (managed projects only).
+ */
+
+import { triggerCronSchedule as triggerCronScheduleApi } from "../control-plane.ts";
+import { readProjectLink } from "../project-link.ts";
+import {
+	describeCronExpression,
+	getNextScheduledTimes,
+	validateCronExpression,
+} from "./cron-utils.ts";
+
+export interface CronTestOptions {
+	triggerProduction?: boolean;
+	interactive?: boolean;
+}
+
+export interface CronTestResult {
+	valid: boolean;
+	error?: string;
+	expression?: string;
+	description?: string;
+	nextTimes?: Date[];
+	triggerResult?: {
+		triggered: boolean;
+		status: string;
+		durationMs: number;
+	};
+}
+
+/**
+ * Test a cron expression: validate, describe, and show next run times.
+ * Optionally trigger the schedule handler on production.
+ */
+export async function testCronExpression(
+	projectDir: string,
+	expression: string,
+	options: CronTestOptions = {},
+): Promise<CronTestResult> {
+	// Validate expression
+	const validation = validateCronExpression(expression);
+	if (!validation.valid) {
+		return {
+			valid: false,
+			error: validation.error,
+		};
+	}
+
+	const normalizedExpression = validation.normalized!;
+
+	// Get description and next times
+	const description = describeCronExpression(normalizedExpression);
+	const nextTimes = getNextScheduledTimes(normalizedExpression, 5);
+
+	const result: CronTestResult = {
+		valid: true,
+		expression: normalizedExpression,
+		description,
+		nextTimes,
+	};
+
+	// Optionally trigger production
+	if (options.triggerProduction) {
+		const link = await readProjectLink(projectDir);
+		if (!link || link.deploy_mode !== "managed") {
+			throw new Error("Production trigger is only available for Jack Cloud (managed) projects.");
+		}
+
+		const triggerResponse = await triggerCronScheduleApi(link.project_id, normalizedExpression);
+		result.triggerResult = {
+			triggered: triggerResponse.triggered,
+			status: triggerResponse.status,
+			durationMs: triggerResponse.duration_ms,
+		};
+	}
+
+	return result;
+}
+
+/**
+ * Common cron expression patterns for help output.
+ */
+export const COMMON_CRON_PATTERNS = [
+	{ expression: "*/15 * * * *", description: "Every 15 minutes" },
+	{ expression: "0 * * * *", description: "Every hour" },
+	{ expression: "0 0 * * *", description: "Daily at midnight" },
+	{ expression: "0 9 * * *", description: "Daily at 9am" },
+	{ expression: "0 9 * * 1", description: "Every Monday at 9am" },
+	{ expression: "0 0 1 * *", description: "First day of every month" },
+];

package/src/lib/services/cron-utils.ts

@@ -0,0 +1,78 @@
+/**
+ * Cron expression utilities for validation, parsing, and human-readable descriptions.
+ */
+
+import parser from "cron-parser";
+import cronstrue from "cronstrue";
+
+/**
+ * Normalize a cron expression by collapsing whitespace.
+ * "0  *  * * *" -> "0 * * * *"
+ */
+export function normalizeCronExpression(expression: string): string {
+	return expression.trim().replace(/\s+/g, " ");
+}
+
+/**
+ * Validate a cron expression.
+ * Returns normalized expression if valid, error message if invalid.
+ */
+export function validateCronExpression(expression: string): {
+	valid: boolean;
+	error?: string;
+	normalized?: string;
+} {
+	try {
+		const normalized = normalizeCronExpression(expression);
+		parser.parseExpression(normalized);
+		return { valid: true, normalized };
+	} catch (e) {
+		return { valid: false, error: e instanceof Error ? e.message : String(e) };
+	}
+}
+
+/**
+ * Check if a cron expression has at least the minimum interval between runs.
+ * Returns true if the interval is >= minMinutes.
+ */
+export function checkMinimumInterval(expression: string, minMinutes: number): boolean {
+	try {
+		const interval = parser.parseExpression(expression);
+		const first = interval.next().toDate();
+		const second = interval.next().toDate();
+		return (second.getTime() - first.getTime()) / 1000 / 60 >= minMinutes;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Get the next N scheduled times for a cron expression.
+ */
+export function getNextScheduledTimes(expression: string, count: number): Date[] {
+	const interval = parser.parseExpression(expression);
+	const times: Date[] = [];
+	for (let i = 0; i < count; i++) {
+		times.push(interval.next().toDate());
+	}
+	return times;
+}
+
+/**
+ * Get a human-readable description of a cron expression.
+ * e.g., "0 * * * *" -> "At minute 0"
+ */
+export function describeCronExpression(expression: string): string {
+	try {
+		return cronstrue.toString(expression);
+	} catch {
+		return expression;
+	}
+}
+
+/**
+ * Compute the next run time for a cron expression as ISO string.
+ */
+export function computeNextRun(expression: string): string {
+	return parser.parseExpression(expression).next().toDate().toISOString();
+}

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

@@ -15,14 +15,18 @@ import { JackError, JackErrorCode } from "../errors.ts";
 
 export type DomainStatus =
 	| "claimed"
+	| "unassigned"
 	| "pending"
+	| "pending_dns"
 	| "pending_owner"
 	| "pending_ssl"
 	| "active"
 	| "blocked"
 	| "moved"
 	| "failed"
-	| "deleting";
+	| "deleting"
+	| "expired"
+	| "deleted";
 
 export interface DomainVerification {
 	type: "cname";
@@ -36,6 +40,22 @@ export interface DomainOwnershipVerification {
 	value: string;
 }
 
+export interface DomainDns {
+	verified: boolean;
+	checked_at: string | null;
+	current_target: string | null;
+	expected_target: string | null;
+	error: string | null;
+}
+
+export interface DomainNextStep {
+	action: string;
+	record_type?: string;
+	record_name?: string;
+	record_value?: string;
+	message?: string;
+}
+
 export interface DomainInfo {
 	id: string;
 	hostname: string;
@@ -45,6 +65,8 @@ export interface DomainInfo {
 	project_slug: string | null;
 	verification?: DomainVerification;
 	ownership_verification?: DomainOwnershipVerification;
+	dns?: DomainDns;
+	next_step?: DomainNextStep;
 	created_at: string;
 }
 
@@ -96,16 +118,20 @@ interface ListDomainsApiResponse {
 }
 
 interface ConnectDomainApiResponse {
-	id: string;
-	hostname: string;
-	status: string;
+	domain: {
+		id: string;
+		hostname: string;
+		status: string;
+	};
 }
 
 interface AssignDomainApiResponse {
-	id: string;
-	hostname: string;
-	status: string;
-	ssl_status: string | null;
+	domain: {
+		id: string;
+		hostname: string;
+		status: string;
+		ssl_status: string | null;
+	};
 	verification?: DomainVerification;
 	ownership_verification?: DomainOwnershipVerification;
 }
@@ -215,9 +241,9 @@ export async function connectDomain(hostname: string): Promise<ConnectDomainResu
 
 	const data = (await response.json()) as ConnectDomainApiResponse;
 	return {
-		id: data.id,
-		hostname: data.hostname,
-		status: data.status as DomainStatus,
+		id: data.domain.id,
+		hostname: data.domain.hostname,
+		status: data.domain.status as DomainStatus,
 	};
 }
 
@@ -282,10 +308,10 @@ export async function assignDomain(
 
 	const data = (await response.json()) as AssignDomainApiResponse;
 	return {
-		id: data.id,
-		hostname: data.hostname,
-		status: data.status as DomainStatus,
-		ssl_status: data.ssl_status,
+		id: data.domain.id,
+		hostname: data.domain.hostname,
+		status: data.domain.status as DomainStatus,
+		ssl_status: data.domain.ssl_status,
 		project_id: project.id,
 		project_slug: projectSlug,
 		verification: data.verification,
@@ -334,10 +360,13 @@ export async function unassignDomain(hostname: string): Promise<UnassignDomainRe
 		);
 	}
 
+	const data = (await response.json()) as {
+		domain: { id: string; hostname: string; status: string };
+	};
 	return {
-		id: domain.id,
-		hostname: domain.hostname,
-		status: "claimed" as DomainStatus,
+		id: data.domain.id,
+		hostname: data.domain.hostname,
+		status: data.domain.status as DomainStatus,
 	};
 }
 
@@ -377,3 +406,45 @@ export async function disconnectDomain(hostname: string): Promise<DisconnectDoma
 		hostname: domain.hostname,
 	};
 }
+
+/**
+ * Verify DNS configuration for a domain.
+ *
+ * @throws JackError with RESOURCE_NOT_FOUND if domain not found
+ */
+export interface VerifyDomainResult {
+	domain: DomainInfo;
+	dns_check?: {
+		verified: boolean;
+		target: string | null;
+		error: string | null;
+	};
+}
+
+export async function verifyDomain(hostname: string): Promise<VerifyDomainResult> {
+	const domain = await getDomainByHostname(hostname);
+	if (!domain) {
+		throw new JackError(
+			JackErrorCode.PROJECT_NOT_FOUND,
+			`Domain not found: ${hostname}`,
+			"Run 'jack domain' to see all domains",
+			{ exitCode: 1 },
+		);
+	}
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/domains/${domain.id}/verify`, {
+		method: "POST",
+	});
+
+	if (!response.ok) {
+		const err = (await response
+			.json()
+			.catch(() => ({ message: "Unknown error" }))) as ApiErrorResponse;
+		throw new JackError(
+			JackErrorCode.INTERNAL_ERROR,
+			err.message || `Failed to verify domain: ${response.status}`,
+		);
+	}
+
+	return (await response.json()) as VerifyDomainResult;
+}

package/src/mcp/server.ts

@@ -49,6 +49,20 @@ export async function startMcpServer(options: McpServerOptions = {}) {
 
 	debug("Starting MCP server on stdio transport");
 
+	// Process-level error handlers to prevent silent crashes
+	process.on("uncaughtException", (error) => {
+		console.error(`[jack-mcp] Uncaught exception: ${error.message}`);
+		debug("Uncaught exception", { error: error.stack });
+		process.exit(1);
+	});
+
+	process.on("unhandledRejection", (reason) => {
+		const message = reason instanceof Error ? reason.message : String(reason);
+		console.error(`[jack-mcp] Unhandled rejection: ${message}`);
+		debug("Unhandled rejection", { reason });
+		process.exit(1);
+	});
+
 	// Always log startup to stderr so user knows it's running
 	console.error(
 		`[jack-mcp] Server started (v${pkg.version})${options.debug ? " [debug mode]" : ""}`,
@@ -57,4 +71,10 @@ export async function startMcpServer(options: McpServerOptions = {}) {
 	await server.connect(transport);
 
 	debug("MCP server connected and ready");
+
+	// Keep the server running indefinitely.
+	// This blocks the async function from returning, preventing the caller from
+	// falling through to any cleanup/exit code (like process.exit(0) in index.ts).
+	// The process will stay alive via stdin event listeners in the transport.
+	await new Promise(() => {});
 }