@getjack/jack 0.1.30 → 0.1.31

package/src/commands/services.ts

@@ -5,6 +5,10 @@ import { formatSize } from "../lib/format.ts";
 import { error, info, item, output as outputSpinner, success, warn } from "../lib/output.ts";
 import { readProjectLink } from "../lib/project-link.ts";
 import { parseWranglerResources } from "../lib/resources.ts";
+import { createCronSchedule } from "../lib/services/cron-create.ts";
+import { deleteCronSchedule } from "../lib/services/cron-delete.ts";
+import { listCronSchedules } from "../lib/services/cron-list.ts";
+import { COMMON_CRON_PATTERNS, testCronExpression } from "../lib/services/cron-test.ts";
 import { createDatabase } from "../lib/services/db-create.ts";
 import {
 	DestructiveOperationError,
@@ -111,9 +115,11 @@ export default async function services(
 			return await dbCommand(args, options);
 		case "storage":
 			return await storageCommand(args, options);
+		case "cron":
+			return await cronCommand(args, options);
 		default:
 			error(`Unknown service: ${subcommand}`);
-			info("Available: db, storage");
+			info("Available: db, storage, cron");
 			process.exit(1);
 	}
 }
@@ -125,6 +131,7 @@ function showHelp(): void {
 	console.error("Commands:");
 	console.error("  db         Manage database");
 	console.error("  storage    Manage storage (R2 buckets)");
+	console.error("  cron       Manage scheduled tasks");
 	console.error("");
 	console.error("Run 'jack services <command>' for more information.");
 	console.error("");
@@ -1181,3 +1188,295 @@ async function storageDelete(args: string[], options: ServiceOptions): Promise<v
 		process.exit(1);
 	}
 }
+
+// ============================================================================
+// Cron Commands
+// ============================================================================
+
+function showCronHelp(): void {
+	console.error("");
+	info("jack services cron - Manage scheduled tasks");
+	console.error("");
+	console.error("Actions:");
+	console.error('  create <expression>   Add a cron schedule (e.g., "0 * * * *")');
+	console.error("  list                  List all cron schedules");
+	console.error("  delete <expression>   Remove a cron schedule");
+	console.error("  test <expression>     Validate and preview a cron expression");
+	console.error("");
+	console.error("Examples:");
+	console.error('  jack services cron create "0 * * * *"   Schedule hourly runs');
+	console.error("  jack services cron list                 Show all schedules");
+	console.error('  jack services cron delete "0 * * * *"   Remove a schedule');
+	console.error('  jack services cron test "*/15 * * * *"  Preview next run times');
+	console.error("");
+	console.error("Common patterns:");
+	for (const pattern of COMMON_CRON_PATTERNS) {
+		console.error(`  ${pattern.expression.padEnd(15)} ${pattern.description}`);
+	}
+	console.error("");
+	console.error("Note: Cron schedules require Jack Cloud (managed) projects.");
+	console.error("All times are in UTC.");
+	console.error("");
+}
+
+async function cronCommand(args: string[], options: ServiceOptions): Promise<void> {
+	// Check if any argument is --help or -h
+	if (args.includes("--help") || args.includes("-h")) {
+		return showCronHelp();
+	}
+
+	const action = args[0] || "list"; // Default to list
+
+	switch (action) {
+		case "help":
+			return showCronHelp();
+		case "create":
+			return await cronCreate(args.slice(1), options);
+		case "list":
+			return await cronList(options);
+		case "delete":
+			return await cronDelete(args.slice(1), options);
+		case "test":
+			return await cronTest(args.slice(1), options);
+		default:
+			error(`Unknown action: ${action}`);
+			info("Available: create, list, delete, test");
+			process.exit(1);
+	}
+}
+
+/**
+ * Create a new cron schedule
+ */
+async function cronCreate(args: string[], options: ServiceOptions): Promise<void> {
+	const expression = args[0];
+
+	if (!expression) {
+		console.error("");
+		error("Cron expression required");
+		info('Usage: jack services cron create "<expression>"');
+		console.error("");
+		console.error("Common patterns:");
+		for (const pattern of COMMON_CRON_PATTERNS) {
+			console.error(`  ${pattern.expression.padEnd(15)} ${pattern.description}`);
+		}
+		console.error("");
+		process.exit(1);
+	}
+
+	outputSpinner.start("Creating cron schedule...");
+	try {
+		const result = await createCronSchedule(process.cwd(), expression, {
+			interactive: true,
+		});
+		outputSpinner.stop();
+
+		// Track telemetry
+		track(Events.SERVICE_CREATED, {
+			service_type: "cron",
+			created: result.created,
+		});
+
+		console.error("");
+		success("Cron schedule created");
+		console.error("");
+		item(`Expression: ${result.expression}`);
+		item(`Schedule: ${result.description}`);
+		item(`Next run: ${result.nextRunAt}`);
+		console.error("");
+		info("Make sure your Worker handles POST /__scheduled requests.");
+		console.error("");
+	} catch (err) {
+		outputSpinner.stop();
+		console.error("");
+		error(`Failed to create cron schedule: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+}
+
+/**
+ * List all cron schedules
+ */
+async function cronList(options: ServiceOptions): Promise<void> {
+	outputSpinner.start("Fetching cron schedules...");
+	try {
+		const schedules = await listCronSchedules(process.cwd());
+		outputSpinner.stop();
+
+		if (schedules.length === 0) {
+			console.error("");
+			info("No cron schedules found for this project.");
+			console.error("");
+			info('Create one with: jack services cron create "0 * * * *"');
+			console.error("");
+			return;
+		}
+
+		console.error("");
+		success(`Found ${schedules.length} cron schedule${schedules.length === 1 ? "" : "s"}:`);
+		console.error("");
+
+		for (const schedule of schedules) {
+			const statusIcon = schedule.enabled ? "+" : "-";
+			item(`${statusIcon} ${schedule.expression}`);
+			item(`  ${schedule.description}`);
+			item(`  Next: ${schedule.nextRunAt}`);
+			if (schedule.lastRunAt) {
+				const statusLabel =
+					schedule.lastRunStatus === "success"
+						? "success"
+						: `${schedule.lastRunStatus} (${schedule.consecutiveFailures} failures)`;
+				item(`  Last: ${schedule.lastRunAt} - ${statusLabel}`);
+				if (schedule.lastRunDurationMs !== null) {
+					item(`  Duration: ${schedule.lastRunDurationMs}ms`);
+				}
+			}
+			console.error("");
+		}
+	} catch (err) {
+		outputSpinner.stop();
+		console.error("");
+		error(`Failed to list cron schedules: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+}
+
+/**
+ * Delete a cron schedule
+ */
+async function cronDelete(args: string[], options: ServiceOptions): Promise<void> {
+	const expression = args[0];
+
+	if (!expression) {
+		console.error("");
+		error("Cron expression required");
+		info('Usage: jack services cron delete "<expression>"');
+		console.error("");
+		process.exit(1);
+	}
+
+	// Show what will be deleted
+	console.error("");
+	info(`Cron schedule: ${expression}`);
+	console.error("");
+	warn("This will stop all future scheduled runs");
+	console.error("");
+
+	// Confirm deletion
+	const { promptSelect } = await import("../lib/hooks.ts");
+	const choice = await promptSelect(
+		["Yes, delete", "No, cancel"],
+		`Delete cron schedule '${expression}'?`,
+	);
+
+	if (choice !== 0) {
+		info("Cancelled");
+		return;
+	}
+
+	outputSpinner.start("Deleting cron schedule...");
+	try {
+		const result = await deleteCronSchedule(process.cwd(), expression, {
+			interactive: true,
+		});
+		outputSpinner.stop();
+
+		// Track telemetry
+		track(Events.SERVICE_DELETED, {
+			service_type: "cron",
+			deleted: result.deleted,
+		});
+
+		console.error("");
+		success("Cron schedule deleted");
+		console.error("");
+	} catch (err) {
+		outputSpinner.stop();
+		console.error("");
+		error(`Failed to delete cron schedule: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+}
+
+/**
+ * Test/validate a cron expression
+ */
+async function cronTest(args: string[], options: ServiceOptions): Promise<void> {
+	const expression = args[0];
+
+	if (!expression) {
+		console.error("");
+		error("Cron expression required");
+		info('Usage: jack services cron test "<expression>"');
+		console.error("");
+		console.error("Common patterns:");
+		for (const pattern of COMMON_CRON_PATTERNS) {
+			console.error(`  ${pattern.expression.padEnd(15)} ${pattern.description}`);
+		}
+		console.error("");
+		process.exit(1);
+	}
+
+	// Test the expression (no production trigger by default)
+	const result = await testCronExpression(process.cwd(), expression, {
+		interactive: true,
+	});
+
+	if (!result.valid) {
+		console.error("");
+		error(`Invalid cron expression: ${result.error}`);
+		console.error("");
+		console.error("Common patterns:");
+		for (const pattern of COMMON_CRON_PATTERNS) {
+			console.error(`  ${pattern.expression.padEnd(15)} ${pattern.description}`);
+		}
+		console.error("");
+		process.exit(1);
+	}
+
+	console.error("");
+	success("Valid cron expression");
+	console.error("");
+	item(`Expression: ${result.expression}`);
+	item(`Schedule: ${result.description}`);
+	console.error("");
+	info("Next 5 runs (UTC):");
+	for (const time of result.nextTimes!) {
+		item(`  ${time.toISOString()}`);
+	}
+	console.error("");
+
+	// Check if this is a managed project for optional trigger
+	const link = await readProjectLink(process.cwd());
+	if (link?.deploy_mode === "managed") {
+		const { promptSelect } = await import("../lib/hooks.ts");
+		const choice = await promptSelect(
+			["Yes, trigger now", "No, skip"],
+			"Trigger scheduled handler on production?",
+		);
+
+		if (choice === 0) {
+			outputSpinner.start("Triggering scheduled handler...");
+			try {
+				const triggerResult = await testCronExpression(process.cwd(), expression, {
+					triggerProduction: true,
+					interactive: true,
+				});
+				outputSpinner.stop();
+
+				if (triggerResult.triggerResult) {
+					console.error("");
+					success(
+						`Triggered! Status: ${triggerResult.triggerResult.status}, Duration: ${triggerResult.triggerResult.durationMs}ms`,
+					);
+					console.error("");
+				}
+			} catch (err) {
+				outputSpinner.stop();
+				console.error("");
+				error(`Failed to trigger: ${err instanceof Error ? err.message : String(err)}`);
+				console.error("");
+			}
+		}
+	}
+}

package/src/commands/skills.ts

@@ -124,9 +124,12 @@ export default async function skills(subcommand?: string, args: string[] = []):
 		case "remove":
 		case "rm":
 			return await removeSkill(args[0]);
+		case "upgrade":
+		case "update":
+			return await upgradeSkill(args[0]);
 		default:
 			error(`Unknown subcommand: ${subcommand}`);
-			info("Available: run, list, remove");
+			info("Available: run, list, remove, upgrade");
 			process.exit(1);
 	}
 }
@@ -139,6 +142,7 @@ async function showHelp(): Promise<void> {
 	console.log("  run <name>          Install (if needed) and launch agent with skill");
 	console.log("  list                List installed skills in current project");
 	console.log("  remove <name>       Remove a skill from project");
+	console.log("  upgrade <name>      Re-install skill to get latest version");
 	console.log("");
 	const skills = await fetchAvailableSkills();
 	if (skills.length > 0) {
@@ -333,3 +337,56 @@ async function removeSkill(skillName?: string): Promise<void> {
 		info(`Skill ${skillName} not found in project`);
 	}
 }
+
+async function upgradeSkill(skillName?: string): Promise<void> {
+	if (!skillName) {
+		error("Missing skill name");
+		info("Usage: jack skills upgrade <name>");
+		process.exit(1);
+	}
+
+	const projectDir = process.cwd();
+	const skillPath = join(projectDir, ".claude/skills", skillName);
+
+	// Check if installed
+	if (!existsSync(skillPath)) {
+		error(`Skill ${skillName} not installed`);
+		info(`Install it first: jack skills run ${skillName}`);
+		process.exit(1);
+	}
+
+	// Remove existing installation
+	info(`Removing old version of ${skillName}...`);
+	const dirs = [".agents/skills", ".claude/skills", ".codex/skills", ".cursor/skills"];
+	for (const dir of dirs) {
+		const path = join(projectDir, dir, skillName);
+		if (existsSync(path)) {
+			await rm(path, { recursive: true, force: true });
+		}
+	}
+
+	// Re-install from GitHub
+	info(`Installing latest ${skillName}...`);
+	const agentFlags = SUPPORTED_AGENTS.flatMap((a) => ["--agent", a]);
+	const proc = Bun.spawn(
+		["npx", "skills", "add", SKILLS_REPO, "--skill", skillName, ...agentFlags, "--yes"],
+		{
+			cwd: projectDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		},
+	);
+
+	const stderr = await new Response(proc.stderr).text();
+	await proc.exited;
+
+	if (proc.exitCode !== 0) {
+		error(`Failed to upgrade skill: ${skillName}`);
+		if (stderr.trim()) {
+			console.error(stderr);
+		}
+		process.exit(1);
+	}
+
+	success(`Upgraded ${skillName} to latest version`);
+}

package/src/lib/auth/login-flow.ts

@@ -3,6 +3,7 @@
  */
 import { text } from "@clack/prompts";
 import {
+	applyReferralCode,
 	checkUsernameAvailable,
 	getCurrentUserProfile,
 	registerUser,
@@ -114,6 +115,11 @@ export async function runLoginFlow(options?: LoginFlowOptions): Promise<LoginFlo
 					isNewUser = await promptForUsername(tokens.user.email, tokens.user.first_name);
 				}
 
+				// Prompt for referral code for new users only (one-time, no retry)
+				if (isNewUser && process.stdout.isTTY) {
+					await promptForReferral();
+				}
+
 				console.error("");
 				const displayName = tokens.user.first_name || "you";
 				if (isNewUser) {
@@ -294,3 +300,31 @@ function normalizeToUsername(input: string): string {
 		.replace(/^-+|-+$/g, "")
 		.slice(0, 39);
 }
+
+/**
+ * Prompt new users for a referral code (one-time, no retry on failure).
+ */
+async function promptForReferral(): Promise<void> {
+	console.error("");
+	const referralInput = await text({
+		message: "Were you referred by someone? Enter their username (or press Enter to skip):",
+	});
+
+	if (isCancel(referralInput)) {
+		return;
+	}
+
+	const code = referralInput.trim();
+	if (!code) {
+		return;
+	}
+
+	try {
+		const result = await applyReferralCode(code);
+		if (result.applied) {
+			success("Referral applied! You'll both get a bonus when you upgrade.");
+		}
+	} catch {
+		// Silently continue - referral is not critical
+	}
+}

package/src/lib/control-plane.ts

@@ -666,6 +666,35 @@ export async function setUsername(username: string): Promise<SetUsernameResponse
 	return response.json() as Promise<SetUsernameResponse>;
 }
 
+export interface ApplyReferralResult {
+	applied: boolean;
+	reason?: "invalid" | "self_referral" | "already_referred";
+}
+
+/**
+ * Apply a referral code (username) for the current user.
+ * Returns whether the code was applied successfully.
+ */
+export async function applyReferralCode(code: string): Promise<ApplyReferralResult> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/referral/apply`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ code }),
+	});
+
+	if (response.status === 429) {
+		return { applied: false, reason: "invalid" };
+	}
+
+	if (!response.ok) {
+		return { applied: false, reason: "invalid" };
+	}
+
+	return response.json() as Promise<ApplyReferralResult>;
+}
+
 /**
  * Get the current user's profile including username.
  */
@@ -777,6 +806,36 @@ export interface LogSessionInfo {
 	expires_at: string;
 }
 
+// ============================================================================
+// Cron Schedule Types
+// ============================================================================
+
+export interface CronScheduleInfo {
+	id: string;
+	expression: string;
+	description: string;
+	enabled: boolean;
+	next_run_at: string;
+	last_run_at: string | null;
+	last_run_status: string | null;
+	last_run_duration_ms: number | null;
+	consecutive_failures: number;
+	created_at: string;
+}
+
+export interface CreateCronScheduleResponse {
+	id: string;
+	expression: string;
+	description: string;
+	next_run_at: string;
+}
+
+export interface TriggerCronScheduleResponse {
+	triggered: boolean;
+	status: string;
+	duration_ms: number;
+}
+
 export interface StartLogSessionResponse {
 	success: boolean;
 	session: LogSessionInfo;
@@ -807,3 +866,100 @@ export async function startLogSession(
 
 	return response.json() as Promise<StartLogSessionResponse>;
 }
+
+// ============================================================================
+// Cron Schedule Operations
+// ============================================================================
+
+/**
+ * Create a cron schedule for a managed project.
+ */
+export async function createCronSchedule(
+	projectId: string,
+	expression: string,
+): Promise<CreateCronScheduleResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/crons`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ expression }),
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to create cron schedule: ${response.status}`);
+	}
+
+	return response.json() as Promise<CreateCronScheduleResponse>;
+}
+
+/**
+ * List all cron schedules for a managed project.
+ */
+export async function listCronSchedules(projectId: string): Promise<CronScheduleInfo[]> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/crons`);
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to list cron schedules: ${response.status}`);
+	}
+
+	const data = (await response.json()) as { schedules: CronScheduleInfo[] };
+	return data.schedules;
+}
+
+/**
+ * Delete a cron schedule from a managed project.
+ */
+export async function deleteCronSchedule(projectId: string, cronId: string): Promise<void> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/${projectId}/crons/${cronId}`,
+		{ method: "DELETE" },
+	);
+
+	if (response.status === 404) {
+		// Already deleted, treat as success
+		return;
+	}
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to delete cron schedule: ${response.status}`);
+	}
+}
+
+/**
+ * Manually trigger a cron schedule on a managed project.
+ */
+export async function triggerCronSchedule(
+	projectId: string,
+	expression: string,
+): Promise<TriggerCronScheduleResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/projects/${projectId}/crons/trigger`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ expression }),
+	});
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to trigger cron schedule: ${response.status}`);
+	}
+
+	return response.json() as Promise<TriggerCronScheduleResponse>;
+}

package/src/lib/mcp-config.ts

@@ -9,6 +9,7 @@ import { CONFIG_DIR } from "./config.ts";
  * MCP server configuration structure
  */
 export interface McpServerConfig {
+	type: "stdio";
 	command: string;
 	args: string[];
 	env?: Record<string, string>;
@@ -48,19 +49,40 @@ export const APP_MCP_CONFIGS: Record<string, AppMcpConfig> = {
 const JACK_MCP_CONFIG_DIR = join(CONFIG_DIR, "mcp");
 const JACK_MCP_CONFIG_PATH = join(JACK_MCP_CONFIG_DIR, "config.json");
 
+/**
+ * Find the jack binary path
+ * Checks common install locations
+ */
+function findJackBinary(): string {
+	const bunBin = join(homedir(), ".bun", "bin", "jack");
+	const npmBin = join(homedir(), ".npm-global", "bin", "jack");
+	const homebrewBin = "/opt/homebrew/bin/jack";
+	const usrLocalBin = "/usr/local/bin/jack";
+
+	// Check in order of priority
+	for (const path of [bunBin, npmBin, homebrewBin, usrLocalBin]) {
+		if (existsSync(path)) {
+			return path;
+		}
+	}
+
+	// Fallback to just "jack" and hope PATH works
+	return "jack";
+}
+
 /**
  * Returns the jack MCP server configuration
- * Includes PATH with common install locations so Claude Desktop can find jack
+ * Uses full path to jack binary for reliability
  */
 export function getJackMcpConfig(): McpServerConfig {
-	// Build PATH with common locations where jack might be installed
-	// ~/.bun/bin is where `bun link` installs global commands
+	// Build PATH with common locations (still needed for child processes)
 	const bunBin = join(homedir(), ".bun", "bin");
 	const npmBin = join(homedir(), ".npm-global", "bin");
 	const defaultPaths = [bunBin, npmBin, "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
 
 	return {
-		command: "jack",
+		type: "stdio",
+		command: findJackBinary(),
 		args: ["mcp", "serve"],
 		env: {
 			PATH: defaultPaths.join(":"),

package/src/lib/output.ts

@@ -179,7 +179,8 @@ export function box(title: string, lines: string[]): void {
 	const gradient = "░".repeat(innerWidth);
 
 	// Truncate text if too long for box
-	const truncate = (text: string) => (text.length > maxLen ? text.slice(0, maxLen - 1) + "…" : text);
+	const truncate = (text: string) =>
+		text.length > maxLen ? text.slice(0, maxLen - 1) + "…" : text;
 
 	// Pad plain text first, then apply colors (ANSI codes break padEnd calculation)
 	const pad = (text: string) => `  ${truncate(text).padEnd(maxLen)}  `;
@@ -226,7 +227,8 @@ export function celebrate(title: string, lines: string[]): void {
 	const space = " ".repeat(innerWidth);
 
 	// Truncate text if too long for box
-	const truncate = (text: string) => (text.length > maxLen ? text.slice(0, maxLen - 1) + "…" : text);
+	const truncate = (text: string) =>
+		text.length > maxLen ? text.slice(0, maxLen - 1) + "…" : text;
 
 	// Center text based on visual length, then apply colors
 	const center = (text: string, applyBold = false) => {