koztv-blog-tools 1.0.6 → 1.1.1

package/bin/export-telegram.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/**
+ * CLI for exporting Telegram channel posts
+ *
+ * Usage:
+ *   npx koztv-blog-tools export --channel @channelname --out ./export
+ *
+ * Environment variables:
+ *   TELEGRAM_API_ID    - API ID from https://my.telegram.org
+ *   TELEGRAM_API_HASH  - API Hash from https://my.telegram.org
+ *   TELEGRAM_SESSION   - Session string (for re-authentication)
+ */
+
+const { exportTelegramChannel } = require('../dist/index.js');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+// Parse arguments
+const args = process.argv.slice(2);
+const getArg = (name) => {
+  const idx = args.indexOf(`--${name}`);
+  return idx !== -1 ? args[idx + 1] : null;
+};
+
+const CHANNEL = getArg('channel') || process.env.TELEGRAM_CHANNEL;
+const OUTPUT_DIR = getArg('out') || './export';
+const LIMIT = parseInt(getArg('limit') || '0', 10);
+const SINCE = getArg('since');
+const UNTIL = getArg('until');
+const NO_MEDIA = args.includes('--no-media');
+
+const API_ID = parseInt(process.env.TELEGRAM_API_ID || '0', 10);
+const API_HASH = process.env.TELEGRAM_API_HASH || '';
+const SESSION = process.env.TELEGRAM_SESSION || '';
+const SESSION_FILE = path.join(OUTPUT_DIR, '.telegram-session');
+
+if (!CHANNEL) {
+  console.error('Error: Channel is required');
+  console.error('');
+  console.error('Usage:');
+  console.error('  npx koztv-blog-tools export --channel @channelname --out ./export');
+  console.error('');
+  console.error('Environment variables:');
+  console.error('  TELEGRAM_API_ID    - API ID from https://my.telegram.org');
+  console.error('  TELEGRAM_API_HASH  - API Hash');
+  console.error('  TELEGRAM_SESSION   - Session string (optional, for re-auth)');
+  console.error('  TELEGRAM_CHANNEL   - Default channel (optional)');
+  console.error('');
+  console.error('Options:');
+  console.error('  --channel @name   Target channel');
+  console.error('  --out ./path      Output directory (default: ./export)');
+  console.error('  --limit N         Max posts to export');
+  console.error('  --since YYYY-MM-DD  Export posts since date');
+  console.error('  --until YYYY-MM-DD  Export posts until date');
+  console.error('  --no-media        Skip media download');
+  process.exit(1);
+}
+
+if (!API_ID || !API_HASH) {
+  console.error('Error: TELEGRAM_API_ID and TELEGRAM_API_HASH are required');
+  console.error('Get them from https://my.telegram.org');
+  process.exit(1);
+}
+
+// Read saved session if exists
+let savedSession = SESSION;
+if (!savedSession && fs.existsSync(SESSION_FILE)) {
+  savedSession = fs.readFileSync(SESSION_FILE, 'utf-8').trim();
+}
+
+async function main() {
+  console.log('Telegram Channel Exporter');
+  console.log('=========================');
+  console.log(`Channel: ${CHANNEL}`);
+  console.log(`Output: ${OUTPUT_DIR}`);
+  if (LIMIT) console.log(`Limit: ${LIMIT}`);
+  if (SINCE) console.log(`Since: ${SINCE}`);
+  if (UNTIL) console.log(`Until: ${UNTIL}`);
+  console.log(`Media: ${NO_MEDIA ? 'skip' : 'download'}`);
+  console.log('');
+
+  try {
+    const result = await exportTelegramChannel({
+      apiId: API_ID,
+      apiHash: API_HASH,
+      session: savedSession,
+      target: CHANNEL,
+      outputDir: OUTPUT_DIR,
+      limit: LIMIT,
+      since: SINCE ? new Date(SINCE) : undefined,
+      until: UNTIL ? new Date(UNTIL) : undefined,
+      downloadMedia: !NO_MEDIA,
+      onProgress: (current, total, msg) => {
+        process.stdout.write(`\r${msg} (${current}/${total})`);
+      },
+      onSession: (session) => {
+        // Save session for future use
+        fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+        fs.writeFileSync(SESSION_FILE, session);
+        console.log('\nSession saved to', SESSION_FILE);
+      },
+    });
+
+    console.log('\n');
+    console.log('=========================');
+    console.log(`Exported ${result.posts.length} posts from "${result.channelMeta.title}"`);
+    console.log(`Output: ${OUTPUT_DIR}`);
+
+    // Output session string if new
+    if (result.session && result.session !== savedSession) {
+      console.log('\nNew session string (save to TELEGRAM_SESSION):');
+      console.log(result.session);
+    }
+  } catch (error) {
+    console.error('\nError:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/dist/index.d.mts

@@ -142,4 +142,78 @@ declare function translateTitle(title: string, options: TranslateOptions): Promi
  */
 declare function generateEnglishSlug(title: string): string;
 
-export { type AnalyticsConfig, type GoalName, type GoalParams, type GroupedPost, type ParsePostOptions, type Post, type TranslateOptions, categorizePost, cleanContent, configureAnalytics, deduplicatePosts, extractAttachments, extractExcerpt, extractTitle, generateEnglishSlug, generateSlug, groupPosts, parsePost, trackBookAppointment, trackGoal, trackLearnMore, trackServiceClick, trackTelegramClick, translateContent, translateTitle };
+/**
+ * Telegram channel export utilities using gramjs (MTProto)
+ */
+
+interface TelegramExportOptions {
+    /** Telegram API ID from https://my.telegram.org */
+    apiId: number;
+    /** Telegram API Hash from https://my.telegram.org */
+    apiHash: string;
+    /** Session string (for re-authentication). If empty, will prompt for login */
+    session?: string;
+    /** Target channel username, link or ID */
+    target: string;
+    /** Output directory for exported data */
+    outputDir: string;
+    /** Maximum number of posts to export (0 = all) */
+    limit?: number;
+    /** Only export posts since this date */
+    since?: Date;
+    /** Only export posts until this date */
+    until?: Date;
+    /** Download media files */
+    downloadMedia?: boolean;
+    /** Number of concurrent media downloads */
+    mediaWorkers?: number;
+    /** Callback for progress updates */
+    onProgress?: (current: number, total: number, message: string) => void;
+    /** Callback to get phone number for login */
+    onPhoneNumber?: () => Promise<string>;
+    /** Callback to get verification code */
+    onCode?: () => Promise<string>;
+    /** Callback to get 2FA password */
+    onPassword?: () => Promise<string>;
+    /** Callback when session string is generated (save this for future use) */
+    onSession?: (session: string) => void;
+}
+interface ExportedPost {
+    msgId: number;
+    date: Date;
+    content: string;
+    hasMedia: boolean;
+    mediaFiles: string[];
+    views?: number;
+    forwards?: number;
+    link: string;
+    channelUsername: string;
+    channelTitle: string;
+}
+interface ExportResult {
+    channelMeta: {
+        id: number;
+        username: string;
+        title: string;
+        description?: string;
+        participantsCount?: number;
+    };
+    posts: ExportedPost[];
+    session: string;
+}
+/**
+ * Export messages from a Telegram channel
+ */
+declare function exportTelegramChannel(options: TelegramExportOptions): Promise<ExportResult>;
+/**
+ * Format a post as markdown with YAML frontmatter
+ */
+declare function formatPostMarkdown(post: ExportedPost): string;
+/**
+ * Resume export from a saved session
+ */
+declare function resumeExport(options: Omit<TelegramExportOptions, 'onPhoneNumber' | 'onCode' | 'onPassword'> & {
+    session: string;
+}): Promise<ExportResult>;
+
+export { type AnalyticsConfig, type ExportResult, type ExportedPost, type GoalName, type GoalParams, type GroupedPost, type ParsePostOptions, type Post, type TelegramExportOptions, type TranslateOptions, categorizePost, cleanContent, configureAnalytics, deduplicatePosts, exportTelegramChannel, extractAttachments, extractExcerpt, extractTitle, formatPostMarkdown, generateEnglishSlug, generateSlug, groupPosts, parsePost, resumeExport, trackBookAppointment, trackGoal, trackLearnMore, trackServiceClick, trackTelegramClick, translateContent, translateTitle };

package/dist/index.d.ts

@@ -142,4 +142,78 @@ declare function translateTitle(title: string, options: TranslateOptions): Promi
  */
 declare function generateEnglishSlug(title: string): string;
 
-export { type AnalyticsConfig, type GoalName, type GoalParams, type GroupedPost, type ParsePostOptions, type Post, type TranslateOptions, categorizePost, cleanContent, configureAnalytics, deduplicatePosts, extractAttachments, extractExcerpt, extractTitle, generateEnglishSlug, generateSlug, groupPosts, parsePost, trackBookAppointment, trackGoal, trackLearnMore, trackServiceClick, trackTelegramClick, translateContent, translateTitle };
+/**
+ * Telegram channel export utilities using gramjs (MTProto)
+ */
+
+interface TelegramExportOptions {
+    /** Telegram API ID from https://my.telegram.org */
+    apiId: number;
+    /** Telegram API Hash from https://my.telegram.org */
+    apiHash: string;
+    /** Session string (for re-authentication). If empty, will prompt for login */
+    session?: string;
+    /** Target channel username, link or ID */
+    target: string;
+    /** Output directory for exported data */
+    outputDir: string;
+    /** Maximum number of posts to export (0 = all) */
+    limit?: number;
+    /** Only export posts since this date */
+    since?: Date;
+    /** Only export posts until this date */
+    until?: Date;
+    /** Download media files */
+    downloadMedia?: boolean;
+    /** Number of concurrent media downloads */
+    mediaWorkers?: number;
+    /** Callback for progress updates */
+    onProgress?: (current: number, total: number, message: string) => void;
+    /** Callback to get phone number for login */
+    onPhoneNumber?: () => Promise<string>;
+    /** Callback to get verification code */
+    onCode?: () => Promise<string>;
+    /** Callback to get 2FA password */
+    onPassword?: () => Promise<string>;
+    /** Callback when session string is generated (save this for future use) */
+    onSession?: (session: string) => void;
+}
+interface ExportedPost {
+    msgId: number;
+    date: Date;
+    content: string;
+    hasMedia: boolean;
+    mediaFiles: string[];
+    views?: number;
+    forwards?: number;
+    link: string;
+    channelUsername: string;
+    channelTitle: string;
+}
+interface ExportResult {
+    channelMeta: {
+        id: number;
+        username: string;
+        title: string;
+        description?: string;
+        participantsCount?: number;
+    };
+    posts: ExportedPost[];
+    session: string;
+}
+/**
+ * Export messages from a Telegram channel
+ */
+declare function exportTelegramChannel(options: TelegramExportOptions): Promise<ExportResult>;
+/**
+ * Format a post as markdown with YAML frontmatter
+ */
+declare function formatPostMarkdown(post: ExportedPost): string;
+/**
+ * Resume export from a saved session
+ */
+declare function resumeExport(options: Omit<TelegramExportOptions, 'onPhoneNumber' | 'onCode' | 'onPassword'> & {
+    session: string;
+}): Promise<ExportResult>;
+
+export { type AnalyticsConfig, type ExportResult, type ExportedPost, type GoalName, type GoalParams, type GroupedPost, type ParsePostOptions, type Post, type TelegramExportOptions, type TranslateOptions, categorizePost, cleanContent, configureAnalytics, deduplicatePosts, exportTelegramChannel, extractAttachments, extractExcerpt, extractTitle, formatPostMarkdown, generateEnglishSlug, generateSlug, groupPosts, parsePost, resumeExport, trackBookAppointment, trackGoal, trackLearnMore, trackServiceClick, trackTelegramClick, translateContent, translateTitle };

package/dist/index.js

@@ -34,13 +34,16 @@ __export(index_exports, {
   cleanContent: () => cleanContent,
   configureAnalytics: () => configureAnalytics,
   deduplicatePosts: () => deduplicatePosts,
+  exportTelegramChannel: () => exportTelegramChannel,
   extractAttachments: () => extractAttachments,
   extractExcerpt: () => extractExcerpt,
   extractTitle: () => extractTitle,
+  formatPostMarkdown: () => formatPostMarkdown,
   generateEnglishSlug: () => generateEnglishSlug,
   generateSlug: () => generateSlug,
   groupPosts: () => groupPosts,
   parsePost: () => parsePost,
+  resumeExport: () => resumeExport,
   trackBookAppointment: () => trackBookAppointment,
   trackGoal: () => trackGoal,
   trackLearnMore: () => trackLearnMore,
@@ -351,19 +354,254 @@ async function translateTitle(title, options) {
 function generateEnglishSlug(title) {
   return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 60);
 }
+
+// src/telegram.ts
+var import_telegram = require("telegram");
+var import_sessions = require("telegram/sessions");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var readline = __toESM(require("readline"));
+async function defaultReadline(prompt) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+async function exportTelegramChannel(options) {
+  const {
+    apiId,
+    apiHash,
+    session = "",
+    target,
+    outputDir,
+    limit = 0,
+    since,
+    until,
+    downloadMedia = true,
+    mediaWorkers = 3,
+    onProgress,
+    onPhoneNumber = () => defaultReadline("Phone number: "),
+    onCode = () => defaultReadline("Verification code: "),
+    onPassword = () => defaultReadline("2FA Password: "),
+    onSession
+  } = options;
+  const postsDir = path.join(outputDir, "posts");
+  const mediaDir = path.join(outputDir, "media");
+  fs.mkdirSync(postsDir, { recursive: true });
+  fs.mkdirSync(mediaDir, { recursive: true });
+  const stringSession = new import_sessions.StringSession(session);
+  const client = new import_telegram.TelegramClient(stringSession, apiId, apiHash, {
+    connectionRetries: 5
+  });
+  await client.start({
+    phoneNumber: onPhoneNumber,
+    phoneCode: onCode,
+    password: onPassword,
+    onError: (err) => console.error("Auth error:", err)
+  });
+  const newSession = client.session.save();
+  if (onSession) {
+    onSession(newSession);
+  }
+  const entity = await client.getEntity(target);
+  if (!(entity instanceof import_telegram.Api.Channel)) {
+    throw new Error(`Target "${target}" is not a channel`);
+  }
+  const channelMeta = {
+    id: entity.id.toJSNumber(),
+    username: entity.username || "",
+    title: entity.title,
+    description: void 0,
+    participantsCount: void 0
+  };
+  try {
+    const fullChannel = await client.invoke(
+      new import_telegram.Api.channels.GetFullChannel({ channel: entity })
+    );
+    if (fullChannel.fullChat instanceof import_telegram.Api.ChannelFull) {
+      channelMeta.description = fullChannel.fullChat.about;
+      channelMeta.participantsCount = fullChannel.fullChat.participantsCount;
+    }
+  } catch (e) {
+  }
+  fs.writeFileSync(
+    path.join(outputDir, "channel_meta.json"),
+    JSON.stringify(channelMeta, null, 2)
+  );
+  const posts = [];
+  let processedCount = 0;
+  const iterParams = {
+    entity,
+    reverse: true
+    // Oldest first
+  };
+  if (limit > 0) {
+    iterParams.limit = limit;
+  }
+  if (since) {
+    iterParams.offsetDate = Math.floor(since.getTime() / 1e3);
+  }
+  let totalMessages = limit || 0;
+  if (!limit) {
+    try {
+      const history = await client.invoke(
+        new import_telegram.Api.messages.GetHistory({
+          peer: entity,
+          limit: 1,
+          offsetId: 0,
+          offsetDate: 0,
+          addOffset: 0,
+          maxId: 0,
+          minId: 0,
+          hash: 0n
+        })
+      );
+      if ("count" in history) {
+        totalMessages = history.count;
+      }
+    } catch (e) {
+    }
+  }
+  for await (const message of client.iterMessages(entity, iterParams)) {
+    if (until && message.date && message.date * 1e3 > until.getTime()) {
+      continue;
+    }
+    if (since && message.date && message.date * 1e3 < since.getTime()) {
+      break;
+    }
+    processedCount++;
+    if (onProgress) {
+      onProgress(processedCount, totalMessages, `Processing message ${message.id}`);
+    }
+    const msgId = message.id;
+    const paddedId = String(msgId).padStart(6, "0");
+    const postMediaDir = path.join(mediaDir, paddedId);
+    const mediaFiles = [];
+    if (downloadMedia && message.media) {
+      fs.mkdirSync(postMediaDir, { recursive: true });
+      try {
+        const buffer = await client.downloadMedia(message.media, {});
+        if (buffer) {
+          let ext = ".bin";
+          if (message.media instanceof import_telegram.Api.MessageMediaPhoto) {
+            ext = ".jpg";
+          } else if (message.media instanceof import_telegram.Api.MessageMediaDocument) {
+            const doc = message.media.document;
+            if (doc instanceof import_telegram.Api.Document) {
+              const mimeExt = doc.mimeType?.split("/")[1];
+              if (mimeExt) {
+                ext = "." + mimeExt.replace("jpeg", "jpg");
+              }
+              for (const attr of doc.attributes) {
+                if (attr instanceof import_telegram.Api.DocumentAttributeVideo) {
+                  ext = ".mp4";
+                }
+                if (attr instanceof import_telegram.Api.DocumentAttributeFilename) {
+                  ext = path.extname(attr.fileName) || ext;
+                }
+              }
+            }
+          }
+          const mediaFileName = `media${ext}`;
+          const mediaPath = path.join(postMediaDir, mediaFileName);
+          fs.writeFileSync(mediaPath, buffer);
+          mediaFiles.push(`media/${paddedId}/${mediaFileName}`);
+        }
+      } catch (e) {
+        console.error(`Error downloading media for message ${msgId}:`, e);
+      }
+    }
+    const content = message.message || "";
+    const link = channelMeta.username ? `https://t.me/${channelMeta.username}/${msgId}` : "";
+    const post = {
+      msgId,
+      date: new Date(message.date * 1e3),
+      content,
+      hasMedia: mediaFiles.length > 0 || !!message.media,
+      mediaFiles,
+      views: message.views,
+      forwards: message.forwards,
+      link,
+      channelUsername: channelMeta.username,
+      channelTitle: channelMeta.title
+    };
+    posts.push(post);
+    const markdown = formatPostMarkdown(post);
+    fs.writeFileSync(path.join(postsDir, `${paddedId}.md`), markdown);
+  }
+  const ndjsonPath = path.join(outputDir, "posts.ndjson");
+  const ndjsonContent = posts.map((p) => JSON.stringify(p)).join("\n");
+  fs.writeFileSync(ndjsonPath, ndjsonContent);
+  await client.disconnect();
+  return {
+    channelMeta,
+    posts,
+    session: newSession
+  };
+}
+function formatPostMarkdown(post) {
+  const dateStr = post.date.toISOString();
+  const dateOnly = dateStr.split("T")[0];
+  let frontmatter = `---
+msg_id: ${post.msgId}
+date: ${dateStr}
+channel_username: "${post.channelUsername}"
+channel_title: "${post.channelTitle.replace(/"/g, '\\"')}"
+link: "${post.link}"
+has_media: ${post.hasMedia}`;
+  if (post.views !== void 0) {
+    frontmatter += `
+views: ${post.views}`;
+  }
+  if (post.forwards !== void 0) {
+    frontmatter += `
+forwards: ${post.forwards}`;
+  }
+  frontmatter += "\n---\n\n";
+  let body = post.content || "";
+  if (post.mediaFiles.length > 0) {
+    body += "\n\n## Attachments\n\n";
+    for (const file of post.mediaFiles) {
+      const ext = path.extname(file).toLowerCase();
+      if ([".jpg", ".jpeg", ".png", ".gif", ".webp"].includes(ext)) {
+        body += `![](${file})
+`;
+      } else {
+        body += `- ${file}
+`;
+      }
+    }
+  }
+  return frontmatter + body;
+}
+async function resumeExport(options) {
+  if (!options.session) {
+    throw new Error("Session string is required for resumeExport");
+  }
+  return exportTelegramChannel(options);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   categorizePost,
   cleanContent,
   configureAnalytics,
   deduplicatePosts,
+  exportTelegramChannel,
   extractAttachments,
   extractExcerpt,
   extractTitle,
+  formatPostMarkdown,
   generateEnglishSlug,
   generateSlug,
   groupPosts,
   parsePost,
+  resumeExport,
   trackBookAppointment,
   trackGoal,
   trackLearnMore,

package/dist/index.mjs

@@ -298,18 +298,253 @@ async function translateTitle(title, options) {
 function generateEnglishSlug(title) {
   return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 60);
 }
+
+// src/telegram.ts
+import { TelegramClient, Api } from "telegram";
+import { StringSession } from "telegram/sessions";
+import * as fs from "fs";
+import * as path from "path";
+import * as readline from "readline";
+async function defaultReadline(prompt) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+async function exportTelegramChannel(options) {
+  const {
+    apiId,
+    apiHash,
+    session = "",
+    target,
+    outputDir,
+    limit = 0,
+    since,
+    until,
+    downloadMedia = true,
+    mediaWorkers = 3,
+    onProgress,
+    onPhoneNumber = () => defaultReadline("Phone number: "),
+    onCode = () => defaultReadline("Verification code: "),
+    onPassword = () => defaultReadline("2FA Password: "),
+    onSession
+  } = options;
+  const postsDir = path.join(outputDir, "posts");
+  const mediaDir = path.join(outputDir, "media");
+  fs.mkdirSync(postsDir, { recursive: true });
+  fs.mkdirSync(mediaDir, { recursive: true });
+  const stringSession = new StringSession(session);
+  const client = new TelegramClient(stringSession, apiId, apiHash, {
+    connectionRetries: 5
+  });
+  await client.start({
+    phoneNumber: onPhoneNumber,
+    phoneCode: onCode,
+    password: onPassword,
+    onError: (err) => console.error("Auth error:", err)
+  });
+  const newSession = client.session.save();
+  if (onSession) {
+    onSession(newSession);
+  }
+  const entity = await client.getEntity(target);
+  if (!(entity instanceof Api.Channel)) {
+    throw new Error(`Target "${target}" is not a channel`);
+  }
+  const channelMeta = {
+    id: entity.id.toJSNumber(),
+    username: entity.username || "",
+    title: entity.title,
+    description: void 0,
+    participantsCount: void 0
+  };
+  try {
+    const fullChannel = await client.invoke(
+      new Api.channels.GetFullChannel({ channel: entity })
+    );
+    if (fullChannel.fullChat instanceof Api.ChannelFull) {
+      channelMeta.description = fullChannel.fullChat.about;
+      channelMeta.participantsCount = fullChannel.fullChat.participantsCount;
+    }
+  } catch (e) {
+  }
+  fs.writeFileSync(
+    path.join(outputDir, "channel_meta.json"),
+    JSON.stringify(channelMeta, null, 2)
+  );
+  const posts = [];
+  let processedCount = 0;
+  const iterParams = {
+    entity,
+    reverse: true
+    // Oldest first
+  };
+  if (limit > 0) {
+    iterParams.limit = limit;
+  }
+  if (since) {
+    iterParams.offsetDate = Math.floor(since.getTime() / 1e3);
+  }
+  let totalMessages = limit || 0;
+  if (!limit) {
+    try {
+      const history = await client.invoke(
+        new Api.messages.GetHistory({
+          peer: entity,
+          limit: 1,
+          offsetId: 0,
+          offsetDate: 0,
+          addOffset: 0,
+          maxId: 0,
+          minId: 0,
+          hash: 0n
+        })
+      );
+      if ("count" in history) {
+        totalMessages = history.count;
+      }
+    } catch (e) {
+    }
+  }
+  for await (const message of client.iterMessages(entity, iterParams)) {
+    if (until && message.date && message.date * 1e3 > until.getTime()) {
+      continue;
+    }
+    if (since && message.date && message.date * 1e3 < since.getTime()) {
+      break;
+    }
+    processedCount++;
+    if (onProgress) {
+      onProgress(processedCount, totalMessages, `Processing message ${message.id}`);
+    }
+    const msgId = message.id;
+    const paddedId = String(msgId).padStart(6, "0");
+    const postMediaDir = path.join(mediaDir, paddedId);
+    const mediaFiles = [];
+    if (downloadMedia && message.media) {
+      fs.mkdirSync(postMediaDir, { recursive: true });
+      try {
+        const buffer = await client.downloadMedia(message.media, {});
+        if (buffer) {
+          let ext = ".bin";
+          if (message.media instanceof Api.MessageMediaPhoto) {
+            ext = ".jpg";
+          } else if (message.media instanceof Api.MessageMediaDocument) {
+            const doc = message.media.document;
+            if (doc instanceof Api.Document) {
+              const mimeExt = doc.mimeType?.split("/")[1];
+              if (mimeExt) {
+                ext = "." + mimeExt.replace("jpeg", "jpg");
+              }
+              for (const attr of doc.attributes) {
+                if (attr instanceof Api.DocumentAttributeVideo) {
+                  ext = ".mp4";
+                }
+                if (attr instanceof Api.DocumentAttributeFilename) {
+                  ext = path.extname(attr.fileName) || ext;
+                }
+              }
+            }
+          }
+          const mediaFileName = `media${ext}`;
+          const mediaPath = path.join(postMediaDir, mediaFileName);
+          fs.writeFileSync(mediaPath, buffer);
+          mediaFiles.push(`media/${paddedId}/${mediaFileName}`);
+        }
+      } catch (e) {
+        console.error(`Error downloading media for message ${msgId}:`, e);
+      }
+    }
+    const content = message.message || "";
+    const link = channelMeta.username ? `https://t.me/${channelMeta.username}/${msgId}` : "";
+    const post = {
+      msgId,
+      date: new Date(message.date * 1e3),
+      content,
+      hasMedia: mediaFiles.length > 0 || !!message.media,
+      mediaFiles,
+      views: message.views,
+      forwards: message.forwards,
+      link,
+      channelUsername: channelMeta.username,
+      channelTitle: channelMeta.title
+    };
+    posts.push(post);
+    const markdown = formatPostMarkdown(post);
+    fs.writeFileSync(path.join(postsDir, `${paddedId}.md`), markdown);
+  }
+  const ndjsonPath = path.join(outputDir, "posts.ndjson");
+  const ndjsonContent = posts.map((p) => JSON.stringify(p)).join("\n");
+  fs.writeFileSync(ndjsonPath, ndjsonContent);
+  await client.disconnect();
+  return {
+    channelMeta,
+    posts,
+    session: newSession
+  };
+}
+function formatPostMarkdown(post) {
+  const dateStr = post.date.toISOString();
+  const dateOnly = dateStr.split("T")[0];
+  let frontmatter = `---
+msg_id: ${post.msgId}
+date: ${dateStr}
+channel_username: "${post.channelUsername}"
+channel_title: "${post.channelTitle.replace(/"/g, '\\"')}"
+link: "${post.link}"
+has_media: ${post.hasMedia}`;
+  if (post.views !== void 0) {
+    frontmatter += `
+views: ${post.views}`;
+  }
+  if (post.forwards !== void 0) {
+    frontmatter += `
+forwards: ${post.forwards}`;
+  }
+  frontmatter += "\n---\n\n";
+  let body = post.content || "";
+  if (post.mediaFiles.length > 0) {
+    body += "\n\n## Attachments\n\n";
+    for (const file of post.mediaFiles) {
+      const ext = path.extname(file).toLowerCase();
+      if ([".jpg", ".jpeg", ".png", ".gif", ".webp"].includes(ext)) {
+        body += `![](${file})
+`;
+      } else {
+        body += `- ${file}
+`;
+      }
+    }
+  }
+  return frontmatter + body;
+}
+async function resumeExport(options) {
+  if (!options.session) {
+    throw new Error("Session string is required for resumeExport");
+  }
+  return exportTelegramChannel(options);
+}
 export {
   categorizePost,
   cleanContent,
   configureAnalytics,
   deduplicatePosts,
+  exportTelegramChannel,
   extractAttachments,
   extractExcerpt,
   extractTitle,
+  formatPostMarkdown,
   generateEnglishSlug,
   generateSlug,
   groupPosts,
   parsePost,
+  resumeExport,
   trackBookAppointment,
   trackGoal,
   trackLearnMore,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koztv-blog-tools",
-  "version": "1.0.6",
+  "version": "1.1.1",
   "description": "Shared utilities for Telegram-based blog sites",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -12,8 +12,12 @@
       "require": "./dist/index.js"
     }
   },
+  "bin": {
+    "tg-export": "./bin/export-telegram.js"
+  },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts --clean",
@@ -23,23 +27,31 @@
     "blog",
     "telegram",
     "markdown",
-    "static-site"
+    "static-site",
+    "telegram-export",
+    "mtproto"
   ],
   "author": "Koz TV",
   "license": "MIT",
   "devDependencies": {
+    "@types/node": "^20.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "gray-matter": "^4.0.3"
+    "gray-matter": "^4.0.3",
+    "telegram": "^2.26.22"
   },
   "peerDependencies": {
-    "gray-matter": "^4.0.0"
+    "gray-matter": "^4.0.0",
+    "telegram": "^2.0.0"
   },
   "peerDependenciesMeta": {
     "gray-matter": {
       "optional": true
+    },
+    "telegram": {
+      "optional": true
     }
   }
 }