@getjack/jack 0.1.30 → 0.1.32

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/lib/services/token-operations.ts

@@ -0,0 +1,84 @@
+/**
+ * Token operations service layer for jack cloud
+ *
+ * Provides shared API token management functions for both CLI and MCP.
+ * Returns pure data - no console.log or process.exit.
+ */
+
+import { authFetch } from "../auth/index.ts";
+import { getControlApiUrl } from "../control-plane.ts";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface CreateTokenResult {
+	token: string;
+	id: string;
+	name: string;
+	created_at: string;
+	expires_at: string | null;
+}
+
+export interface TokenInfo {
+	id: string;
+	name: string;
+	id_prefix: string;
+	created_at: string;
+	last_used_at: string | null;
+	expires_at: string | null;
+}
+
+// ============================================================================
+// Service Functions
+// ============================================================================
+
+/**
+ * Create a new API token for headless authentication.
+ */
+export async function createApiToken(
+	name: string,
+	expiresInDays?: number,
+): Promise<CreateTokenResult> {
+	const response = await authFetch(`${getControlApiUrl()}/v1/tokens`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ name, expires_in_days: expiresInDays }),
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({}))) as { message?: string };
+		throw new Error(err.message || `Failed to create token: ${response.status}`);
+	}
+
+	return response.json() as Promise<CreateTokenResult>;
+}
+
+/**
+ * List all active API tokens for the current user.
+ */
+export async function listApiTokens(): Promise<TokenInfo[]> {
+	const response = await authFetch(`${getControlApiUrl()}/v1/tokens`);
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({}))) as { message?: string };
+		throw new Error(err.message || `Failed to list tokens: ${response.status}`);
+	}
+
+	const data = (await response.json()) as { tokens: TokenInfo[] };
+	return data.tokens;
+}
+
+/**
+ * Revoke an API token by ID.
+ */
+export async function revokeApiToken(tokenId: string): Promise<void> {
+	const response = await authFetch(`${getControlApiUrl()}/v1/tokens/${tokenId}`, {
+		method: "DELETE",
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({}))) as { message?: string };
+		throw new Error(err.message || `Failed to revoke token: ${response.status}`);
+	}
+}

package/src/lib/telemetry.ts

@@ -44,6 +44,9 @@ export const Events = {
 	BYO_DEPLOY_STARTED: "byo_deploy_started",
 	BYO_DEPLOY_COMPLETED: "byo_deploy_completed",
 	BYO_DEPLOY_FAILED: "byo_deploy_failed",
+	// Token management events
+	TOKEN_CREATED: "token_created",
+	TOKEN_REVOKED: "token_revoked",
 } as const;
 
 type EventName = (typeof Events)[keyof typeof Events];
@@ -127,6 +130,7 @@ export interface UserProperties {
 	is_tty?: boolean;
 	locale?: string;
 	config_style?: "byoc" | "jack-cloud";
+	auth_method?: "oauth" | "token";
 }
 
 // Detect environment properties (for user profile - stable properties)