@prajwalshete/telegram-plugin 0.0.0-stage → 0.1.1

package/dist/routes/app.js

@@ -0,0 +1,9 @@
+import { adminRoutes } from "./admin.js";
+import { meRoutes } from "./me.js";
+import { webhookRoutes } from "./webhook.js";
+import { Hono } from "hono";
+// src/routes/app.ts
+function buildRoutes(deps, meta) {
+	return new Hono().route("/", webhookRoutes(deps)).route("/", adminRoutes(deps, meta)).route("/", meRoutes(deps));
+}
+export { buildRoutes };

package/dist/routes/broadcasts.js

@@ -0,0 +1,37 @@
+import { PageQuery } from "../contracts/common.js";
+import { BroadcastPreviewRequest, BroadcastQuery, BroadcastSave } from "../contracts/broadcasts.js";
+import { broadcastDto, broadcastReport, createBroadcast, deleteBroadcast, listBroadcasts, previewBroadcast, requireBroadcast, sendBroadcast, updateBroadcast } from "../services/broadcasts.js";
+import { decodeCursor, featureGate, idParam, pageOf, requirePermission, zJson, zQuery } from "./http.js";
+import { Hono } from "hono";
+// src/routes/broadcasts.ts
+const ListQuery = BroadcastQuery.extend(PageQuery.shape);
+const PERM = "telegram.broadcasts.send";
+function broadcastRoutes(deps) {
+	const app = new Hono();
+	app.use("/admin/broadcasts", featureGate(deps.features, "broadcasts"));
+	app.use("/admin/broadcasts/*", featureGate(deps.features, "broadcasts"));
+	return app.get("/admin/broadcasts", requirePermission(PERM), zQuery(ListQuery), async (c) => {
+		const q = c.req.valid("query");
+		const rows = await listBroadcasts(c.var.tg, q, {
+			cursor: decodeCursor(q.cursor),
+			limit: q.limit
+		});
+		return c.json(pageOf(rows, q.limit, broadcastDto));
+	}).post("/admin/broadcasts", requirePermission(PERM), zJson(BroadcastSave), async (c) => {
+		return c.json(await createBroadcast(c.var.tg, c.var.tgActor, c.req.valid("json")), 201);
+	}).get("/admin/broadcasts/:id", requirePermission(PERM), async (c) => {
+		return c.json(broadcastDto(await requireBroadcast(c.var.tg, idParam(c))));
+	}).put("/admin/broadcasts/:id", requirePermission(PERM), zJson(BroadcastSave), async (c) => {
+		return c.json(await updateBroadcast(c.var.tg, c.var.tgActor, idParam(c), c.req.valid("json")));
+	}).delete("/admin/broadcasts/:id", requirePermission(PERM), async (c) => {
+		await deleteBroadcast(c.var.tg, c.var.tgActor, idParam(c));
+		return c.json({ ok: true });
+	}).post("/admin/broadcasts/:id/preview", requirePermission(PERM), zJson(BroadcastPreviewRequest), async (c) => {
+		return c.json(await previewBroadcast(c.var.tg, c.var.tgActor, idParam(c), c.req.valid("json")));
+	}).post("/admin/broadcasts/:id/send", requirePermission(PERM), async (c) => {
+		return c.json(await sendBroadcast(c.var.tg, c.var.tgActor, idParam(c)));
+	}).get("/admin/broadcasts/:id/report", requirePermission(PERM), async (c) => {
+		return c.json(await broadcastReport(c.var.tg, idParam(c)));
+	});
+}
+export { broadcastRoutes };

package/dist/routes/commands.js

@@ -0,0 +1,35 @@
+import { CommandConfigSave, CommandName } from "../contracts/commands.js";
+import { TelegramPluginError } from "../engine/errors.js";
+import { loadBot } from "../engine/bot-api.js";
+import { listCommandConfigs, saveCommandConfig } from "../services/commands.js";
+import { syncCommandMenu } from "../services/menu.js";
+import { featureGate, idParam, requirePermission, zJson } from "./http.js";
+import { Hono } from "hono";
+// src/routes/commands.ts
+async function requireBot(rt, id) {
+	const bot = await loadBot(rt, id);
+	if (!bot) throw new TelegramPluginError("not_found", "bot not found");
+	return bot;
+}
+function commandRoutes(deps) {
+	const app = new Hono();
+	app.use("/admin/bots/:id/commands", featureGate(deps.features, "commands"));
+	app.use("/admin/bots/:id/commands/*", featureGate(deps.features, "commands"));
+	return app.get("/admin/bots/:id/commands", requirePermission("telegram.commands.manage"), async (c) => {
+		const bot = await requireBot(c.var.tg, idParam(c));
+		return c.json({ items: await listCommandConfigs(c.var.tg, bot) });
+	}).post("/admin/bots/:id/commands/sync", requirePermission("telegram.commands.manage"), async (c) => {
+		const bot = await requireBot(c.var.tg, idParam(c));
+		return c.json(await syncCommandMenu(c.var.tg, bot, { force: true }));
+	}).put("/admin/bots/:id/commands/:command", requirePermission("telegram.commands.manage"), zJson(CommandConfigSave), async (c) => {
+		const rt = c.var.tg;
+		const bot = await requireBot(rt, idParam(c));
+		const name = CommandName.safeParse(c.req.param("command"));
+		if (!name.success) throw new TelegramPluginError("not_found", "command not found");
+		const dto = await saveCommandConfig(rt, c.var.tgActor, bot, name.data, c.req.valid("json"));
+		const fresh = await loadBot(rt, bot.id);
+		if (fresh) await syncCommandMenu(rt, fresh);
+		return c.json(dto);
+	});
+}
+export { commandRoutes };

package/dist/routes/content.js

@@ -0,0 +1,12 @@
+import { broadcastRoutes } from "./broadcasts.js";
+import { commandRoutes } from "./commands.js";
+import { eventRoutes } from "./events.js";
+import { scheduleRoutes } from "./schedules.js";
+import { sendRoutes } from "./send.js";
+import { templateRoutes } from "./templates.js";
+import { Hono } from "hono";
+// src/routes/content.ts
+function contentRoutes(deps) {
+	return new Hono().route("/", templateRoutes(deps)).route("/", commandRoutes(deps)).route("/", scheduleRoutes(deps)).route("/", eventRoutes(deps)).route("/", broadcastRoutes(deps)).route("/", sendRoutes(deps));
+}
+export { contentRoutes };

package/dist/routes/events.js

@@ -0,0 +1,36 @@
+import { PageQuery } from "../contracts/common.js";
+import { EventRuleQuery, EventRuleSave, EventRuleTestRequest } from "../contracts/events.js";
+import { createRule, deleteRule, eventRuleDto, listRules, registeredEvents, requireRule, testRule, updateRule } from "../services/event-rules.js";
+import { decodeCursor, featureGate, idParam, pageOf, requirePermission, zJson, zQuery } from "./http.js";
+import { Hono } from "hono";
+// src/routes/events.ts
+const ListQuery = EventRuleQuery.extend(PageQuery.shape);
+const PERM = "telegram.events.manage";
+function eventRoutes(deps) {
+	const app = new Hono();
+	app.use("/admin/events", featureGate(deps.features, "events"));
+	app.use("/admin/event-rules", featureGate(deps.features, "events"));
+	app.use("/admin/event-rules/*", featureGate(deps.features, "events"));
+	return app.get("/admin/events", requirePermission(PERM), async (c) => {
+		return c.json({ items: registeredEvents(c.var.tg) });
+	}).get("/admin/event-rules", requirePermission(PERM), zQuery(ListQuery), async (c) => {
+		const q = c.req.valid("query");
+		const rows = await listRules(c.var.tg, q, {
+			cursor: decodeCursor(q.cursor),
+			limit: q.limit
+		});
+		return c.json(pageOf(rows, q.limit, eventRuleDto));
+	}).post("/admin/event-rules", requirePermission(PERM), zJson(EventRuleSave), async (c) => {
+		return c.json(await createRule(c.var.tg, c.var.tgActor, c.req.valid("json")), 201);
+	}).get("/admin/event-rules/:id", requirePermission(PERM), async (c) => {
+		return c.json(eventRuleDto(await requireRule(c.var.tg, idParam(c))));
+	}).put("/admin/event-rules/:id", requirePermission(PERM), zJson(EventRuleSave), async (c) => {
+		return c.json(await updateRule(c.var.tg, c.var.tgActor, idParam(c), c.req.valid("json")));
+	}).delete("/admin/event-rules/:id", requirePermission(PERM), async (c) => {
+		await deleteRule(c.var.tg, c.var.tgActor, idParam(c));
+		return c.json({ ok: true });
+	}).post("/admin/event-rules/:id/test", requirePermission(PERM), zJson(EventRuleTestRequest), async (c) => {
+		return c.json(await testRule(c.var.tg, c.var.tgActor, idParam(c), c.req.valid("json").payload));
+	});
+}
+export { eventRoutes };

package/dist/routes/http.d.ts

@@ -0,0 +1,30 @@
+import { ErrorsPort } from "../ports/ports.js";
+import { FeatureFlags } from "../engine/options.js";
+import { Runtime } from "../engine/runtime.js";
+import { z } from "zod";
+import { Context } from "hono";
+export interface TgVariables {
+  tg: Runtime<unknown>;
+  tgActor: unknown;
+  /** Set by `requirePermission` once a permission check passed. */
+  tgPermChecked?: boolean;
+  /** `idempotencyMiddleware` ran before the permission check: the next `requirePermission` handles the key. */
+  tgIdem?: "armed" | "done";
+  /** `skipIdempotencyStore`: never store this route's response. */
+  tgIdemNoStore?: boolean;
+}
+export type TgEnv = {
+  Bindings: object;
+  Variables: TgVariables;
+};
+export interface RouteDeps {
+  runtime(env: unknown, exec?: {
+    waitUntil(p: Promise<unknown>): void;
+  }): Runtime<unknown>;
+  features: FeatureFlags;
+  errors: ErrorsPort | undefined;
+  /** Databases (keyed by the env mapper's `db` object) that passed the schema check in this isolate. */
+  schemaOk: WeakSet<object>;
+  /** The cache key for `schemaOk`: the `db` binding / port the env mapper returns for this env. */
+  schemaKey(env: unknown): object | undefined;
+}

package/dist/routes/http.js

@@ -0,0 +1,223 @@
+import { Id } from "../contracts/common.js";
+import { PROBLEM_CONTENT_TYPE, PROBLEM_STATUS } from "../contracts/problems.js";
+import { TelegramPluginError, featureDisabled, isTelegramPluginError } from "../engine/errors.js";
+import { ensureState } from "../engine/state.js";
+import { IDEMPOTENCY_RENEW_MS, reserveIdempotency } from "../services/idempotency.js";
+import { validator } from "hono/validator";
+// src/routes/http.ts
+const NO_STORE = "private, no-store";
+function problemBody(err, instance) {
+	return err.toProblem(instance);
+}
+function problemResponse(err, instance) {
+	return new Response(JSON.stringify(problemBody(err, instance)), {
+		status: err.status,
+		headers: {
+			"content-type": PROBLEM_CONTENT_TYPE,
+			"cache-control": NO_STORE
+		}
+	});
+}
+/** `onError` for the sub-apps: plugin problems → problem+json (or the host's error through `ports.errors`). */
+function errorHandler(errors) {
+	return (err, c) => {
+		if (!isTelegramPluginError(err)) throw err;
+		const instance = new URL(c.req.url).pathname;
+		if (errors) throw errors(err.toProblem(instance), err);
+		return problemResponse(err, instance);
+	};
+}
+function validationError(error, prefix = "") {
+	return new TelegramPluginError("validation_failed", "request is not valid", {
+		status: PROBLEM_STATUS.validation_failed,
+		extensions: { issues: error.issues.slice(0, 50).map((i) => ({
+			path: [prefix, ...i.path.map(String)].filter(Boolean).join("."),
+			message: i.message
+		})) }
+	});
+}
+function parseWith(schema, value, prefix) {
+	const r = schema.safeParse(value);
+	if (!r.success) throw validationError(r.error, prefix);
+	return r.data;
+}
+const zJson = (schema) => validator("json", (value) => parseWith(schema, value, "body"));
+const zQuery = (schema) => validator("query", (value) => parseWith(schema, value, "query"));
+/** Validates `:id` route params with the contracts `Id`. */
+function idParam(c, name = "id") {
+	const r = Id.safeParse(c.req.param(name));
+	if (!r.success) throw new TelegramPluginError("not_found", `${name} not found`);
+	return r.data;
+}
+/** Opaque cursor = base64url of the last row id. */
+function encodeCursor(id) {
+	return btoa(id).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function decodeCursor(cursor) {
+	if (!cursor) return null;
+	try {
+		const s = cursor.replaceAll("-", "+").replaceAll("_", "/");
+		const id = atob(s.padEnd(Math.ceil(s.length / 4) * 4, "="));
+		return Id.safeParse(id).success ? id : null;
+	} catch {
+		throw new TelegramPluginError("validation_failed", "cursor is not valid", { extensions: { issues: [{
+			path: "query.cursor",
+			message: "invalid cursor"
+		}] } });
+	}
+}
+/** Rows fetched with `limit + 1` → `{ items, next }`. */
+function pageOf(rows, limit, map) {
+	const more = rows.length > limit;
+	const slice = more ? rows.slice(0, limit) : rows;
+	const last = slice.at(-1);
+	return {
+		items: slice.map(map),
+		next: more && last ? encodeCursor(last.id) : null
+	};
+}
+function execOf(c) {
+	try {
+		return c.executionCtx;
+	} catch {
+		return;
+	}
+}
+/** Sets the runtime and `Cache-Control: private, no-store` on every plugin response. */
+function runtimeMiddleware(deps) {
+	return async (c, next) => {
+		c.set("tg", deps.runtime(c.env, execOf(c)));
+		await next();
+		c.res.headers.set("cache-control", NO_STORE);
+	};
+}
+/** Admin and /me routes refuse to run on a database behind `SCHEMA_VERSION` (503 schema_outdated). */
+function schemaGuard(deps) {
+	return async (c, next) => {
+		const key = deps.schemaKey(c.env);
+		if (!key || !deps.schemaOk.has(key)) {
+			const state = await ensureState(c.var.tg);
+			if (!state.ok) {
+				c.var.tg.log.error("tg.schema_outdated", {
+					required: state.required,
+					current: state.current,
+					missing: state.missing.length
+				});
+				throw new TelegramPluginError("schema_outdated", `database schema ${state.current ?? "none"} < ${state.required}`);
+			}
+			if (key) deps.schemaOk.add(key);
+		}
+		await next();
+	};
+}
+/** Resolves the host actor (`ports.actor.fromRequest`); 401 `unauthenticated` when nobody is signed in. */
+const actorMiddleware = async (c, next) => {
+	const actor = await c.var.tg.actor.fromRequest(c);
+	if (actor === null || actor === void 0) throw new TelegramPluginError("unauthenticated", "sign in required");
+	c.set("tgActor", actor);
+	await next();
+};
+/** Requires one plugin permission; then runs an armed `idempotencyMiddleware` (so a replay is never unchecked). */
+function requirePermission(name) {
+	return async (c, next) => {
+		if (!await c.var.tg.can(c.var.tgActor, name)) throw new TelegramPluginError("forbidden", `missing ${c.var.tg.perm(name)}`);
+		c.set("tgPermChecked", true);
+		const key = c.var.tgIdem === "armed" ? idempotencyKeyOf(c) : null;
+		if (key !== null) {
+			c.set("tgIdem", "done");
+			return runIdempotent(c, next, key);
+		}
+		await next();
+	};
+}
+/** 404 `feature_disabled` for every route of a feature that is off. */
+function featureGate(features, key) {
+	return async (_c, next) => {
+		if (features[key] !== true) throw featureDisabled(key);
+		await next();
+	};
+}
+/** Stable per-caller key part: the host user id, else the role (actors without a user id). */
+function actorKey(c) {
+	const d = c.var.tg.describe(c.var.tgActor);
+	return d.userId !== null ? `user:${d.userId}` : `role:${d.role ?? ""}`;
+}
+/**
+* Routes whose answer holds a secret (plaintext one-time link codes) are never stored. A retry after the first
+* request finished runs again (a fresh code); a retry while it is still in flight gets 409.
+*/
+const NO_STORE_PATHS = ["/admin/links", "/me/link"];
+/** Per-route opt-out: a handler calls this so its response is never written to `tg_state`. */
+function skipIdempotencyStore(c) {
+	c.set("tgIdemNoStore", true);
+}
+function isJson(contentType) {
+	return contentType !== null && /^application\/([a-z0-9.+-]*\+)?json\b/i.test(contentType);
+}
+async function runIdempotent(c, next, key) {
+	const rt = c.var.tg;
+	const path = new URL(c.req.url).pathname;
+	const slot = await reserveIdempotency(rt, {
+		key,
+		actor: actorKey(c),
+		method: c.req.method,
+		path,
+		body: await c.req.text()
+	});
+	if (slot.replay) {
+		const r = slot.replay;
+		return new Response(r.body === null ? null : JSON.stringify(r.body), {
+			status: r.status,
+			headers: {
+				"content-type": r.contentType ?? "application/json",
+				"idempotent-replay": "true"
+			}
+		});
+	}
+	const timer = setInterval(() => {
+		slot.renew().catch(() => {});
+	}, IDEMPOTENCY_RENEW_MS);
+	try {
+		await next();
+	} catch (e) {
+		await slot.release();
+		throw e;
+	} finally {
+		clearInterval(timer);
+	}
+	const contentType = c.res.headers.get("content-type");
+	const noStore = c.var.tgIdemNoStore === true || NO_STORE_PATHS.some((p) => path.endsWith(p));
+	if (c.error || c.res.status >= 500 || noStore || !isJson(contentType)) {
+		await slot.release();
+		return;
+	}
+	const text = await c.res.clone().text();
+	let body = null;
+	try {
+		body = text === "" ? null : JSON.parse(text);
+	} catch {
+		await slot.release();
+		return;
+	}
+	await slot.save({
+		status: c.res.status,
+		body,
+		contentType
+	});
+}
+function idempotencyKeyOf(c) {
+	if (c.req.method === "GET" || c.req.method === "HEAD") return null;
+	return c.req.header("idempotency-key") ?? null;
+}
+/**
+* `Idempotency-Key` on writes: replays the stored response for a repeated key. The replay never runs before the
+* route's permission check: placed before `requirePermission` it only arms it, and the check runs it after passing.
+*/
+const idempotencyMiddleware = async (c, next) => {
+	const key = idempotencyKeyOf(c);
+	if (key === null) return next();
+	if (c.var.tgPermChecked === true) return runIdempotent(c, next, key);
+	c.set("tgIdem", "armed");
+	await next();
+};
+export { NO_STORE, actorKey, actorMiddleware, decodeCursor, encodeCursor, errorHandler, featureGate, idParam, idempotencyMiddleware, pageOf, problemBody, problemResponse, requirePermission, runtimeMiddleware, schemaGuard, skipIdempotencyStore, validationError, zJson, zQuery };

package/dist/routes/me.js

@@ -0,0 +1,59 @@
+import { SelfLinkCreate } from "../contracts/links.js";
+import { SubscriptionSave } from "../contracts/subscriptions.js";
+import { TelegramPluginError } from "../engine/errors.js";
+import { chatDto } from "../engine/rows.js";
+import { myChats, requireOwnChat, unlinkChat } from "../services/chats.js";
+import { confirmPendingLink, createSelfLink, declinePendingLink, listPendingLinks } from "../services/links.js";
+import { listSubscriptions, replaceSubscriptions } from "../services/subscriptions.js";
+import { actorMiddleware, errorHandler, featureGate, idParam, idempotencyMiddleware, requirePermission, runtimeMiddleware, schemaGuard, zJson } from "./http.js";
+import { Hono } from "hono";
+// src/routes/me.ts
+function userIdOf(c) {
+	const id = c.var.tg.describe(c.var.tgActor).userId;
+	if (!id) throw new TelegramPluginError("forbidden", "only signed-in users have their own chats");
+	return id;
+}
+const needSelfLink = requirePermission("telegram.self.link");
+/**
+* `telegram.self.link` for every `/me` route except the pending-invite ones: confirming an admin invite needs only
+* a signed-in user whose id is the invite's user (checked in the service), so invited users without self-link can
+* still accept.
+*/
+const selfLinkPermission = async (c, next) => {
+	if (c.req.path.includes("/me/links/pending")) return next();
+	return needSelfLink(c, next);
+};
+function meRoutes(deps) {
+	const app = new Hono();
+	app.onError(errorHandler(deps.errors));
+	app.use("/me/*", runtimeMiddleware(deps), schemaGuard(deps), actorMiddleware, selfLinkPermission, idempotencyMiddleware);
+	app.use("/me/subscriptions", featureGate(deps.features, "subscriptions"));
+	return app.post("/me/link", zJson(SelfLinkCreate), async (c) => {
+		return c.json(await createSelfLink(c.var.tg, c.var.tgActor, c.req.valid("json").bot), 201);
+	}).get("/me/links/pending", async (c) => {
+		return c.json({ items: await listPendingLinks(c.var.tg, c.var.tgActor) });
+	}).post("/me/links/pending/:id/confirm", async (c) => {
+		return c.json({ chat: await confirmPendingLink(c.var.tg, c.var.tgActor, idParam(c)) });
+	}).post("/me/links/pending/:id/decline", async (c) => {
+		await declinePendingLink(c.var.tg, c.var.tgActor, idParam(c));
+		return c.json({ ok: true });
+	}).get("/me/chats", async (c) => {
+		const page = {
+			items: (await myChats(c.var.tg, userIdOf(c))).map(chatDto),
+			next: null
+		};
+		return c.json(page);
+	}).delete("/me/chats/:id", async (c) => {
+		const chat = await requireOwnChat(c.var.tg, userIdOf(c), idParam(c));
+		await unlinkChat(c.var.tg, c.var.tgActor, chat.id);
+		return c.json({ ok: true });
+	}).get("/me/subscriptions", async (c) => {
+		const rows = await myChats(c.var.tg, userIdOf(c));
+		return c.json({ items: await listSubscriptions(c.var.tg, rows.map((r) => r.id)) });
+	}).put("/me/subscriptions", zJson(SubscriptionSave), async (c) => {
+		const body = c.req.valid("json");
+		await requireOwnChat(c.var.tg, userIdOf(c), body.chatRef);
+		return c.json({ items: await replaceSubscriptions(c.var.tg, body) });
+	});
+}
+export { meRoutes };

package/dist/routes/schedules.js

@@ -0,0 +1,62 @@
+import { PageQuery } from "../contracts/common.js";
+import { RecipientSpec } from "../contracts/recipients.js";
+import { NextRunsRequest, SchedulePause, ScheduleSave } from "../contracts/schedules.js";
+import { scheduleDto, scheduleRunDto } from "../engine/schedules/rows.js";
+import { decodeCursor, featureGate, idParam, pageOf, requirePermission, validationError, zJson, zQuery } from "./http.js";
+import { createSchedule, deleteSchedule, getSchedule, listRuns, listSchedules, pauseSchedule, previewNextRuns, resumeSchedule, runScheduleNow, updateSchedule } from "../services/schedules.js";
+import { z } from "zod";
+import { Hono } from "hono";
+// src/routes/schedules.ts
+/** Zone and recipient count are checked by the service, so they answer `timezone_invalid` / `recipient_empty`. */
+const SaveBody = ScheduleSave.extend({
+	timezone: z.string().min(1).max(64).optional(),
+	recipients: z.array(RecipientSpec).max(100)
+});
+const PERM = "telegram.schedules.manage";
+function scheduleRoutes(deps) {
+	const app = new Hono();
+	app.use("/admin/schedules", featureGate(deps.features, "schedules"));
+	app.use("/admin/schedules/*", featureGate(deps.features, "schedules"));
+	return app.get("/admin/schedules", requirePermission(PERM), zQuery(PageQuery), async (c) => {
+		const q = c.req.valid("query");
+		const rows = await listSchedules(c.var.tg, {
+			cursor: decodeCursor(q.cursor),
+			limit: q.limit
+		});
+		return c.json(pageOf(rows, q.limit, scheduleDto));
+	}).post("/admin/schedules", requirePermission(PERM), zJson(SaveBody), async (c) => {
+		return c.json(await createSchedule(c.var.tg, c.var.tgActor, c.req.valid("json")), 201);
+	}).post("/admin/schedules/next-runs", requirePermission(PERM), zJson(NextRunsRequest), async (c) => {
+		return c.json(previewNextRuns(c.var.tg, c.req.valid("json")));
+	}).get("/admin/schedules/:id", requirePermission(PERM), async (c) => {
+		return c.json(await getSchedule(c.var.tg, idParam(c)));
+	}).put("/admin/schedules/:id", requirePermission(PERM), zJson(SaveBody), async (c) => {
+		return c.json(await updateSchedule(c.var.tg, c.var.tgActor, idParam(c), c.req.valid("json")));
+	}).delete("/admin/schedules/:id", requirePermission(PERM), async (c) => {
+		await deleteSchedule(c.var.tg, c.var.tgActor, idParam(c));
+		return c.json({ ok: true });
+	}).post("/admin/schedules/:id/pause", requirePermission(PERM), async (c) => {
+		const text = await c.req.text();
+		let raw = {};
+		try {
+			raw = text.trim() === "" ? {} : JSON.parse(text);
+		} catch {
+			raw = null;
+		}
+		const body = SchedulePause.safeParse(raw);
+		if (!body.success) throw validationError(body.error, "body");
+		return c.json(await pauseSchedule(c.var.tg, c.var.tgActor, idParam(c), body.data));
+	}).post("/admin/schedules/:id/resume", requirePermission(PERM), async (c) => {
+		return c.json(await resumeSchedule(c.var.tg, c.var.tgActor, idParam(c)));
+	}).post("/admin/schedules/:id/run-now", requirePermission(PERM), async (c) => {
+		return c.json(await runScheduleNow(c.var.tg, c.var.tgActor, idParam(c)));
+	}).get("/admin/schedules/:id/runs", requirePermission(PERM), zQuery(PageQuery), async (c) => {
+		const q = c.req.valid("query");
+		const rows = await listRuns(c.var.tg, idParam(c), {
+			cursor: decodeCursor(q.cursor),
+			limit: q.limit
+		});
+		return c.json(pageOf(rows, q.limit, scheduleRunDto));
+	});
+}
+export { scheduleRoutes };

package/dist/routes/send.js

@@ -0,0 +1,24 @@
+import { SendIntent } from "../contracts/send.js";
+import { sha256Hex } from "../core/random.js";
+import { enqueueIntent, previewIntent } from "../services/send.js";
+import { actorKey, requirePermission, zJson } from "./http.js";
+import { Hono } from "hono";
+// src/routes/send.ts
+function sendRoutes(_deps) {
+	return new Hono().post("/admin/send/preview", requirePermission("telegram.send"), zJson(SendIntent), async (c) => {
+		return c.json(await previewIntent(c.var.tg, c.var.tgActor, c.req.valid("json")));
+	}).post("/admin/send", requirePermission("telegram.send"), zJson(SendIntent), async (c) => {
+		const rt = c.var.tg;
+		const key = c.req.header("idempotency-key");
+		const intent = c.req.valid("json");
+		const dedupeKey = key ? `api:${(await sha256Hex(crypto.subtle, `/admin/send|${actorKey(c)}|${key}|${JSON.stringify(intent)}`)).slice(0, 40)}` : `api:${rt.ids.uuid()}`;
+		const sqls = await enqueueIntent(rt, c.var.tgActor, intent, { dedupeKey });
+		const queued = (sqls.length > 0 ? await rt.db.batch(sqls) : []).reduce((n, r, i) => n + (/^\s*INSERT INTO tg_delivery/.test(sqls[i]?.text ?? "") ? r.changes : 0), 0);
+		rt.waitUntil(rt.transport.kick());
+		return c.json({
+			queued,
+			dedupeKey
+		});
+	});
+}
+export { sendRoutes };

package/dist/routes/templates.js

@@ -0,0 +1,70 @@
+import { PageQuery } from "../contracts/common.js";
+import { ReportRenderRequest, TemplatePreviewRequest, TemplateQuery, TemplateSave } from "../contracts/templates.js";
+import { TelegramPluginError } from "../engine/errors.js";
+import { buildReport } from "../services/reports.js";
+import { audienceForPreview } from "../engine/content/audience.js";
+import { requireTemplate, requireTemplateByKey, templateDto, templateModel } from "../engine/content/template-rows.js";
+import { decodeCursor, featureGate, idParam, pageOf, requirePermission, zJson, zQuery } from "./http.js";
+import { createTemplate, deleteTemplate, listTemplates, listVersions, previewTemplate, restoreVersion, updateTemplate } from "../services/templates.js";
+import { z } from "zod";
+import { Hono } from "hono";
+// src/routes/templates.ts
+const ListQuery = TemplateQuery.extend(PageQuery.shape);
+const Version = z.coerce.number().int().min(1);
+/** RFC 6266 filename (ASCII fallback + UTF-8 form for Marathi names). */
+function disposition(name) {
+	return `attachment; filename="${name.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "_")}"; filename*=UTF-8''${encodeURIComponent(name)}`;
+}
+function templateRoutes(deps) {
+	const app = new Hono();
+	app.use("/admin/templates", featureGate(deps.features, "templates"));
+	app.use("/admin/templates/*", featureGate(deps.features, "templates"));
+	app.use("/admin/reports/*", featureGate(deps.features, "reports"));
+	return app.get("/admin/templates", requirePermission("telegram.templates.manage"), zQuery(ListQuery), async (c) => {
+		const q = c.req.valid("query");
+		const rows = await listTemplates(c.var.tg, q, {
+			cursor: decodeCursor(q.cursor),
+			limit: q.limit
+		});
+		return c.json(pageOf(rows, q.limit, templateDto));
+	}).post("/admin/templates", requirePermission("telegram.templates.manage"), zJson(TemplateSave), async (c) => {
+		return c.json(await createTemplate(c.var.tg, c.var.tgActor, c.req.valid("json")), 201);
+	}).post("/admin/templates/preview", requirePermission("telegram.templates.manage"), zJson(TemplatePreviewRequest), async (c) => {
+		return c.json(await previewTemplate(c.var.tg, c.var.tgActor, c.req.valid("json")));
+	}).get("/admin/templates/:id", requirePermission("telegram.templates.manage"), async (c) => {
+		return c.json(templateDto(await requireTemplate(c.var.tg, idParam(c))));
+	}).put("/admin/templates/:id", requirePermission("telegram.templates.manage"), zJson(TemplateSave), async (c) => {
+		return c.json(await updateTemplate(c.var.tg, c.var.tgActor, idParam(c), c.req.valid("json")));
+	}).delete("/admin/templates/:id", requirePermission("telegram.templates.manage"), async (c) => {
+		await deleteTemplate(c.var.tg, c.var.tgActor, idParam(c));
+		return c.json({ ok: true });
+	}).get("/admin/templates/:id/versions", requirePermission("telegram.templates.manage"), async (c) => {
+		return c.json({ items: await listVersions(c.var.tg, idParam(c)) });
+	}).post("/admin/templates/:id/restore/:version", requirePermission("telegram.templates.manage"), async (c) => {
+		const v = Version.safeParse(c.req.param("version"));
+		if (!v.success) throw new TelegramPluginError("not_found", "version not found");
+		return c.json(await restoreVersion(c.var.tg, c.var.tgActor, idParam(c), v.data));
+	}).post("/admin/reports/render", requirePermission("telegram.reports.run"), zJson(ReportRenderRequest), async (c) => {
+		const rt = c.var.tg;
+		const req = c.req.valid("json");
+		const template = templateModel(await requireTemplateByKey(rt, req.template));
+		const actor = await audienceForPreview(rt, req.as);
+		const locale = req.locale ?? rt.describe(actor).locale;
+		const built = await buildReport(rt, {
+			template,
+			actor,
+			params: req.params,
+			locales: [locale],
+			tz: rt.settings.timezone,
+			format: req.format,
+			now: rt.clock.now(),
+			viewer: c.var.tgActor
+		});
+		return new Response(built.file.body, { headers: {
+			"content-type": built.file.mime,
+			"content-disposition": disposition(built.file.name),
+			...built.file.size === void 0 ? {} : { "content-length": String(built.file.size) }
+		} });
+	});
+}
+export { templateRoutes };