@getjack/jack 0.1.32 → 0.1.33

package/templates/ai-chat/src/index.ts

@@ -1,49 +1,32 @@
+import { Hono } from "hono";
+import { streamText, convertToCoreMessages, type Message } from "ai";
+import { createWorkersAI } from "workers-ai-provider";
 import { createJackAI } from "./jack-ai";
 
 interface Env {
-	// Direct AI binding (for local dev with wrangler)
 	AI?: Ai;
-	// Jack proxy bindings (injected in jack cloud)
 	__AI_PROXY?: Fetcher;
 	__JACK_PROJECT_ID?: string;
 	__JACK_ORG_ID?: string;
-	// Assets binding
 	ASSETS: Fetcher;
+	DB: D1Database;
 }
 
 function getAI(env: Env) {
-	// Prefer jack cloud proxy if available (for metering)
 	if (env.__AI_PROXY && env.__JACK_PROJECT_ID && env.__JACK_ORG_ID) {
 		return createJackAI(
-			env as Required<Pick<Env, "__AI_PROXY" | "__JACK_PROJECT_ID" | "__JACK_ORG_ID">>,
+			env as Required<
+				Pick<Env, "__AI_PROXY" | "__JACK_PROJECT_ID" | "__JACK_ORG_ID">
+			>,
 		);
 	}
-	// Fallback to direct binding for local dev
-	if (env.AI) {
-		return env.AI;
-	}
+	if (env.AI) return env.AI;
 	throw new Error("No AI binding available");
 }
 
-interface ChatMessage {
-	role: "user" | "assistant" | "system";
-	content: string;
-}
-
-// System prompt - customize this to change the AI's personality
-const SYSTEM_PROMPT = `You are a helpful AI assistant built with jack (getjack.sh).
-
-jack helps developers ship ideas fast - from "what if" to a live URL in seconds. You're running on Cloudflare's edge network, close to users worldwide.
-
-Be concise, friendly, and helpful. If asked about jack:
-- jack new creates projects from templates
-- jack ship deploys to production
-- jack open opens your app in browser
-- Docs: https://docs.getjack.sh
+const SYSTEM_PROMPT = `You are a helpful AI assistant. Be concise, friendly, and helpful. Keep responses short unless detail is needed.`;
 
-Focus on being useful. Keep responses short unless detail is needed.`;
-
-// Rate limiting: 10 requests per minute per IP
+// Rate limiting
 const RATE_LIMIT = 10;
 const RATE_WINDOW_MS = 60_000;
 const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
@@ -51,91 +34,92 @@ const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
 function checkRateLimit(ip: string): boolean {
 	const now = Date.now();
 	const entry = rateLimitMap.get(ip);
-
 	if (!entry || now >= entry.resetAt) {
 		rateLimitMap.set(ip, { count: 1, resetAt: now + RATE_WINDOW_MS });
 		return true;
 	}
-
-	if (entry.count >= RATE_LIMIT) {
-		return false;
-	}
-
+	if (entry.count >= RATE_LIMIT) return false;
 	entry.count++;
 	return true;
 }
 
-// Clean up old entries periodically to prevent memory leaks
-function cleanupRateLimitMap(): void {
-	const now = Date.now();
-	for (const [ip, entry] of rateLimitMap) {
-		if (now >= entry.resetAt) {
-			rateLimitMap.delete(ip);
-		}
+const app = new Hono<{ Bindings: Env }>();
+
+// Create new chat
+app.post("/api/chat/new", async (c) => {
+	const id = crypto.randomUUID();
+	await c.env.DB.prepare("INSERT INTO chats (id) VALUES (?)").bind(id).run();
+	return c.json({ id });
+});
+
+// Load chat history
+app.get("/api/chat/:id", async (c) => {
+	const chatId = c.req.param("id");
+	const { results } = await c.env.DB.prepare(
+		"SELECT id, role, content, created_at FROM messages WHERE chat_id = ? ORDER BY created_at ASC",
+	)
+		.bind(chatId)
+		.all();
+	return c.json({ messages: results || [] });
+});
+
+// Chat endpoint with streaming
+app.post("/api/chat", async (c) => {
+	const ip = c.req.header("cf-connecting-ip") || "unknown";
+	if (!checkRateLimit(ip)) {
+		return c.json({ error: "Too many requests. Please wait a moment." }, 429);
 	}
-}
 
-export default {
-	async fetch(request: Request, env: Env): Promise<Response> {
-		const url = new URL(request.url);
-
-		// Serve static assets for non-API routes
-		if (request.method === "GET" && !url.pathname.startsWith("/api")) {
-			return env.ASSETS.fetch(request);
-		}
-
-		// POST /api/chat - Streaming chat endpoint
-		if (request.method === "POST" && url.pathname === "/api/chat") {
-			const ip = request.headers.get("cf-connecting-ip") || "unknown";
-
-			// Check rate limit
-			if (!checkRateLimit(ip)) {
-				// Cleanup old entries occasionally
-				cleanupRateLimitMap();
-				return Response.json(
-					{ error: "Too many requests. Please wait a moment and try again." },
-					{ status: 429 },
-				);
-			}
+	const { messages, chatId } = await c.req.json<{
+		messages: Message[];
+		chatId?: string;
+	}>();
+	if (!messages || !Array.isArray(messages)) {
+		return c.json({ error: "Invalid request." }, 400);
+	}
 
-			try {
-				const body = (await request.json()) as { messages?: ChatMessage[] };
-				let messages = body.messages;
-
-				if (!messages || !Array.isArray(messages)) {
-					return Response.json(
-						{ error: "Invalid request. Please provide a messages array." },
-						{ status: 400 },
-					);
-				}
-
-				// Prepend system prompt if not already present
-				if (messages.length === 0 || messages[0].role !== "system") {
-					messages = [{ role: "system", content: SYSTEM_PROMPT }, ...messages];
-				}
-
-				// Stream response using Llama 3.2 1B - cheapest model with good quality
-				// See: https://developers.cloudflare.com/workers-ai/models/
-				const ai = getAI(env);
-				const stream = await ai.run("@cf/meta/llama-3.2-1b-instruct", {
-					messages,
-					stream: true,
-					max_tokens: 1024,
-				});
-
-				return new Response(stream, {
-					headers: {
-						"Content-Type": "text/event-stream",
-						"Cache-Control": "no-cache",
-						Connection: "keep-alive",
-					},
-				});
-			} catch (err) {
-				console.error("Chat error:", err);
-				return Response.json({ error: "Something went wrong. Please try again." }, { status: 500 });
+	// Save user message to DB if we have a chatId
+	const lastUserMsg = messages.findLast((m: Message) => m.role === "user");
+	if (chatId && lastUserMsg) {
+		await c.env.DB.prepare(
+			"INSERT INTO messages (id, chat_id, role, content) VALUES (?, ?, ?, ?)",
+		)
+			.bind(
+				crypto.randomUUID(),
+				chatId,
+				"user",
+				typeof lastUserMsg.content === "string"
+					? lastUserMsg.content
+					: JSON.stringify(lastUserMsg.content),
+			)
+			.run();
+	}
+
+	const ai = getAI(c.env);
+	const provider = createWorkersAI({ binding: ai as Ai });
+
+	const result = streamText({
+		model: provider("@cf/meta/llama-3.3-70b-instruct-fp8-fast"),
+		system: SYSTEM_PROMPT,
+		messages: convertToCoreMessages(messages),
+		onFinish: async ({ text }) => {
+			// Save assistant response to DB
+			if (chatId && text) {
+				await c.env.DB.prepare(
+					"INSERT INTO messages (id, chat_id, role, content) VALUES (?, ?, ?, ?)",
+				)
+					.bind(crypto.randomUUID(), chatId, "assistant", text)
+					.run();
 			}
-		}
+		},
+	});
+
+	return result.toDataStreamResponse();
+});
+
+// Serve static assets for non-API routes
+app.get("*", async (c) => {
+	return c.env.ASSETS.fetch(c.req.raw);
+});
 
-		return Response.json({ error: "Not found" }, { status: 404 });
-	},
-};
+export default app;

package/templates/ai-chat/wrangler.jsonc

@@ -2,11 +2,18 @@
 	"name": "jack-template",
 	"main": "src/index.ts",
 	"compatibility_date": "2024-12-01",
+	"compatibility_flags": ["nodejs_compat"],
 	"ai": {
 		"binding": "AI"
 	},
 	"assets": {
 		"directory": "public",
 		"binding": "ASSETS"
-	}
+	},
+	"d1_databases": [
+		{
+			"binding": "DB",
+			"database_name": "jack-template-db"
+		}
+	]
 }

package/templates/cron/.jack.json

@@ -0,0 +1,66 @@
+{
+	"name": "cron",
+	"description": "Background tasks with cron scheduling and webhook ingestion",
+	"secrets": [],
+	"capabilities": ["db"],
+	"requires": ["DB", "CRON"],
+	"intent": {
+		"keywords": [
+			"cron",
+			"background",
+			"jobs",
+			"webhook",
+			"scheduled",
+			"queue",
+			"worker",
+			"tasks"
+		],
+		"examples": [
+			"background job processor",
+			"scheduled tasks",
+			"webhook handler",
+			"job queue"
+		]
+	},
+	"agentContext": {
+		"summary": "A background task worker with cron scheduling, D1 job queue, and webhook ingestion.",
+		"full_text": "## Project Structure\n\n- `src/index.ts` - Hono API with cron handler, webhook endpoint, and job status routes\n- `src/jobs.ts` - Job queue: create, process, retry with D1 backend\n- `src/webhooks.ts` - Webhook ingestion with HMAC-SHA256 signature verification\n- `schema.sql` - D1 schema (jobs, webhook_events)\n\n## Cron\n\nThe `POST /__scheduled` route runs on a cron schedule (default: every 5 minutes). It processes pending jobs and retries failed ones.\n\n## Jobs\n\n```typescript\n// Create a job\nawait createJob(db, { type: 'process-order', payload: { orderId: '123' } });\n\n// Jobs are processed automatically by cron\n// Failed jobs retry up to 3 times with exponential backoff\n```\n\n## Webhooks\n\n```\nPOST /webhook\nX-Signature: sha256=abc123...\nContent-Type: application/json\n\n{ \"event\": \"order.completed\", \"data\": { ... } }\n```\n\nWebhooks are verified using HMAC-SHA256, logged to D1, and can create jobs for async processing.\n\n## Endpoints\n\n- `POST /__scheduled` - Cron handler (called by scheduler)\n- `POST /webhook` - Inbound webhook receiver with signature verification\n- `GET /jobs` - List recent jobs with status\n- `GET /health` - Health check\n\n## Environment Variables\n\n- `WEBHOOK_SECRET` - HMAC signing secret for webhook verification (auto-generated)\n\n## Resources\n\n- [Hono Documentation](https://hono.dev)"
+	},
+	"hooks": {
+		"preCreate": [
+			{
+				"action": "require",
+				"source": "secret",
+				"key": "WEBHOOK_SECRET",
+				"message": "Generating webhook signing secret...",
+				"onMissing": "generate",
+				"generateCommand": "openssl rand -hex 32"
+			}
+		],
+		"postDeploy": [
+			{
+				"action": "clipboard",
+				"text": "{{url}}",
+				"message": "Deploy URL copied to clipboard"
+			},
+			{
+				"action": "shell",
+				"command": "curl -s {{url}}/health | head -c 200",
+				"message": "Testing worker health..."
+			},
+			{
+				"action": "box",
+				"title": "Background worker live: {{name}}",
+				"lines": [
+					"{{url}}",
+					"",
+					"Endpoints:",
+					"  POST {{url}}/webhook  — inbound webhook receiver",
+					"  GET  {{url}}/jobs     — job queue status",
+					"",
+					"Cron: runs every 5 minutes"
+				]
+			}
+		]
+	}
+}

package/templates/cron/bun.lock

@@ -0,0 +1,23 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "jack-template",
+      "dependencies": {
+        "hono": "^4.6.0",
+      },
+      "devDependencies": {
+        "@cloudflare/workers-types": "^4.20241205.0",
+        "typescript": "^5.0.0",
+      },
+    },
+  },
+  "packages": {
+    "@cloudflare/workers-types": ["@cloudflare/workers-types@4.20260212.0", "", {}, "sha512-ZK+e8T/2tWBCrE8PoAi9oqTxcBen9Apq+dxbsy1R5LFVdB6M4pY+oP49OFuHTTezrvNXbyvmzbf/vjtrCPGdNg=="],
+
+    "hono": ["hono@4.11.9", "", {}, "sha512-Eaw2YTGM6WOxA6CXbckaEvslr2Ne4NFsKrvc0v97JD5awbmeBLO5w9Ho9L9kmKonrwF9RJlW6BxT1PVv/agBHQ=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+  }
+}

package/templates/cron/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "jack-template",
+	"type": "module",
+	"private": true,
+	"scripts": {
+		"dev": "wrangler dev",
+		"deploy": "wrangler deploy"
+	},
+	"dependencies": {
+		"hono": "^4.6.0"
+	},
+	"devDependencies": {
+		"@cloudflare/workers-types": "^4.20241205.0",
+		"typescript": "^5.0.0"
+	}
+}

package/templates/cron/schema.sql

@@ -0,0 +1,24 @@
+CREATE TABLE IF NOT EXISTS jobs (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  payload TEXT NOT NULL DEFAULT '{}',
+  status TEXT NOT NULL DEFAULT 'pending',
+  attempts INTEGER NOT NULL DEFAULT 0,
+  max_attempts INTEGER NOT NULL DEFAULT 3,
+  last_error TEXT,
+  run_at INTEGER NOT NULL DEFAULT (unixepoch()),
+  created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
+CREATE TABLE IF NOT EXISTS webhook_events (
+  id TEXT PRIMARY KEY,
+  source TEXT NOT NULL DEFAULT 'unknown',
+  event_type TEXT,
+  payload TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'received',
+  created_at INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
+CREATE INDEX IF NOT EXISTS idx_jobs_status_run_at ON jobs(status, run_at);
+CREATE INDEX IF NOT EXISTS idx_webhook_events_created ON webhook_events(created_at);

package/templates/cron/src/index.ts

@@ -0,0 +1,117 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { createJob, getPendingJobs, processJob, retryFailedJobs } from "./jobs";
+import { logWebhookEvent, verifyWebhookSignature } from "./webhooks";
+
+type Bindings = {
+	DB: D1Database;
+	WEBHOOK_SECRET: string;
+};
+
+const app = new Hono<{ Bindings: Bindings }>();
+
+app.use("/*", cors());
+
+app.get("/", (c) => {
+	return c.json({
+		message: "Background worker running",
+		name: "jack-template",
+	});
+});
+
+app.get("/health", (c) => {
+	return c.json({ status: "ok", timestamp: Date.now() });
+});
+
+// Cron handler - called by scheduler on POST /__scheduled
+app.post("/__scheduled", async (c) => {
+	const db = c.env.DB;
+
+	// Retry failed jobs that haven't exceeded max attempts
+	const retried = await retryFailedJobs(db);
+
+	// Get pending jobs that are ready to run
+	const jobs = await getPendingJobs(db, 10);
+	let processed = 0;
+
+	for (const job of jobs) {
+		await processJob(db, job);
+		processed++;
+	}
+
+	return c.json({ processed, retried });
+});
+
+// Webhook ingestion endpoint
+app.post("/webhook", async (c) => {
+	const db = c.env.DB;
+	const body = await c.req.text();
+	const signature = c.req.header("X-Signature") || "";
+
+	// Verify webhook signature
+	const valid = await verifyWebhookSignature(
+		body,
+		signature,
+		c.env.WEBHOOK_SECRET,
+	);
+	if (!valid) {
+		return c.json({ error: "Invalid signature" }, 401);
+	}
+
+	// Parse and log the event
+	let parsed: Record<string, unknown>;
+	try {
+		parsed = JSON.parse(body);
+	} catch {
+		return c.json({ error: "Invalid JSON body" }, 400);
+	}
+
+	const eventType = (parsed.event as string) || "unknown";
+	const source = (parsed.source as string) || "unknown";
+
+	const eventId = await logWebhookEvent(db, {
+		source,
+		eventType,
+		payload: body,
+	});
+
+	// Create a job from the webhook event for async processing
+	await createJob(db, {
+		type: `webhook.${eventType}`,
+		payload: { webhookEventId: eventId, data: parsed.data || {} },
+	});
+
+	return c.json({ received: true, id: eventId });
+});
+
+// List recent jobs
+app.get("/jobs", async (c) => {
+	const db = c.env.DB;
+
+	const { results } = await db
+		.prepare(
+			"SELECT * FROM jobs ORDER BY created_at DESC LIMIT 50",
+		)
+		.all();
+
+	return c.json({ jobs: results });
+});
+
+// Get a single job by ID
+app.get("/jobs/:id", async (c) => {
+	const db = c.env.DB;
+	const id = c.req.param("id");
+
+	const job = await db
+		.prepare("SELECT * FROM jobs WHERE id = ?")
+		.bind(id)
+		.first();
+
+	if (!job) {
+		return c.json({ error: "Job not found" }, 404);
+	}
+
+	return c.json({ job });
+});
+
+export default app;

package/templates/cron/src/jobs.ts

@@ -0,0 +1,139 @@
+export interface Job {
+	id: string;
+	type: string;
+	payload: string;
+	status: string;
+	attempts: number;
+	max_attempts: number;
+	last_error: string | null;
+	run_at: number;
+	created_at: number;
+	updated_at: number;
+}
+
+export interface CreateJobInput {
+	type: string;
+	payload?: Record<string, unknown>;
+	runAt?: number;
+}
+
+// Create a new job in the queue
+export async function createJob(
+	db: D1Database,
+	input: CreateJobInput,
+): Promise<string> {
+	const id = crypto.randomUUID();
+	const now = Math.floor(Date.now() / 1000);
+	const runAt = input.runAt || now;
+	const payload = JSON.stringify(input.payload || {});
+
+	await db
+		.prepare(
+			"INSERT INTO jobs (id, type, payload, status, attempts, max_attempts, run_at, created_at, updated_at) VALUES (?, ?, ?, 'pending', 0, 3, ?, ?, ?)",
+		)
+		.bind(id, input.type, payload, runAt, now, now)
+		.run();
+
+	return id;
+}
+
+// Get pending jobs that are ready to run
+export async function getPendingJobs(
+	db: D1Database,
+	limit = 10,
+): Promise<Job[]> {
+	const now = Math.floor(Date.now() / 1000);
+
+	const { results } = await db
+		.prepare(
+			"SELECT * FROM jobs WHERE status = 'pending' AND run_at <= ? ORDER BY run_at ASC LIMIT ?",
+		)
+		.bind(now, limit)
+		.all<Job>();
+
+	return results;
+}
+
+// Process a single job
+// Add your own processing logic in the switch statement below
+export async function processJob(db: D1Database, job: Job): Promise<void> {
+	const now = Math.floor(Date.now() / 1000);
+
+	try {
+		// Mark as running
+		await db
+			.prepare(
+				"UPDATE jobs SET status = 'running', attempts = attempts + 1, updated_at = ? WHERE id = ?",
+			)
+			.bind(now, job.id)
+			.run();
+
+		// Process based on job type
+		const payload = JSON.parse(job.payload);
+
+		switch (job.type) {
+			case "example-task":
+				// Replace with your own logic
+				console.log(`Processing example task: ${JSON.stringify(payload)}`);
+				break;
+
+			default:
+				// Webhook-created jobs and other types
+				if (job.type.startsWith("webhook.")) {
+					console.log(`Processing webhook job: ${job.type}`, payload);
+				} else {
+					console.log(`Unknown job type: ${job.type}`);
+				}
+				break;
+		}
+
+		// Mark as completed
+		await db
+			.prepare(
+				"UPDATE jobs SET status = 'completed', updated_at = ? WHERE id = ?",
+			)
+			.bind(Math.floor(Date.now() / 1000), job.id)
+			.run();
+	} catch (err) {
+		const errorMessage = err instanceof Error ? err.message : String(err);
+
+		// Mark as failed
+		await db
+			.prepare(
+				"UPDATE jobs SET status = 'failed', last_error = ?, updated_at = ? WHERE id = ?",
+			)
+			.bind(errorMessage, Math.floor(Date.now() / 1000), job.id)
+			.run();
+	}
+}
+
+// Retry failed jobs that haven't exceeded max attempts
+// Uses exponential backoff: 2^attempts * 60 seconds
+export async function retryFailedJobs(db: D1Database): Promise<number> {
+	const now = Math.floor(Date.now() / 1000);
+
+	const { results } = await db
+		.prepare(
+			"SELECT id, attempts FROM jobs WHERE status = 'failed' AND attempts < max_attempts",
+		)
+		.all<{ id: string; attempts: number }>();
+
+	let retried = 0;
+
+	for (const job of results) {
+		// Exponential backoff: 2^attempts * 60 seconds
+		const backoffSeconds = Math.pow(2, job.attempts) * 60;
+		const nextRunAt = now + backoffSeconds;
+
+		await db
+			.prepare(
+				"UPDATE jobs SET status = 'pending', run_at = ?, updated_at = ? WHERE id = ?",
+			)
+			.bind(nextRunAt, now, job.id)
+			.run();
+
+		retried++;
+	}
+
+	return retried;
+}