@getjack/jack 0.1.30 → 0.1.32

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,
@@ -95,6 +99,7 @@ async function resolveDatabaseInfo(projectName: string): Promise<ResolvedDatabas
 
 interface ServiceOptions {
 	project?: string;
+	json?: boolean;
 }
 
 export default async function services(
@@ -111,9 +116,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 +132,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("");
@@ -202,17 +210,23 @@ async function resolveProjectName(options: ServiceOptions): Promise<string> {
  * Show database information
  */
 async function dbInfo(options: ServiceOptions): Promise<void> {
+	const jsonOutput = options.json ?? false;
 	const projectName = await resolveProjectName(options);
 	const projectDir = process.cwd();
 	const link = await readProjectLink(projectDir);
 
 	// For managed projects, use control plane API (no wrangler dependency)
 	if (link?.deploy_mode === "managed") {
-		outputSpinner.start("Fetching database info...");
+		if (!jsonOutput) outputSpinner.start("Fetching database info...");
 		try {
 			const { getManagedDatabaseInfo } = await import("../lib/control-plane.ts");
 			const dbInfo = await getManagedDatabaseInfo(link.project_id);
-			outputSpinner.stop();
+			if (!jsonOutput) outputSpinner.stop();
+
+			if (jsonOutput) {
+				console.log(JSON.stringify({ name: dbInfo.name, id: dbInfo.id, sizeBytes: dbInfo.sizeBytes, numTables: dbInfo.numTables, source: "managed" }));
+				return;
+			}
 
 			console.error("");
 			success(`Database: ${dbInfo.name}`);
@@ -224,7 +238,14 @@ async function dbInfo(options: ServiceOptions): Promise<void> {
 			console.error("");
 			return;
 		} catch (err) {
-			outputSpinner.stop();
+			if (!jsonOutput) outputSpinner.stop();
+			if (jsonOutput) {
+				const msg = err instanceof Error && err.message.includes("No database found")
+					? "No database configured. Run 'jack services db create' to create one."
+					: `Failed to fetch database info: ${err instanceof Error ? err.message : String(err)}`;
+				console.log(JSON.stringify({ success: false, error: msg }));
+				process.exit(1);
+			}
 			console.error("");
 			if (err instanceof Error && err.message.includes("No database found")) {
 				error("No database found for this project");
@@ -241,6 +262,10 @@ async function dbInfo(options: ServiceOptions): Promise<void> {
 	const dbInfo = await resolveDatabaseInfo(projectName);
 
 	if (!dbInfo) {
+		if (jsonOutput) {
+			console.log(JSON.stringify({ success: false, error: "No database found for this project" }));
+			return;
+		}
 		console.error("");
 		error("No database found for this project");
 		info("Create one with: jack services db create");
@@ -249,11 +274,15 @@ async function dbInfo(options: ServiceOptions): Promise<void> {
 	}
 
 	// Fetch detailed database info via wrangler
-	outputSpinner.start("Fetching database info...");
+	if (!jsonOutput) outputSpinner.start("Fetching database info...");
 	const wranglerDbInfo = await getWranglerDatabaseInfo(dbInfo.name);
-	outputSpinner.stop();
+	if (!jsonOutput) outputSpinner.stop();
 
 	if (!wranglerDbInfo) {
+		if (jsonOutput) {
+			console.log(JSON.stringify({ success: false, error: "Database not found" }));
+			process.exit(1);
+		}
 		console.error("");
 		error("Database not found");
 		info("It may have been deleted");
@@ -261,6 +290,11 @@ async function dbInfo(options: ServiceOptions): Promise<void> {
 		process.exit(1);
 	}
 
+	if (jsonOutput) {
+		console.log(JSON.stringify({ name: wranglerDbInfo.name, id: dbInfo.id || wranglerDbInfo.id, sizeBytes: wranglerDbInfo.sizeBytes, numTables: wranglerDbInfo.numTables, source: "byo" }));
+		return;
+	}
+
 	// Display info
 	console.error("");
 	success(`Database: ${wranglerDbInfo.name}`);
@@ -617,10 +651,16 @@ async function dbCreate(args: string[], options: ServiceOptions): Promise<void>
  * List all databases in the project
  */
 async function dbList(options: ServiceOptions): Promise<void> {
-	outputSpinner.start("Fetching databases...");
+	const jsonOutput = options.json ?? false;
+	if (!jsonOutput) outputSpinner.start("Fetching databases...");
 	try {
 		const databases = await listDatabases(process.cwd());
-		outputSpinner.stop();
+		if (!jsonOutput) outputSpinner.stop();
+
+		if (jsonOutput) {
+			console.log(JSON.stringify(databases));
+			return;
+		}
 
 		if (databases.length === 0) {
 			console.error("");
@@ -647,7 +687,11 @@ async function dbList(options: ServiceOptions): Promise<void> {
 			console.error("");
 		}
 	} catch (err) {
-		outputSpinner.stop();
+		if (!jsonOutput) outputSpinner.stop();
+		if (jsonOutput) {
+			console.log(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+			process.exit(1);
+		}
 		console.error("");
 		error(`Failed to list databases: ${err instanceof Error ? err.message : String(err)}`);
 		process.exit(1);
@@ -722,7 +766,8 @@ function parseExecuteArgs(args: string[]): ExecuteArgs {
 /**
  * Execute SQL against the database
  */
-async function dbExecute(args: string[], _options: ServiceOptions): Promise<void> {
+async function dbExecute(args: string[], options: ServiceOptions): Promise<void> {
+	const jsonOutput = options.json ?? false;
 	const execArgs = parseExecuteArgs(args);
 
 	// Validate input
@@ -759,7 +804,7 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 	const projectDir = process.cwd();
 
 	try {
-		outputSpinner.start("Executing SQL...");
+		if (!jsonOutput) outputSpinner.start("Executing SQL...");
 
 		let result;
 		if (execArgs.filePath) {
@@ -816,7 +861,7 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 			}
 
 			// NOW execute with confirmation
-			outputSpinner.start("Executing SQL...");
+			if (!jsonOutput) outputSpinner.start("Executing SQL...");
 			if (execArgs.filePath) {
 				result = await executeSqlFile({
 					projectDir,
@@ -850,12 +895,37 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 				error_type: "execution_failed",
 			});
 
+			if (jsonOutput) {
+				console.log(JSON.stringify({ success: false, error: result.error || "SQL execution failed" }));
+				process.exit(1);
+			}
+
 			console.error("");
 			error(result.error || "SQL execution failed");
 			console.error("");
 			process.exit(1);
 		}
 
+		// Track telemetry
+		track(Events.SQL_EXECUTED, {
+			success: true,
+			risk_level: result.risk,
+			statement_count: result.statements.length,
+			from_file: !!execArgs.filePath,
+		});
+
+		// JSON output mode — structured result for agents
+		if (jsonOutput) {
+			console.log(JSON.stringify({
+				success: true,
+				results: result.results ?? [],
+				meta: result.meta,
+				risk: result.risk,
+				warning: result.warning,
+			}));
+			return;
+		}
+
 		// Show results
 		console.error("");
 		success(`SQL executed (${getRiskDescription(result.risk)})`);
@@ -879,14 +949,6 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 			console.log(JSON.stringify(result.results, null, 2));
 		}
 		console.error("");
-
-		// Track telemetry
-		track(Events.SQL_EXECUTED, {
-			success: true,
-			risk_level: result.risk,
-			statement_count: result.statements.length,
-			from_file: !!execArgs.filePath,
-		});
 	} catch (err) {
 		outputSpinner.stop();
 
@@ -897,6 +959,11 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 				risk_level: err.risk,
 			});
 
+			if (jsonOutput) {
+				console.log(JSON.stringify({ success: false, error: err.message, suggestion: "Add --write flag" }));
+				process.exit(1);
+			}
+
 			console.error("");
 			error(err.message);
 			info("Add the --write flag to allow data modification:");
@@ -912,6 +979,11 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 				risk_level: "destructive",
 			});
 
+			if (jsonOutput) {
+				console.log(JSON.stringify({ success: false, error: err.message, suggestion: "Destructive operations require confirmation via CLI" }));
+				process.exit(1);
+			}
+
 			console.error("");
 			error(err.message);
 			info("Destructive operations require confirmation via CLI.");
@@ -924,6 +996,11 @@ async function dbExecute(args: string[], _options: ServiceOptions): Promise<void
 			error_type: "unknown",
 		});
 
+		if (jsonOutput) {
+			console.log(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
+			process.exit(1);
+		}
+
 		console.error("");
 		error(`SQL execution failed: ${err instanceof Error ? err.message : String(err)}`);
 		console.error("");
@@ -1181,3 +1258,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/ship.ts

@@ -3,14 +3,15 @@ import { createReporter, output } from "../lib/output.ts";
 import { deployProject } from "../lib/project-operations.ts";
 
 export default async function ship(
-	options: { managed?: boolean; byo?: boolean; dryRun?: boolean } = {},
+	options: { managed?: boolean; byo?: boolean; dryRun?: boolean; json?: boolean } = {},
 ): Promise<void> {
 	const isCi = process.env.CI === "true" || process.env.CI === "1";
+	const jsonOutput = options.json ?? false;
 	try {
 		const result = await deployProject({
 			projectPath: process.cwd(),
-			reporter: createReporter(),
-			interactive: !isCi,
+			reporter: jsonOutput ? undefined : createReporter(),
+			interactive: !isCi && !jsonOutput,
 			includeSecrets: !options.dryRun,
 			includeSync: !options.dryRun,
 			managed: options.managed,
@@ -18,11 +19,35 @@ export default async function ship(
 			dryRun: options.dryRun,
 		});
 
+		if (jsonOutput) {
+			console.log(
+				JSON.stringify({
+					success: true,
+					projectName: result.projectName,
+					url: result.workerUrl,
+					deployMode: result.deployMode,
+				}),
+			);
+			return;
+		}
+
 		if (!result.workerUrl && result.deployOutput) {
 			console.error(result.deployOutput);
 		}
 	} catch (error) {
 		const details = getErrorDetails(error);
+
+		if (jsonOutput) {
+			console.log(
+				JSON.stringify({
+					success: false,
+					error: details.message,
+					suggestion: details.suggestion,
+				}),
+			);
+			process.exit(details.meta?.exitCode ?? 1);
+		}
+
 		if (!details.meta?.reported) {
 			output.error(details.message);
 		}

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`);
+}