@getjack/jack 0.1.29 → 0.1.31

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(() => {});
 }

package/src/mcp/tools/index.ts

@@ -15,6 +15,10 @@ import {
 	wrapResultsForMcp,
 } from "../../lib/services/db-execute.ts";
 import { listDatabases } from "../../lib/services/db-list.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 { testCronExpression } from "../../lib/services/cron-test.ts";
 import {
 	assignDomain,
 	connectDomain,
@@ -215,6 +219,42 @@ const DisconnectDomainSchema = z.object({
 	hostname: z.string().describe("The domain hostname to disconnect (fully remove)"),
 });
 
+const CreateCronSchema = z.object({
+	expression: z.string().describe("Cron expression (e.g., '0 * * * *' for hourly, '*/15 * * * *' for every 15 min)"),
+	project_path: z
+		.string()
+		.optional()
+		.describe("Path to project directory (defaults to current directory)"),
+});
+
+const ListCronsSchema = z.object({
+	project_path: z
+		.string()
+		.optional()
+		.describe("Path to project directory (defaults to current directory)"),
+});
+
+const DeleteCronSchema = z.object({
+	expression: z.string().describe("Cron expression to delete"),
+	project_path: z
+		.string()
+		.optional()
+		.describe("Path to project directory (defaults to current directory)"),
+});
+
+const TestCronSchema = z.object({
+	expression: z.string().describe("Cron expression to test"),
+	project_path: z
+		.string()
+		.optional()
+		.describe("Path to project directory (defaults to current directory)"),
+	trigger_production: z
+		.boolean()
+		.optional()
+		.default(false)
+		.describe("Whether to trigger the cron handler on production (requires managed project)"),
+});
+
 export function registerTools(server: McpServer, _options: McpServerOptions, debug: DebugLogger) {
 	// Register tool list handler
 	server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -611,6 +651,80 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 						required: ["hostname"],
 					},
 				},
+				{
+					name: "create_cron",
+					description:
+						"Create a cron schedule for a managed (Jack Cloud) project. Minimum interval is 15 minutes. The worker must have a scheduled() handler or POST /__scheduled route.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							expression: {
+								type: "string",
+								description: "Cron expression (e.g., '0 * * * *' for hourly, '*/15 * * * *' for every 15 min)",
+							},
+							project_path: {
+								type: "string",
+								description: "Path to project directory (defaults to current directory)",
+							},
+						},
+						required: ["expression"],
+					},
+				},
+				{
+					name: "list_crons",
+					description: "List all cron schedules for a managed (Jack Cloud) project.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							project_path: {
+								type: "string",
+								description: "Path to project directory (defaults to current directory)",
+							},
+						},
+					},
+				},
+				{
+					name: "delete_cron",
+					description: "Delete a cron schedule by its expression.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							expression: {
+								type: "string",
+								description: "Cron expression to delete",
+							},
+							project_path: {
+								type: "string",
+								description: "Path to project directory (defaults to current directory)",
+							},
+						},
+						required: ["expression"],
+					},
+				},
+				{
+					name: "test_cron",
+					description:
+						"Test a cron expression: validate, show human-readable description, and display next 5 scheduled times. Optionally trigger the handler on production.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							expression: {
+								type: "string",
+								description: "Cron expression to test",
+							},
+							project_path: {
+								type: "string",
+								description: "Path to project directory (defaults to current directory)",
+							},
+							trigger_production: {
+								type: "boolean",
+								default: false,
+								description: "Whether to trigger the cron handler on production (requires managed project)",
+							},
+						},
+						required: ["expression"],
+					},
+				},
 			],
 		};
 	});
@@ -1566,6 +1680,171 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 					};
 				}
 
+				case "create_cron": {
+					const args = CreateCronSchema.parse(request.params.arguments ?? {});
+					const projectPath = args.project_path ?? process.cwd();
+
+					const wrappedCreateCron = withTelemetry(
+						"create_cron",
+						async (projectDir: string, expression: string) => {
+							const result = await createCronSchedule(projectDir, expression, {
+								interactive: false,
+							});
+
+							track(Events.SERVICE_CREATED, {
+								service_type: "cron",
+								platform: "mcp",
+							});
+
+							return {
+								id: result.id,
+								expression: result.expression,
+								description: result.description,
+								next_run_at: result.nextRunAt,
+								created: result.created,
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedCreateCron(projectPath, args.expression);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
+				case "list_crons": {
+					const args = ListCronsSchema.parse(request.params.arguments ?? {});
+					const projectPath = args.project_path ?? process.cwd();
+
+					const wrappedListCrons = withTelemetry(
+						"list_crons",
+						async (projectDir: string) => {
+							const schedules = await listCronSchedules(projectDir);
+							return {
+								schedules: schedules.map((s) => ({
+									id: s.id,
+									expression: s.expression,
+									description: s.description,
+									enabled: s.enabled,
+									next_run_at: s.nextRunAt,
+									last_run_at: s.lastRunAt,
+									last_run_status: s.lastRunStatus,
+									last_run_duration_ms: s.lastRunDurationMs,
+									consecutive_failures: s.consecutiveFailures,
+									created_at: s.createdAt,
+								})),
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedListCrons(projectPath);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
+				case "delete_cron": {
+					const args = DeleteCronSchema.parse(request.params.arguments ?? {});
+					const projectPath = args.project_path ?? process.cwd();
+
+					const wrappedDeleteCron = withTelemetry(
+						"delete_cron",
+						async (projectDir: string, expression: string) => {
+							const result = await deleteCronSchedule(projectDir, expression, {
+								interactive: false,
+							});
+
+							track(Events.SERVICE_DELETED, {
+								service_type: "cron",
+								platform: "mcp",
+							});
+
+							return {
+								expression: result.expression,
+								deleted: result.deleted,
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedDeleteCron(projectPath, args.expression);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
+				case "test_cron": {
+					const args = TestCronSchema.parse(request.params.arguments ?? {});
+					const projectPath = args.project_path ?? process.cwd();
+
+					const wrappedTestCron = withTelemetry(
+						"test_cron",
+						async (projectDir: string, expression: string, triggerProduction: boolean) => {
+							const result = await testCronExpression(projectDir, expression, {
+								triggerProduction,
+								interactive: false,
+							});
+
+							if (!result.valid) {
+								return {
+									valid: false,
+									error: result.error,
+								};
+							}
+
+							return {
+								valid: true,
+								expression: result.expression,
+								description: result.description,
+								next_times: result.nextTimes?.map((d) => d.toISOString()),
+								trigger_result: result.triggerResult
+									? {
+											triggered: result.triggerResult.triggered,
+											status: result.triggerResult.status,
+											duration_ms: result.triggerResult.durationMs,
+										}
+									: undefined,
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedTestCron(
+						projectPath,
+						args.expression,
+						args.trigger_production ?? false,
+					);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
 				default:
 					throw new Error(`Unknown tool: ${toolName}`);
 			}