@jant/core 0.5.4 → 0.6.1

package/src/routes/api/upload-multipart.ts

@@ -29,6 +29,10 @@ import {
   validateStoredUploadMetadata,
   validateStoredUploadSignature,
 } from "../../lib/upload.js";
+import {
+  IMAGE_DIMENSION_PEEK_BYTES,
+  parseImageDimensions,
+} from "../../lib/image-dimensions.js";
 import { supportsMultipart } from "../../lib/storage.js";
 import {
   MediaQuotaExceededError,
@@ -230,7 +234,16 @@ multipartUploadApiRoutes.post("/:id/complete", async (c) => {
     data.parts,
   );
 
-  const peekLength = getStoredUploadSignaturePeekLength(data.contentType);
+  const signaturePeekLength = getStoredUploadSignaturePeekLength(
+    data.contentType,
+  );
+  let width = data.width && data.width > 0 ? data.width : undefined;
+  let height = data.height && data.height > 0 ? data.height : undefined;
+  const needsDimensionSniff =
+    (!width || !height) && data.contentType.startsWith("image/");
+  const peekLength = needsDimensionSniff
+    ? Math.max(signaturePeekLength, IMAGE_DIMENSION_PEEK_BYTES)
+    : signaturePeekLength;
   if (peekLength > 0) {
     const object = await storage.get(data.storageKey, {
       range: { offset: 0, length: peekLength },
@@ -239,16 +252,25 @@ multipartUploadApiRoutes.post("/:id/complete", async (c) => {
       throw new ValidationError("The uploaded file could not be found.");
     }
     const bytes = new Uint8Array(await new Response(object.body).arrayBuffer());
-    const signatureError = validateStoredUploadSignature(
-      data.contentType,
-      bytes,
-    );
-    if (signatureError) {
-      await storage.delete(data.storageKey).catch(() => {});
-      if (data.posterKey) {
-        await storage.delete(data.posterKey).catch(() => {});
+    if (signaturePeekLength > 0) {
+      const signatureError = validateStoredUploadSignature(
+        data.contentType,
+        bytes.subarray(0, signaturePeekLength),
+      );
+      if (signatureError) {
+        await storage.delete(data.storageKey).catch(() => {});
+        if (data.posterKey) {
+          await storage.delete(data.posterKey).catch(() => {});
+        }
+        throw new ValidationError(signatureError);
+      }
+    }
+    if (needsDimensionSniff) {
+      const dimensions = parseImageDimensions(data.contentType, bytes);
+      if (dimensions) {
+        width ??= dimensions.width;
+        height ??= dimensions.height;
       }
-      throw new ValidationError(signatureError);
     }
   }
 
@@ -261,8 +283,8 @@ multipartUploadApiRoutes.post("/:id/complete", async (c) => {
     size: data.size,
     storageKey: data.storageKey,
     provider: c.var.appConfig.storageDriver,
-    width: data.width && data.width > 0 ? data.width : undefined,
-    height: data.height && data.height > 0 ? data.height : undefined,
+    width,
+    height,
     durationSeconds:
       data.durationSeconds && data.durationSeconds > 0
         ? data.durationSeconds

package/src/routes/api/upload.ts

@@ -28,6 +28,10 @@ import {
   validateStoredUploadMetadata,
   validateStoredUploadSignature,
 } from "../../lib/upload.js";
+import {
+  IMAGE_DIMENSION_PEEK_BYTES,
+  parseImageDimensions,
+} from "../../lib/image-dimensions.js";
 import {
   assertFound,
   MediaQuotaExceededError,
@@ -284,6 +288,23 @@ uploadApiRoutes.post("/", async (c) => {
     const blurhashRaw = (formData.get("blurhash") as string) || undefined;
     const waveformRaw = (formData.get("waveform") as string) || undefined;
 
+    let width = widthRaw && widthRaw > 0 ? widthRaw : undefined;
+    let height = heightRaw && heightRaw > 0 ? heightRaw : undefined;
+    if ((!width || !height) && file.type.startsWith("image/")) {
+      try {
+        const headerBytes = new Uint8Array(
+          await file.slice(0, IMAGE_DIMENSION_PEEK_BYTES).arrayBuffer(),
+        );
+        const dimensions = parseImageDimensions(file.type, headerBytes);
+        if (dimensions) {
+          width ??= dimensions.width;
+          height ??= dimensions.height;
+        }
+      } catch {
+        // Dimensions are optional — fall through with whatever the client sent.
+      }
+    }
+
     // Upload poster frame for videos (if provided by client)
     let posterKey: string | undefined;
     const posterFile = formData.get("poster") as File | null;
@@ -308,8 +329,8 @@ uploadApiRoutes.post("/", async (c) => {
       size: file.size,
       storageKey,
       provider: c.var.appConfig.storageDriver,
-      width: widthRaw && widthRaw > 0 ? widthRaw : undefined,
-      height: heightRaw && heightRaw > 0 ? heightRaw : undefined,
+      width,
+      height,
       durationSeconds:
         durationSecondsRaw && durationSecondsRaw > 0
           ? durationSecondsRaw

package/src/routes/dash/settings.tsx

@@ -44,6 +44,12 @@ import {
   GitHubSyncContent,
   type GitHubSyncStatus,
 } from "../../ui/dash/settings/GitHubSyncContent.js";
+import {
+  readTelegramSettingsView,
+  renderTelegramContentHtml,
+  getTelegramStatusStreamUrl,
+} from "../../lib/telegram-settings-status.js";
+import { TelegramContent } from "../../ui/dash/settings/TelegramContent.js";
 import { toAbsoluteSiteUrl, toPublicPath } from "../../lib/url.js";
 import { parseValidated, UpdateSiteSettingsSchema } from "../../lib/schemas.js";
 import {
@@ -56,6 +62,7 @@ import { syncHostedControlPlaneSiteAvatar } from "../../lib/hosted-control-plane
 import {
   getGitHubAppConfig,
   getHostedControlPlaneSsoSecret,
+  getTelegramBotPool,
 } from "../../lib/env.js";
 import {
   buildInstallUrl,
@@ -131,7 +138,8 @@ function breadcrumbLabel(
     | "password"
     | "deleteAccount"
     | "apiTokens"
-    | "githubSync",
+    | "githubSync"
+    | "telegram",
 ): string {
   const i18n = getI18n(c);
   switch (key) {
@@ -197,6 +205,10 @@ function breadcrumbLabel(
       return i18n._(
         msg({ message: "GitHub Sync", comment: "@context: Breadcrumb label" }),
       );
+    case "telegram":
+      return i18n._(
+        msg({ message: "Telegram", comment: "@context: Breadcrumb label" }),
+      );
   }
 }
 
@@ -2297,3 +2309,121 @@ settingsRoutes.get("/github-sync", async (c) => {
     ),
   });
 });
+
+// ===========================================================================
+// Telegram
+// ===========================================================================
+
+settingsRoutes.get("/telegram", async (c) => {
+  const view = await readTelegramSettingsView(c);
+  const streamUrl = getTelegramStatusStreamUrl(c);
+  const navData = await getNavigationData(c);
+  return renderPublicPage(c, {
+    title: buildPageTitle("Telegram", navData.siteName),
+    navData,
+    content: (
+      <>
+        <AdminBreadcrumb
+          parent={breadcrumbLabel(c, "settings")}
+          parentHref={publicPath(c, "/settings")}
+          current={breadcrumbLabel(c, "telegram")}
+        />
+        <TelegramContent
+          view={view}
+          sitePathPrefix={c.var.appConfig.sitePathPrefix}
+          streamUrl={streamUrl}
+        />
+      </>
+    ),
+  });
+});
+
+/**
+ * Live status stream — swaps the connect view for the connected view the
+ * moment a binding lands, so the user doesn't have to refresh after sending
+ * the binding code to the bot. Same pattern as GitHub Sync's status stream:
+ * subscribed via Datastar `data-init="@get(...)"`, each frame is a
+ * `patchElements` with `mode: outer` on the stable `#telegram-status` id.
+ *
+ * The connected view ships without `data-init`, so the stream closes as
+ * soon as we send the first "binding present" frame. A 5-minute cap bounds
+ * an abandoned subscription.
+ */
+settingsRoutes.get("/telegram/status/stream", async (c) => {
+  const streamUrl = getTelegramStatusStreamUrl(c);
+  // 5 minutes is well above the time a user reasonably spends sending a
+  // code to a bot; longer windows just close and the page can be reloaded.
+  const MAX_DURATION_MS = 5 * 60 * 1000;
+  // 1.5s keeps the UI snappy without hammering the binding table.
+  const POLL_INTERVAL_MS = 1500;
+
+  return sse(c, async (stream) => {
+    const startedAt = Date.now();
+    let lastHtml: string | null = null;
+
+    while (true) {
+      const view = await readTelegramSettingsView(c);
+      const html = renderTelegramContentHtml(c, view, streamUrl);
+      if (html !== lastHtml) {
+        stream.patchElements(html, {
+          mode: "outer",
+          selector: "#telegram-status",
+        });
+        lastHtml = html;
+      }
+
+      // Binding landed: the patch above just shipped the connected view
+      // (no `data-init`), so the client will close. A brief beat lets the
+      // browser apply the patch before the server-side stream ends.
+      if (view.binding) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        break;
+      }
+
+      if (Date.now() - startedAt >= MAX_DURATION_MS) break;
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+  });
+});
+
+settingsRoutes.post("/telegram/connect", async (c) => {
+  // Token entry is for bring-your-own deployments only. When a managed pool
+  // is configured the bot is platform-owned and users connect via a code.
+  if (getTelegramBotPool(c.env).length > 0) {
+    return dsToast(
+      "This deployment uses a managed Telegram bot. Connect with the binding code instead.",
+      "error",
+    );
+  }
+
+  const body = await c.req.json<{ token?: string }>();
+  const token = body.token?.trim();
+  if (!token) {
+    return dsToast("Paste your bot token to continue.", "error");
+  }
+
+  const siteUrl = c.var.appConfig.siteUrl.replace(/\/+$/, "");
+  try {
+    await c.var.services.telegram.connectUserBot(token, siteUrl);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return dsToast(`Could not set up the bot: ${detail}`, "error");
+  }
+
+  return dsRedirect(publicPath(c, "/settings/telegram"));
+});
+
+settingsRoutes.post("/telegram/remove-bot", async (c) => {
+  await c.var.services.telegram.removeUserBot();
+  return dsRedirect(publicPath(c, "/settings/telegram"));
+});
+
+settingsRoutes.post("/telegram/regenerate-code", async (c) => {
+  await c.var.services.telegram.generateCode();
+  return dsRedirect(publicPath(c, "/settings/telegram"));
+});
+
+settingsRoutes.post("/telegram/disconnect", async (c) => {
+  await c.var.services.telegram.disconnect();
+  return dsRedirect(publicPath(c, "/settings/telegram"));
+});

package/src/routes/pages/__tests__/post-page-title.test.ts

@@ -0,0 +1,70 @@
+/**
+ * Tests for the `<title>` tag on post pages.
+ *
+ * Post pages compose `<title>` as "Post Title - Site Name" so the site
+ * name is visible in browser tabs, bookmarks, and SEO snippets, matching
+ * the convention used by Settings, Search, Archive, and Collection pages.
+ */
+
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { pageRoutes } from "../page.js";
+
+function createPageTestApp() {
+  const testApp = createTestApp();
+  const { app } = testApp;
+
+  app.use("*", async (c, next) => {
+    c.set("publicPath", c.req.path);
+    c.set("publicRequestUrl", c.req.url);
+    await next();
+  });
+
+  app.route("/", pageRoutes);
+
+  return testApp;
+}
+
+function extractTitle(html: string): string | null {
+  const match = html.match(/<title>([^<]*)<\/title>/i);
+  return match?.[1] ?? null;
+}
+
+describe("Post page <title>", () => {
+  it("appends the site name to the post title", async () => {
+    const { app, services } = createPageTestApp();
+    await services.settings.set("SITE_NAME", "Owen");
+
+    const post = await services.posts.create({
+      format: "note",
+      title: "Hello world",
+      bodyMarkdown: "Body",
+      status: "published",
+    });
+
+    const res = await app.request(`/${post.slug}`);
+    expect(res.status).toBe(200);
+
+    const html = await res.text();
+    expect(extractTitle(html)).toBe("Hello world - Owen");
+  });
+
+  it("falls back to derived meta title when post has no title", async () => {
+    const { app, services } = createPageTestApp();
+    await services.settings.set("SITE_NAME", "Owen");
+
+    const post = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "First sentence of the body.",
+      status: "published",
+    });
+
+    const res = await app.request(`/${post.slug}`);
+    expect(res.status).toBe(200);
+
+    const html = await res.text();
+    const title = extractTitle(html);
+    expect(title).toMatch(/- Owen$/);
+    expect(title).toContain("First sentence");
+  });
+});

package/src/routes/pages/page.tsx

@@ -11,6 +11,7 @@ import type { AppVariables } from "../../types/app-context.js";
 import { PostPage } from "../../ui/pages/PostPage.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
+import { buildPageTitle } from "../../lib/page-title.js";
 import { buildPostMeta } from "../../lib/post-meta.js";
 import { assemblePostPageDisplay } from "../../lib/post-display.js";
 import { toPublicHref, toPublicPath } from "../../lib/url.js";
@@ -93,7 +94,7 @@ async function renderPostWithTextPreview(
     .replace(/>/g, "\\u003e");
 
   return renderPublicPage(c, {
-    title: pageTitle,
+    title: buildPageTitle(pageTitle, navData.siteName),
     description: meta.description,
     canonicalHref,
     navData,
@@ -162,7 +163,7 @@ async function renderPost(c: Context<Env>, post: Post) {
   );
 
   return renderPublicPage(c, {
-    title: meta.title,
+    title: buildPageTitle(meta.title, navData.siteName),
     description: meta.description,
     canonicalHref,
     navData,

package/src/runtime/cloudflare.ts

@@ -34,6 +34,12 @@ export interface CloudflareRequestRuntime {
   hostedHandoff: HostedHandoffService;
   rateLimiter: RateLimiter;
   services: Services;
+  /**
+   * Builds a `Services` object scoped to an arbitrary site. Used by
+   * host-agnostic handlers (e.g. the Telegram webhook) that resolve the
+   * target site from request data rather than the hostname.
+   */
+  servicesForSite: (siteId: string) => Services;
   storage: StorageDriver | null;
 }
 
@@ -81,6 +87,18 @@ export async function createCloudflareRequestRuntime(
     useSecureCookies: shouldUseSecureCookies(env, publicRequestUrl),
   });
 
+  const servicesConfig = {
+    databaseDialect: "sqlite" as const,
+    bootstrapSite: getSingleSiteBootstrapOptions(env),
+    enforceHostedMediaQuota: getSiteResolutionMode(env) === "host-based",
+    hostedControlPlane: createHostedControlPlaneClient(env),
+    siteResolutionMode: getSiteResolutionMode(env),
+    slugIdLength,
+    schema: sqliteSchemaBundle,
+  };
+  const servicesForSite = (siteId: string): Services =>
+    createServices(db, session, siteId, servicesConfig);
+
   return {
     auth,
     currentSite: siteLookup.site,
@@ -92,15 +110,8 @@ export async function createCloudflareRequestRuntime(
       secret: hostedControlPlaneSsoSecret,
     }),
     rateLimiter: createD1RateLimiter(db, sqliteSchemaBundle),
-    services: createServices(db, session, siteLookup.site.id, {
-      databaseDialect: "sqlite",
-      bootstrapSite: getSingleSiteBootstrapOptions(env),
-      enforceHostedMediaQuota: getSiteResolutionMode(env) === "host-based",
-      hostedControlPlane: createHostedControlPlaneClient(env),
-      siteResolutionMode: getSiteResolutionMode(env),
-      slugIdLength,
-      schema: sqliteSchemaBundle,
-    }),
+    services: servicesForSite(siteLookup.site.id),
+    servicesForSite,
     storage: createStorageDriver(env),
   };
 }

package/src/runtime/node.ts

@@ -37,6 +37,12 @@ export interface NodeRequestRuntime {
   hostedHandoff: HostedHandoffService;
   rateLimiter: RateLimiter;
   services: Services;
+  /**
+   * Builds a `Services` object scoped to an arbitrary site. Used by
+   * host-agnostic handlers (e.g. the Telegram webhook) that resolve the
+   * target site from request data rather than the hostname.
+   */
+  servicesForSite: (siteId: string) => Services;
   storage: StorageDriver | null;
 }
 
@@ -136,6 +142,18 @@ export async function createNodeRequestRuntime(
     useSecureCookies: shouldUseSecureCookies(env, publicRequestUrl),
   });
 
+  const servicesConfig = {
+    databaseDialect,
+    bootstrapSite: getSingleSiteBootstrapOptions(env),
+    enforceHostedMediaQuota: getSiteResolutionMode(env) === "host-based",
+    hostedControlPlane: createHostedControlPlaneClient(env),
+    siteResolutionMode: getSiteResolutionMode(env),
+    slugIdLength,
+    schema: databaseSchema,
+  };
+  const servicesForSite = (siteId: string): Services =>
+    createServices(db, rawQuery, siteId, servicesConfig);
+
   return {
     auth,
     currentSite: siteLookup.site,
@@ -147,15 +165,8 @@ export async function createNodeRequestRuntime(
       secret: hostedControlPlaneSsoSecret,
     }),
     rateLimiter: getNodeRateLimiter(),
-    services: createServices(db, rawQuery, siteLookup.site.id, {
-      databaseDialect,
-      bootstrapSite: getSingleSiteBootstrapOptions(env),
-      enforceHostedMediaQuota: getSiteResolutionMode(env) === "host-based",
-      hostedControlPlane: createHostedControlPlaneClient(env),
-      siteResolutionMode: getSiteResolutionMode(env),
-      slugIdLength,
-      schema: databaseSchema,
-    }),
+    services: servicesForSite(siteLookup.site.id),
+    servicesForSite,
     storage: createStorageDriver(env),
   };
 }

package/src/runtime/site.ts

@@ -91,7 +91,8 @@ export async function resolveRequestSite(
     // payload's installation id) instead of relying on `currentSite`.
     if (
       requestUrl.pathname.startsWith("/api/internal/") ||
-      requestUrl.pathname === "/api/github-sync/app-webhook"
+      requestUrl.pathname === "/api/github-sync/app-webhook" ||
+      requestUrl.pathname.startsWith("/api/telegram/webhook/")
     ) {
       return {
         site: createTransientSite("internal"),

package/src/services/__tests__/telegram.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createTestDatabase,
+  DEFAULT_TEST_SITE_ID,
+} from "../../__tests__/helpers/db.js";
+import type { Database } from "../../db/index.js";
+import { createTelegramService, type TelegramService } from "../telegram.js";
+
+const SECOND_SITE_ID = "sit_second00000000000000000000000";
+const BOT_ID = "111111";
+const USER_ID = "999999";
+
+function insertSecondSite(
+  sqlite: ReturnType<typeof createTestDatabase>["sqlite"],
+): void {
+  const timestamp = Math.floor(Date.now() / 1000);
+  sqlite
+    .prepare(
+      `INSERT INTO site (id, key, status, created_at, updated_at)
+       VALUES (?, ?, 'active', ?, ?)`,
+    )
+    .run(SECOND_SITE_ID, "second", timestamp, timestamp);
+}
+
+describe("TelegramService", () => {
+  let db: Database;
+  let sqlite: ReturnType<typeof createTestDatabase>["sqlite"];
+  let service: TelegramService;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    sqlite = testDb.sqlite;
+    insertSecondSite(sqlite);
+    service = createTelegramService(db, DEFAULT_TEST_SITE_ID);
+  });
+
+  it("reports an empty status for a fresh site", async () => {
+    const status = await service.getStatus();
+    expect(status.binding).toBeNull();
+    expect(status.userBot).toBeNull();
+  });
+
+  it("reuses an existing code via getOrCreateCode", async () => {
+    const first = await service.getOrCreateCode();
+    const second = await service.getOrCreateCode();
+    expect(second).toBe(first);
+  });
+
+  it("replaces the code on generateCode", async () => {
+    const first = await service.getOrCreateCode();
+    const next = await service.generateCode();
+    expect(next).not.toBe(first);
+    expect(await service.resolvePendingCode(first)).toBeNull();
+    expect(await service.resolvePendingCode(next)).toEqual({
+      siteId: DEFAULT_TEST_SITE_ID,
+    });
+  });
+
+  it("resolves a pending code to its site", async () => {
+    const code = await service.getOrCreateCode();
+    expect(await service.resolvePendingCode(code)).toEqual({
+      siteId: DEFAULT_TEST_SITE_ID,
+    });
+  });
+
+  it("returns null for an unknown code", async () => {
+    expect(await service.resolvePendingCode("nope")).toBeNull();
+  });
+
+  it("treats an expired code as unknown", async () => {
+    const code = await service.getOrCreateCode();
+    sqlite
+      .prepare(
+        `UPDATE telegram_pending_binding SET expires_at = ? WHERE code = ?`,
+      )
+      .run(1, code);
+    expect(await service.resolvePendingCode(code)).toBeNull();
+  });
+
+  it("binds an account and surfaces it in status", async () => {
+    await service.getOrCreateCode();
+    const binding = await service.bindAccount({
+      siteId: DEFAULT_TEST_SITE_ID,
+      botId: BOT_ID,
+      telegramUserId: USER_ID,
+      telegramUsername: "alice",
+    });
+    expect(binding.siteId).toBe(DEFAULT_TEST_SITE_ID);
+
+    const status = await service.getStatus();
+    expect(status.binding).toMatchObject({
+      botId: BOT_ID,
+      telegramUserId: USER_ID,
+      telegramUsername: "alice",
+    });
+
+    // The pending code is consumed on bind.
+    const found = await service.findBindingByUser(BOT_ID, USER_ID);
+    expect(found?.siteId).toBe(DEFAULT_TEST_SITE_ID);
+  });
+
+  it("moves a binding to a new site on rebind (last-write-wins)", async () => {
+    await service.bindAccount({
+      siteId: DEFAULT_TEST_SITE_ID,
+      botId: BOT_ID,
+      telegramUserId: USER_ID,
+      telegramUsername: "alice",
+    });
+    await service.bindAccount({
+      siteId: SECOND_SITE_ID,
+      botId: BOT_ID,
+      telegramUserId: USER_ID,
+      telegramUsername: "alice",
+    });
+
+    const found = await service.findBindingByUser(BOT_ID, USER_ID);
+    expect(found?.siteId).toBe(SECOND_SITE_ID);
+
+    // The first site no longer has a binding.
+    const firstSiteService = createTelegramService(db, DEFAULT_TEST_SITE_ID);
+    expect((await firstSiteService.getStatus()).binding).toBeNull();
+  });
+
+  it("records the last processed update id", async () => {
+    const binding = await service.bindAccount({
+      siteId: DEFAULT_TEST_SITE_ID,
+      botId: BOT_ID,
+      telegramUserId: USER_ID,
+      telegramUsername: null,
+    });
+    await service.markUpdateProcessed(binding.id, 42);
+    const found = await service.findBindingByUser(BOT_ID, USER_ID);
+    expect(found?.lastUpdateId).toBe(42);
+  });
+
+  it("disconnects the active binding", async () => {
+    await service.bindAccount({
+      siteId: DEFAULT_TEST_SITE_ID,
+      botId: BOT_ID,
+      telegramUserId: USER_ID,
+      telegramUsername: null,
+    });
+    await service.disconnect();
+    expect((await service.getStatus()).binding).toBeNull();
+    expect(await service.findBindingByUser(BOT_ID, USER_ID)).toBeNull();
+  });
+});

package/src/services/index.ts

@@ -43,6 +43,7 @@ import {
   createGitHubAppInstallationsService,
   type GitHubAppInstallationsService,
 } from "./github-app-installations.js";
+import { createTelegramService, type TelegramService } from "./telegram.js";
 import type { HostedControlPlaneClient } from "../lib/hosted-control-plane.js";
 import type { EnsureSingleSiteOptions } from "./site.js";
 
@@ -64,6 +65,7 @@ export interface Services {
   siteMembers: SiteMemberService;
   siteProfile: SiteProfileService;
   githubAppInstallations: GitHubAppInstallationsService;
+  telegram: TelegramService;
 }
 
 export function createServices(
@@ -150,6 +152,7 @@ export function createServices(
       db,
       databaseSchema,
     ),
+    telegram: createTelegramService(db, siteId, databaseSchema),
   };
 }
 
@@ -182,3 +185,9 @@ export type {
   GitHubAccountType,
   StoredGitHubAppInstallation,
 } from "./github-app-installations.js";
+export type {
+  TelegramService,
+  TelegramBinding,
+  TelegramStatus,
+  TelegramUserBot,
+} from "./telegram.js";