@getjack/jack 0.1.30 → 0.1.32

package/src/mcp/resources/index.ts

@@ -31,6 +31,13 @@ export function registerResources(
 					description: "Semantic information about jack's capabilities for AI agents",
 					mimeType: "application/json",
 				},
+				{
+					uri: "agents://workflows",
+					name: "Workflow Recipes",
+					description:
+						"Multi-step workflow templates for common tasks like creating APIs with databases, debugging production issues, and setting up cron jobs",
+					mimeType: "text/markdown",
+				},
 			],
 		};
 	});
@@ -160,6 +167,172 @@ Check for JACK.md in the project root for project-specific instructions.
 			};
 		}
 
+		if (uri === "agents://workflows") {
+			const workflows = `# Jack Workflow Recipes
+
+Multi-step workflows for common tasks. Each workflow can be executed by an agent team or a single agent working sequentially.
+
+---
+
+## 1. Create API with Database
+
+Goal: Scaffold a new API, add a database, create tables, and verify.
+
+\`\`\`
+Step 1: Create project
+  jack new my-api --template api
+
+Step 2: Add database
+  mcp__jack__create_database (or: jack services db create)
+
+Step 3: Create schema
+  mcp__jack__execute_sql
+    sql: "CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT NOT NULL, created_at TEXT DEFAULT CURRENT_TIMESTAMP)"
+    allow_write: true
+
+Step 4: Edit src/index.ts — add routes that use c.env.DB
+
+Step 5: Deploy
+  mcp__jack__deploy_project (or: jack ship)
+
+Step 6: Verify
+  curl https://<slug>.runjack.xyz/api/items
+\`\`\`
+
+---
+
+## 2. Debug Production Issue
+
+Goal: Identify and fix a bug reported in production.
+
+\`\`\`
+Step 1: Check current status
+  mcp__jack__get_project_status (or: jack info)
+
+Step 2: Collect recent logs
+  mcp__jack__tail_logs with max_events: 100, duration_ms: 5000
+
+Step 3: Inspect database state if relevant
+  mcp__jack__execute_sql
+    sql: "SELECT * FROM <table> WHERE <condition>"
+
+Step 4: Read and fix the source code
+
+Step 5: Deploy fix
+  mcp__jack__deploy_project (or: jack ship)
+
+Step 6: Verify fix via logs
+  mcp__jack__tail_logs with max_events: 20, duration_ms: 3000
+\`\`\`
+
+---
+
+## 3. Add Scheduled Task (Cron)
+
+Goal: Run code on a schedule (cleanup, sync, reports).
+
+\`\`\`
+Step 1: Add scheduled handler to src/index.ts
+  export default {
+    async fetch(request, env) { ... },
+    async scheduled(event, env, ctx) {
+      // your cron logic here
+    },
+  };
+
+  Or with Hono, add a POST /__scheduled route.
+
+Step 2: Deploy the handler
+  mcp__jack__deploy_project (or: jack ship)
+
+Step 3: Create cron schedule
+  mcp__jack__create_cron with expression: "0 * * * *"
+  (or: jack services cron create "0 * * * *")
+
+Step 4: Verify schedule
+  mcp__jack__test_cron with expression: "0 * * * *"
+  Shows next 5 scheduled times.
+
+Step 5: Monitor via logs
+  mcp__jack__tail_logs
+\`\`\`
+
+---
+
+## 4. Add File Storage
+
+Goal: Enable file uploads and downloads via R2.
+
+\`\`\`
+Step 1: Create storage bucket
+  mcp__jack__create_storage_bucket (or: jack services storage create)
+
+Step 2: Deploy to activate binding
+  mcp__jack__deploy_project (or: jack ship)
+
+Step 3: Add upload/download routes to src/index.ts
+  Upload:  c.env.BUCKET.put(key, body)
+  Download: c.env.BUCKET.get(key)
+  List:    c.env.BUCKET.list()
+
+Step 4: Deploy routes
+  mcp__jack__deploy_project (or: jack ship)
+\`\`\`
+
+---
+
+## 5. Add Semantic Search (Vectorize + AI)
+
+Goal: Enable vector similarity search using embeddings.
+
+\`\`\`
+Step 1: Create vector index
+  mcp__jack__create_vectorize_index (or: jack services vectorize create)
+  Default: 768 dimensions, cosine metric (matches bge-base-en-v1.5)
+
+Step 2: Deploy to activate binding
+  mcp__jack__deploy_project (or: jack ship)
+
+Step 3: Add indexing route
+  Generate embedding: c.env.AI.run("@cf/baai/bge-base-en-v1.5", { text: [input] })
+  Insert: c.env.VECTORIZE_INDEX.insert([{ id, values, metadata }])
+
+Step 4: Add search route
+  Generate query embedding, then:
+  c.env.VECTORIZE_INDEX.query(embedding, { topK: 5, returnMetadata: "all" })
+
+Step 5: Deploy and test
+  mcp__jack__deploy_project (or: jack ship)
+\`\`\`
+
+---
+
+## Parallel Task Patterns (Agent Teams)
+
+For Opus 4.6 Agent Teams, these tasks can run in parallel:
+
+**Independent (run simultaneously):**
+- Creating database + creating storage bucket
+- Reading logs + checking project status
+- Multiple SQL queries on different tables
+
+**Sequential (must wait for previous):**
+- Create project → then add services
+- Create database → then create tables → then deploy
+- Edit code → then deploy → then verify
+`;
+
+			return {
+				contents: [
+					{
+						uri,
+						mimeType: "text/markdown",
+						text: workflows,
+					},
+				],
+			};
+		}
+
 		throw new Error(`Unknown resource URI: ${uri}`);
 	});
 }

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