@getjack/jack 0.1.34 → 0.1.36

package/templates/telegram-bot/src/index.ts

@@ -0,0 +1,236 @@
+import { Bot, webhookCallback } from "grammy";
+import { createJackAI } from "./jack-ai";
+
+const MODEL = "@cf/meta/llama-3.1-8b-instruct";
+const MAX_MESSAGE_LENGTH = 4000;
+
+interface Env {
+	BOT_TOKEN: string;
+	WEBHOOK_SECRET: string;
+	AI?: Ai;
+	__AI_PROXY?: Fetcher;
+	__JACK_PROJECT_ID?: string;
+	__JACK_ORG_ID?: string;
+}
+
+type AIRunner = {
+	run: (model: string, inputs: unknown) => Promise<unknown>;
+};
+
+function getAI(env: Env): AIRunner {
+	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">>,
+		);
+	}
+	if (env.AI) return env.AI as unknown as AIRunner;
+	throw new Error("No AI binding available");
+}
+
+async function askAI(env: Env, question: string): Promise<string> {
+	const ai = getAI(env);
+	const result = (await ai.run(MODEL, {
+		messages: [
+			{
+				role: "system",
+				content:
+					"You are a helpful Telegram bot powered by getjack.org. Keep answers concise and clear. Use plain text, not markdown.",
+			},
+			{ role: "user", content: question },
+		],
+	})) as { response?: string };
+
+	return result.response ?? "Sorry, I couldn't generate a response.";
+}
+
+async function sendChunked(
+	ctx: { reply: (text: string) => Promise<unknown> },
+	text: string,
+): Promise<void> {
+	if (text.length <= MAX_MESSAGE_LENGTH) {
+		await ctx.reply(text);
+		return;
+	}
+
+	const chunks: string[] = [];
+	let remaining = text;
+	while (remaining.length > 0) {
+		if (remaining.length <= MAX_MESSAGE_LENGTH) {
+			chunks.push(remaining);
+			break;
+		}
+		let splitAt = remaining.lastIndexOf("\n", MAX_MESSAGE_LENGTH);
+		if (splitAt < MAX_MESSAGE_LENGTH / 2) {
+			splitAt = remaining.lastIndexOf(" ", MAX_MESSAGE_LENGTH);
+		}
+		if (splitAt < MAX_MESSAGE_LENGTH / 2) {
+			splitAt = MAX_MESSAGE_LENGTH;
+		}
+		chunks.push(remaining.slice(0, splitAt));
+		remaining = remaining.slice(splitAt).trimStart();
+	}
+
+	for (const chunk of chunks) {
+		await ctx.reply(chunk);
+	}
+}
+
+async function getBotUsername(env: Env): Promise<string | null> {
+	try {
+		const res = await fetch(`https://api.telegram.org/bot${env.BOT_TOKEN}/getMe`);
+		const data = (await res.json()) as {
+			ok: boolean;
+			result?: { username?: string };
+		};
+		return data.ok ? (data.result?.username ?? null) : null;
+	} catch {
+		return null;
+	}
+}
+
+async function registerWebhook(env: Env, url: string): Promise<Response> {
+	const [webhookRes, username] = await Promise.all([
+		fetch(`https://api.telegram.org/bot${env.BOT_TOKEN}/setWebhook`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				url,
+				secret_token: env.WEBHOOK_SECRET,
+				allowed_updates: ["message", "callback_query"],
+			}),
+		}),
+		getBotUsername(env),
+	]);
+	const data = (await webhookRes.json()) as {
+		ok: boolean;
+		description?: string;
+	};
+	const botUrl = username ? `https://t.me/${username}` : null;
+	if (data.ok) {
+		return new Response(JSON.stringify({ registered: true, url, botUrl, username }), {
+			headers: { "Content-Type": "application/json" },
+		});
+	}
+	return new Response(JSON.stringify({ registered: false, error: data.description }), {
+		status: 500,
+		headers: { "Content-Type": "application/json" },
+	});
+}
+
+export default {
+	async fetch(request: Request, env: Env): Promise<Response> {
+		const url = new URL(request.url);
+
+		if (url.pathname === "/register-webhook") {
+			return registerWebhook(env, url.origin);
+		}
+
+		if (url.pathname === "/bot-link") {
+			const username = await getBotUsername(env);
+			if (username) {
+				return new Response(`https://t.me/${username}`, {
+					headers: { "Content-Type": "text/plain" },
+				});
+			}
+			return new Response("", { status: 404 });
+		}
+
+		if (request.method !== "POST") {
+			const username = await getBotUsername(env);
+			const botLink = username
+				? `<p><a href="https://t.me/${username}">Open @${username} in Telegram</a> and send <code>/start</code></p>`
+				: `<p>Open your bot in Telegram and send <code>/start</code></p>`;
+			return new Response(
+				`<!DOCTYPE html><html><head><meta charset="utf-8"><title>jack-template</title>
+<style>body{font-family:system-ui;max-width:480px;margin:60px auto;padding:0 20px}
+a{color:#0088cc}code{background:#f0f0f0;padding:2px 6px;border-radius:3px}</style></head>
+<body><h2>jack-template</h2>${botLink}
+<p>Commands: <code>/start</code> <code>/help</code> <code>/ask</code> <code>/status</code></p></body></html>`,
+				{ headers: { "Content-Type": "text/html;charset=utf-8" } },
+			);
+		}
+
+		const secret = request.headers.get("X-Telegram-Bot-Api-Secret-Token");
+		if (secret !== env.WEBHOOK_SECRET) {
+			return new Response("Unauthorized", { status: 403 });
+		}
+
+		const bot = new Bot(env.BOT_TOKEN);
+
+		bot.command("start", async (ctx) => {
+			await ctx.reply(
+				[
+					"Hey! I'm an AI-powered bot.",
+					"",
+					"Commands:",
+					"/ask <question> - Ask me anything",
+					"/status - Bot info",
+					"/help - Show this message",
+					"",
+					"You can also reply to any of my messages to continue the conversation.",
+				].join("\n"),
+			);
+		});
+
+		bot.command("help", async (ctx) => {
+			await ctx.reply(
+				[
+					"Available commands:",
+					"",
+					"/ask <question> - Ask the AI a question",
+					"/status - Show bot status and info",
+					"/help - Show this help message",
+					"",
+					"Tip: Reply to any of my messages to ask a follow-up question.",
+				].join("\n"),
+			);
+		});
+
+		bot.command("status", async (ctx) => {
+			const cf = (request as Request & { cf?: Record<string, string> }).cf;
+			const region = cf?.colo ?? "unknown";
+			const country = cf?.country ?? "unknown";
+
+			await ctx.reply(
+				[
+					"Bot Status",
+					"",
+					`Region: ${region} (${country})`,
+					`Time: ${new Date().toISOString()}`,
+					`Runtime: Edge`,
+					`AI Model: ${MODEL}`,
+				].join("\n"),
+			);
+		});
+
+		bot.command("ask", async (ctx) => {
+			const question = ctx.match;
+			if (!question) {
+				await ctx.reply(
+					"Usage: /ask <your question>\n\nExample: /ask What is the meaning of life?",
+				);
+				return;
+			}
+
+			const answer = await askAI(env, question);
+			await sendChunked(ctx, answer);
+		});
+
+		bot.on("message:text", async (ctx) => {
+			// In private chats, respond to every message
+			if (ctx.chat.type === "private") {
+				const answer = await askAI(env, ctx.message.text);
+				await sendChunked(ctx, answer);
+				return;
+			}
+			// In groups, only respond when replying to bot's message
+			const replyTo = ctx.message.reply_to_message;
+			if (replyTo?.from?.id === bot.botInfo.id) {
+				const answer = await askAI(env, ctx.message.text);
+				await sendChunked(ctx, answer);
+			}
+		});
+
+		return webhookCallback(bot, "cloudflare-mod")(request);
+	},
+};

package/templates/telegram-bot/src/jack-ai.ts

@@ -0,0 +1,100 @@
+/**
+ * Jack AI Client - Drop-in replacement for Cloudflare AI binding.
+ *
+ * This wrapper provides the same interface as env.AI but routes calls
+ * through jack's binding proxy for metering and quota enforcement.
+ *
+ * Usage in templates:
+ * ```typescript
+ * import { createJackAI } from "./jack-ai";
+ *
+ * interface Env {
+ *   __AI_PROXY: Fetcher;        // Service binding to binding-proxy worker
+ *   __JACK_PROJECT_ID: string;  // Injected by control plane
+ *   __JACK_ORG_ID: string;      // Injected by control plane
+ * }
+ *
+ * export default {
+ *   async fetch(request: Request, env: Env) {
+ *     const AI = createJackAI(env);
+ *     const result = await AI.run("@cf/meta/llama-3.2-1b-instruct", { messages });
+ *     // Works exactly like env.AI.run()
+ *   }
+ * };
+ * ```
+ *
+ * The wrapper is transparent - it accepts the same parameters as env.AI.run()
+ * and returns the same response types, including streaming.
+ */
+
+interface JackAIEnv {
+	__AI_PROXY: Fetcher;
+	__JACK_PROJECT_ID: string;
+	__JACK_ORG_ID: string;
+}
+
+/**
+ * Creates a Jack AI client that mirrors the Cloudflare AI binding interface.
+ *
+ * @param env - Worker environment with jack proxy bindings
+ * @returns AI-compatible object with run() method
+ */
+export function createJackAI(env: JackAIEnv): {
+	run: <T = unknown>(
+		model: string,
+		inputs: unknown,
+		options?: unknown,
+	) => Promise<T | ReadableStream>;
+} {
+	return {
+		async run<T = unknown>(
+			model: string,
+			inputs: unknown,
+			options?: unknown,
+		): Promise<T | ReadableStream> {
+			const response = await env.__AI_PROXY.fetch("http://internal/ai/run", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"X-Jack-Project-ID": env.__JACK_PROJECT_ID,
+					"X-Jack-Org-ID": env.__JACK_ORG_ID,
+				},
+				body: JSON.stringify({ model, inputs, options }),
+			});
+
+			// Handle quota exceeded
+			if (response.status === 429) {
+				const error = await response.json();
+				const quotaError = new Error(
+					(error as { message?: string }).message || "AI quota exceeded",
+				);
+				(quotaError as Error & { code: string }).code = "AI_QUOTA_EXCEEDED";
+				(quotaError as Error & { resetIn?: number }).resetIn = (
+					error as { resetIn?: number }
+				).resetIn;
+				throw quotaError;
+			}
+
+			// Handle other errors
+			if (!response.ok) {
+				const error = await response.json();
+				throw new Error((error as { error?: string }).error || "AI request failed");
+			}
+
+			// Handle streaming response
+			const contentType = response.headers.get("Content-Type");
+			if (contentType?.includes("text/event-stream")) {
+				return response.body as ReadableStream;
+			}
+
+			// Handle JSON response
+			return response.json() as Promise<T>;
+		},
+	};
+}
+
+/**
+ * Type-safe wrapper that infers return types based on model.
+ * For advanced users who want full type safety.
+ */
+export type JackAI = ReturnType<typeof createJackAI>;

package/templates/telegram-bot/tsconfig.json

@@ -0,0 +1,11 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"strict": true,
+		"skipLibCheck": true,
+		"types": ["@cloudflare/workers-types"]
+	},
+	"include": ["src/**/*"]
+}

package/templates/telegram-bot/wrangler.jsonc

@@ -0,0 +1,8 @@
+{
+	"name": "jack-template",
+	"main": "src/index.ts",
+	"compatibility_date": "2024-12-01",
+	"ai": {
+		"binding": "AI"
+	}
+}

package/templates/cron/src/jobs.ts

@@ -1,139 +0,0 @@
-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;
-}

package/templates/cron/src/webhooks.ts

@@ -1,95 +0,0 @@
-// Convert an ArrayBuffer to hex string
-function bufferToHex(buffer: ArrayBuffer): string {
-	const bytes = new Uint8Array(buffer);
-	const hexChars: string[] = [];
-	for (const byte of bytes) {
-		hexChars.push(byte.toString(16).padStart(2, "0"));
-	}
-	return hexChars.join("");
-}
-
-// Verify HMAC-SHA256 webhook signature
-// Expected header format: sha256=<hex-encoded-signature>
-export async function verifyWebhookSignature(
-	payload: string,
-	signatureHeader: string,
-	secret: string,
-): Promise<boolean> {
-	if (!signatureHeader || !secret) {
-		return false;
-	}
-
-	// Parse the signature header
-	const parts = signatureHeader.split("=");
-	if (parts.length !== 2 || parts[0] !== "sha256") {
-		return false;
-	}
-
-	const receivedSignature = parts[1];
-	if (!receivedSignature) {
-		return false;
-	}
-
-	// Import the secret as a CryptoKey
-	const encoder = new TextEncoder();
-	const key = await crypto.subtle.importKey(
-		"raw",
-		encoder.encode(secret),
-		{ name: "HMAC", hash: "SHA-256" },
-		false,
-		["sign"],
-	);
-
-	// Sign the payload
-	const signatureBuffer = await crypto.subtle.sign(
-		"HMAC",
-		key,
-		encoder.encode(payload),
-	);
-
-	// Convert to hex and compare
-	const expectedSignature = bufferToHex(signatureBuffer);
-
-	// Constant-time comparison
-	if (receivedSignature.length !== expectedSignature.length) {
-		return false;
-	}
-
-	let mismatch = 0;
-	for (let i = 0; i < receivedSignature.length; i++) {
-		mismatch |=
-			receivedSignature.charCodeAt(i) ^ expectedSignature.charCodeAt(i);
-	}
-
-	return mismatch === 0;
-}
-
-export interface WebhookEventInput {
-	source?: string;
-	eventType?: string;
-	payload: string;
-}
-
-// Log a webhook event to D1
-export async function logWebhookEvent(
-	db: D1Database,
-	input: WebhookEventInput,
-): Promise<string> {
-	const id = crypto.randomUUID();
-	const now = Math.floor(Date.now() / 1000);
-
-	await db
-		.prepare(
-			"INSERT INTO webhook_events (id, source, event_type, payload, status, created_at) VALUES (?, ?, ?, ?, 'received', ?)",
-		)
-		.bind(
-			id,
-			input.source || "unknown",
-			input.eventType || null,
-			input.payload,
-			now,
-		)
-		.run();
-
-	return id;
-}