@getjack/jack 0.1.34 → 0.1.35

package/templates/cron/src/index.ts

@@ -1,11 +1,11 @@
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { createJob, getPendingJobs, processJob, retryFailedJobs } from "./jobs";
-import { logWebhookEvent, verifyWebhookSignature } from "./webhooks";
+import { runChecks } from "./monitor";
+import { adminHTML } from "./admin";
 
 type Bindings = {
 	DB: D1Database;
-	WEBHOOK_SECRET: string;
+	MONITOR_URLS?: string;
 };
 
 const app = new Hono<{ Bindings: Bindings }>();
@@ -13,105 +13,175 @@ const app = new Hono<{ Bindings: Bindings }>();
 app.use("/*", cors());
 
 app.get("/", (c) => {
-	return c.json({
-		message: "Background worker running",
-		name: "jack-template",
-	});
+	return c.html(adminHTML());
 });
 
 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) => {
+// Rich per-group uptime stats (URLs hidden)
+app.get("/api/status", async (c) => {
 	const db = c.env.DB;
+	const now = Math.floor(Date.now() / 1000);
+	const DAY = 86400;
 
-	// 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 });
-});
+	const { results: groups } = await db
+		.prepare(
+			`SELECT
+				group_name,
+				COUNT(DISTINCT url) as endpoint_count,
+				MAX(created_at) as last_check_at,
+				SUM(CASE WHEN created_at > ?1 THEN 1 ELSE 0 END) as checks_24h,
+				SUM(CASE WHEN created_at > ?1 AND ok = 1 THEN 1 ELSE 0 END) as up_24h,
+				SUM(CASE WHEN created_at > ?2 THEN 1 ELSE 0 END) as checks_7d,
+				SUM(CASE WHEN created_at > ?2 AND ok = 1 THEN 1 ELSE 0 END) as up_7d,
+				COUNT(*) as checks_30d,
+				SUM(ok) as up_30d,
+				ROUND(AVG(CASE WHEN created_at > ?1 THEN latency_ms END)) as avg_latency,
+				MIN(CASE WHEN created_at > ?1 THEN latency_ms END) as min_latency,
+				MAX(CASE WHEN created_at > ?1 THEN latency_ms END) as max_latency
+			FROM checks
+			GROUP BY group_name
+			ORDER BY group_name`,
+		)
+		.bind(now - DAY, now - 7 * DAY)
+		.all();
 
-// 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,
+	const monitors = await Promise.all(
+		(groups as Array<Record<string, unknown>>).map(async (g) => {
+			const groupName = g.group_name as string;
+
+			// Recent checks for status bar + sparkline (newest first → reverse for display)
+			const { results: recentRaw } = await db
+				.prepare(
+					"SELECT ok, latency_ms FROM checks WHERE group_name = ? ORDER BY created_at DESC LIMIT 48",
+				)
+				.bind(groupName)
+				.all();
+			const recent = (
+				recentRaw as Array<{ ok: number; latency_ms: number }>
+			).reverse();
+
+			// Uptime streak: time since last failure (or since first check if none)
+			const lastFail = (await db
+				.prepare(
+					"SELECT created_at FROM checks WHERE group_name = ? AND ok = 0 ORDER BY created_at DESC LIMIT 1",
+				)
+				.bind(groupName)
+				.first()) as { created_at: number } | null;
+
+			const firstCheck = (await db
+				.prepare(
+					"SELECT created_at FROM checks WHERE group_name = ? ORDER BY created_at ASC LIMIT 1",
+				)
+				.bind(groupName)
+				.first()) as { created_at: number } | null;
+
+			const streakStart = lastFail
+				? lastFail.created_at
+				: firstCheck
+					? firstCheck.created_at
+					: now;
+			const streakSeconds = Math.max(0, now - streakStart);
+
+			// Current status from latest check per URL
+			const { results: latestPerUrl } = await db
+				.prepare(
+					`SELECT c.ok FROM checks c
+					INNER JOIN (
+						SELECT url, MAX(created_at) as max_ts
+						FROM checks WHERE group_name = ? GROUP BY url
+					) latest ON c.url = latest.url AND c.created_at = latest.max_ts
+					WHERE c.group_name = ?`,
+				)
+				.bind(groupName, groupName)
+				.all();
+
+			const allUp =
+				latestPerUrl.length > 0 &&
+				latestPerUrl.every((r: Record<string, unknown>) => r.ok);
+
+			function pct(up: number, total: number): number | null {
+				return total > 0 ? Math.round((1000 * up) / total) / 10 : null;
+			}
+
+			return {
+				group_name: groupName,
+				endpoint_count: g.endpoint_count,
+				all_up: allUp,
+				streak_seconds: streakSeconds,
+				last_check_at: g.last_check_at,
+				periods: {
+					"24h": {
+						uptime_pct: pct(g.up_24h as number, g.checks_24h as number),
+						failed_checks: (g.checks_24h as number) - (g.up_24h as number),
+						total_checks: g.checks_24h,
+					},
+					"7d": {
+						uptime_pct: pct(g.up_7d as number, g.checks_7d as number),
+						failed_checks: (g.checks_7d as number) - (g.up_7d as number),
+						total_checks: g.checks_7d,
+					},
+					"30d": {
+						uptime_pct: pct(g.up_30d as number, g.checks_30d as number),
+						failed_checks: (g.checks_30d as number) - (g.up_30d as number),
+						total_checks: g.checks_30d,
+					},
+				},
+				latency: {
+					avg: g.avg_latency || 0,
+					min: g.min_latency || 0,
+					max: g.max_latency || 0,
+				},
+				recent_checks: recent,
+			};
+		}),
 	);
-	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 });
+	return c.json({ monitors });
 });
 
-// List recent jobs
-app.get("/jobs", async (c) => {
+// Recent checks (URLs hidden)
+app.get("/api/checks", async (c) => {
 	const db = c.env.DB;
-
 	const { results } = await db
 		.prepare(
-			"SELECT * FROM jobs ORDER BY created_at DESC LIMIT 50",
+			"SELECT id, group_name, status_code, latency_ms, ok, source, error, created_at FROM checks ORDER BY created_at DESC LIMIT 100",
 		)
 		.all();
-
-	return c.json({ jobs: results });
+	return c.json({ checks: 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);
-	}
+// Manual trigger
+app.post("/api/trigger", async (c) => {
+	const results = await runChecks(
+		c.env.DB,
+		c.env as unknown as Record<string, unknown>,
+		"manual",
+	);
+	const allOk = results.every((r) => r.ok);
+	return c.json({
+		checked: results.length,
+		all_ok: allOk,
+		results: results.map((r) => ({
+			group: r.group_name,
+			ok: r.ok,
+			latency_ms: r.latency_ms,
+		})),
+	});
+});
 
-	return c.json({ job });
+// Cron handler
+app.post("/__scheduled", async (c) => {
+	const results = await runChecks(
+		c.env.DB,
+		c.env as unknown as Record<string, unknown>,
+		"cron",
+	);
+	const allOk = results.every((r) => r.ok);
+	console.log(`Uptime check: ${results.length} URLs, all_ok=${allOk}`);
+	return c.json({ checked: results.length, all_ok: allOk });
 });
 
 export default app;

package/templates/cron/src/monitor.ts

@@ -0,0 +1,124 @@
+export interface MonitorGroup {
+	name: string;
+	urls: string[];
+}
+
+export interface CheckResult {
+	url: string;
+	group_name: string;
+	status_code: number | null;
+	latency_ms: number;
+	ok: boolean;
+	error: string | null;
+}
+
+async function checkUrl(url: string): Promise<Omit<CheckResult, "group_name">> {
+	const start = Date.now();
+	try {
+		const res = await fetch(url, { signal: AbortSignal.timeout(10000) });
+		return {
+			url,
+			status_code: res.status,
+			latency_ms: Date.now() - start,
+			ok: res.ok,
+			error: null,
+		};
+	} catch (err) {
+		return {
+			url,
+			status_code: null,
+			latency_ms: Date.now() - start,
+			ok: false,
+			error: err instanceof Error ? err.message : String(err),
+		};
+	}
+}
+
+/**
+ * Parse MONITOR_URLS into named groups.
+ *
+ * Format: "GroupName=url1,url2;Other=url3,url4"
+ * Plain URLs without a group name go into "Default".
+ * If nothing is configured, monitors https://1.1.1.1 as "Default".
+ */
+export function parseMonitorConfig(env: Record<string, unknown>): MonitorGroup[] {
+	const raw = env.MONITOR_URLS as string | undefined;
+	if (!raw?.trim()) {
+		return [{ name: "Default", urls: ["https://1.1.1.1"] }];
+	}
+
+	const groups: MonitorGroup[] = [];
+
+	for (const segment of raw.split(";")) {
+		const trimmed = segment.trim();
+		if (!trimmed) continue;
+
+		const eqIndex = trimmed.indexOf("=");
+		if (eqIndex > 0) {
+			const name = trimmed.slice(0, eqIndex).trim();
+			const urls = trimmed
+				.slice(eqIndex + 1)
+				.split(",")
+				.map((u) => u.trim())
+				.filter(Boolean);
+			if (urls.length) groups.push({ name, urls });
+		} else {
+			const urls = trimmed
+				.split(",")
+				.map((u) => u.trim())
+				.filter(Boolean);
+			const existing = groups.find((g) => g.name === "Default");
+			if (existing) {
+				existing.urls.push(...urls);
+			} else if (urls.length) {
+				groups.push({ name: "Default", urls });
+			}
+		}
+	}
+
+	if (groups.length === 0) {
+		groups.push({ name: "Default", urls: ["https://1.1.1.1"] });
+	}
+
+	return groups;
+}
+
+export async function runChecks(
+	db: D1Database,
+	env: Record<string, unknown>,
+	source: "cron" | "manual",
+): Promise<CheckResult[]> {
+	const groups = parseMonitorConfig(env);
+	const promises: Promise<CheckResult>[] = [];
+
+	for (const group of groups) {
+		for (const url of group.urls) {
+			promises.push(
+				checkUrl(url).then((r) => ({ ...r, group_name: group.name })),
+			);
+		}
+	}
+
+	const results = await Promise.all(promises);
+
+	for (const r of results) {
+		await db
+			.prepare(
+				"INSERT INTO checks (id, url, group_name, status_code, latency_ms, ok, source, error, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+			)
+			.bind(
+				crypto.randomUUID(),
+				r.url,
+				r.group_name,
+				r.status_code,
+				r.latency_ms,
+				r.ok ? 1 : 0,
+				source,
+				r.error,
+				Math.floor(Date.now() / 1000),
+			)
+			.run();
+	}
+
+	return results;
+}

package/templates/semantic-search/src/index.ts

@@ -1,23 +1,13 @@
 import { type JackAI, createJackAI } from "./jack-ai";
-import { type JackVectorize, createJackVectorize } from "./jack-vectorize";
 
 interface Env {
-	// Direct bindings (for local dev with wrangler)
 	AI?: Ai;
-	VECTORS?: VectorizeIndex;
-	// Jack proxy bindings (injected in jack cloud)
+	VECTORS: VectorizeIndex;
 	__AI_PROXY?: Fetcher;
-	__VECTORIZE_PROXY?: Fetcher;
-	__JACK_PROJECT_ID?: string;
-	__JACK_ORG_ID?: string;
-	// Other bindings
 	DB: D1Database;
 	ASSETS: Fetcher;
 }
 
-// Index name must match wrangler.jsonc vectorize config
-const VECTORIZE_INDEX_NAME = "jack-template-vectors";
-
 // Minimal AI interface for embedding generation
 type AIClient = {
 	run: (model: string, inputs: { text: string }) => Promise<{ data: number[][] } | unknown>;
@@ -25,10 +15,8 @@ type AIClient = {
 
 function getAI(env: Env): AIClient {
 	// 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">>,
-		) as AIClient;
+	if (env.__AI_PROXY) {
+		return createJackAI(env as Pick<Env, "__AI_PROXY"> & { __AI_PROXY: Fetcher }) as AIClient;
 	}
 	// Fallback to direct binding for local dev
 	if (env.AI) {
@@ -37,32 +25,6 @@ function getAI(env: Env): AIClient {
 	throw new Error("No AI binding available");
 }
 
-// Minimal Vectorize interface
-type VectorizeClient = {
-	insert: (
-		vectors: { id: string; values: number[]; metadata?: Record<string, unknown> }[],
-	) => Promise<unknown>;
-	query: (
-		vector: number[],
-		options?: { topK?: number; returnMetadata?: "none" | "indexed" | "all" },
-	) => Promise<{ matches: { id: string; score: number; metadata?: Record<string, unknown> }[] }>;
-};
-
-function getVectorize(env: Env): VectorizeClient {
-	// Prefer jack cloud proxy if available (for metering)
-	if (env.__VECTORIZE_PROXY && env.__JACK_PROJECT_ID && env.__JACK_ORG_ID) {
-		return createJackVectorize(
-			env as Required<Pick<Env, "__VECTORIZE_PROXY" | "__JACK_PROJECT_ID" | "__JACK_ORG_ID">>,
-			VECTORIZE_INDEX_NAME,
-		) as VectorizeClient;
-	}
-	// Fallback to direct binding for local dev
-	if (env.VECTORS) {
-		return env.VECTORS as unknown as VectorizeClient;
-	}
-	throw new Error("No Vectorize binding available");
-}
-
 // Rate limiting: 10 requests per minute per IP
 const RATE_LIMIT = 10;
 const RATE_WINDOW_MS = 60_000;
@@ -142,7 +104,7 @@ export default {
 				}
 
 				// Store in Vectorize
-				const vectors = getVectorize(env);
+				const vectors = env.VECTORS;
 				await vectors.insert([
 					{
 						id,
@@ -188,7 +150,7 @@ export default {
 				}
 
 				// Search Vectorize
-				const vectors = getVectorize(env);
+				const vectors = env.VECTORS;
 				const results = await vectors.query(embeddingVector, {
 					topK: limit,
 					returnMetadata: "all",

package/templates/semantic-search/src/jack-ai.ts

@@ -10,8 +10,6 @@
  *
  * 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 {
@@ -29,8 +27,6 @@
 
 interface JackAIEnv {
 	__AI_PROXY: Fetcher;
-	__JACK_PROJECT_ID: string;
-	__JACK_ORG_ID: string;
 }
 
 /**
@@ -56,8 +52,6 @@ export function createJackAI(env: JackAIEnv): {
 				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 }),
 			});

package/templates/telegram-bot/.jack.json

@@ -0,0 +1,56 @@
+{
+	"name": "telegram-bot",
+	"description": "Telegram bot with AI-powered responses",
+	"secrets": ["BOT_TOKEN", "WEBHOOK_SECRET"],
+	"requires": ["AI"],
+	"intent": {
+		"keywords": ["telegram", "bot", "chat", "messaging", "ai"],
+		"examples": ["telegram bot", "AI telegram assistant", "messaging bot", "chat bot"]
+	},
+	"agentContext": {
+		"summary": "A Telegram bot with grammY, AI-powered responses, and webhook delivery.",
+		"full_text": "## Project Structure\n\n- `src/index.ts` - grammY bot with webhook handler, commands, and AI integration\n- `src/jack-ai.ts` - Jack AI proxy wrapper (do not modify)\n\n## Commands\n\n- `/start` - Welcome message with available commands\n- `/help` - List all commands\n- `/ask <question>` - Ask the AI anything\n- `/status` - Bot info: region, timestamp, uptime\n\n## AI Responses\n\nThe bot responds with AI in two ways:\n1. `/ask <question>` - Explicit AI query\n2. Reply to any bot message - Treated as a follow-up question\n\nAI uses the jack metered proxy. Change the model in `src/index.ts`.\n\n## Webhook\n\nTelegram delivers updates via webhook POST to your deploy URL. The webhook is auto-registered during deployment. The `WEBHOOK_SECRET` header is verified on every request.\n\n## Environment Variables\n\n- `BOT_TOKEN` - Telegram bot token from @BotFather (secret)\n- `WEBHOOK_SECRET` - Auto-generated webhook verification token (secret)\n\n## Changing the AI Model\n\nEdit the model string in `src/index.ts`:\n```typescript\nconst MODEL = \"@cf/meta/llama-3.1-8b-instruct\";\n```\n\nAvailable models: https://developers.cloudflare.com/workers-ai/models/\n\n## Resources\n\n- [grammY Documentation](https://grammy.dev)\n- [Telegram Bot API](https://core.telegram.org/bots/api)\n- [AI Models](https://developers.cloudflare.com/workers-ai/models)"
+	},
+	"hooks": {
+		"preCreate": [
+			{
+				"action": "require",
+				"source": "secret",
+				"key": "BOT_TOKEN",
+				"message": "Telegram bot token from @BotFather",
+				"setupUrl": "https://t.me/BotFather",
+				"onMissing": "prompt",
+				"promptMessage": "Enter your Telegram Bot Token:",
+				"perProject": true,
+				"validateCommand": "curl -sf --max-time 5 https://api.telegram.org/bot{{value}}/getMe > /dev/null",
+				"validateError": "Invalid bot token. Make sure you copied it correctly from @BotFather."
+			},
+			{
+				"action": "require",
+				"source": "secret",
+				"key": "WEBHOOK_SECRET",
+				"message": "Generating webhook verification secret...",
+				"onMissing": "generate",
+				"generateCommand": "openssl rand -hex 32",
+				"perProject": true
+			}
+		],
+		"postDeploy": [
+			{
+				"action": "shell",
+				"command": "curl -sf --max-time 10 {{url}}/register-webhook > /dev/null || true",
+				"message": "Registering Telegram webhook..."
+			},
+			{
+				"action": "shell",
+				"command": "BOT_LINK=$(curl -sf --max-time 10 {{url}}/bot-link) && [ -n \"$BOT_LINK\" ] && echo \"\" && echo \"  Your bot is live! Open it here:\" && echo \"  $BOT_LINK\" && echo \"\" && echo \"  Send /start — it will respond.\" || true",
+				"message": ""
+			},
+			{
+				"action": "clipboard",
+				"text": "{{url}}",
+				"message": "Deploy URL copied to clipboard"
+			}
+		]
+	}
+}

package/templates/telegram-bot/bun.lock

@@ -0,0 +1,41 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "jack-template",
+      "dependencies": {
+        "grammy": "^1.35.0",
+      },
+      "devDependencies": {
+        "@cloudflare/workers-types": "^4.20241205.0",
+        "typescript": "^5.0.0",
+      },
+    },
+  },
+  "packages": {
+    "@cloudflare/workers-types": ["@cloudflare/workers-types@4.20260213.0", "", {}, "sha512-dr905ft/1R0mnfdT9aun4vanLgIBN27ZyPxTCENKmhctSz6zNmBOvHbzDWAhGE0RBAKFf3X7ifMRcd0MkmBvgA=="],
+
+    "@grammyjs/types": ["@grammyjs/types@3.24.0", "", {}, "sha512-qQIEs4lN5WqUdr4aT8MeU6UFpMbGYAvcvYSW1A4OO1PABGJQHz/KLON6qvpf+5RxaNDQBxiY2k2otIhg/AG7RQ=="],
+
+    "abort-controller": ["abort-controller@3.0.0", "", { "dependencies": { "event-target-shim": "^5.0.0" } }, "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "event-target-shim": ["event-target-shim@5.0.1", "", {}, "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ=="],
+
+    "grammy": ["grammy@1.40.0", "", { "dependencies": { "@grammyjs/types": "3.24.0", "abort-controller": "^3.0.0", "debug": "^4.4.3", "node-fetch": "^2.7.0" } }, "sha512-ssuE7fc1AwqlUxHr931OCVW3fU+oFDjHZGgvIedPKXfTdjXvzP19xifvVGCnPtYVUig1Kz+gwxe4A9M5WdkT4Q=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
+
+    "tr46": ["tr46@0.0.3", "", {}, "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],
+
+    "whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="],
+  }
+}

package/templates/telegram-bot/package.json

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