@imadtg/tgsm 0.0.1

package/dist/index.js

@@ -0,0 +1,1119 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createInterface } from "readline/promises";
+import process2 from "process";
+import { Command } from "commander";
+
+// ../core/src/errors.ts
+var TgsmError = class extends Error {
+  code;
+  retryable;
+  suggestion;
+  constructor(shape) {
+    super(shape.message);
+    this.name = "TgsmError";
+    this.code = shape.code;
+    this.retryable = shape.retryable;
+    this.suggestion = shape.suggestion;
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      retryable: this.retryable,
+      suggestion: this.suggestion
+    };
+  }
+};
+
+// ../core/src/paths.ts
+import os from "os";
+import path from "path";
+import { mkdir } from "fs/promises";
+function getHomeDir(homeDir) {
+  return homeDir ?? process.env.TGSM_HOME ?? path.join(os.homedir(), ".tgsm");
+}
+function getAccountName(account) {
+  return account ?? "default";
+}
+function getAccountDir(options = {}) {
+  return path.join(getHomeDir(options.homeDir), getAccountName(options.account));
+}
+function getCachePath(options = {}) {
+  return path.join(getAccountDir(options), "cache.json");
+}
+async function ensureAccountDir(options = {}) {
+  const accountDir = getAccountDir(options);
+  await mkdir(accountDir, { recursive: true });
+  return accountDir;
+}
+
+// ../core/src/cache.ts
+import { readFile, writeFile } from "fs/promises";
+var EMPTY_CACHE = {
+  version: 1,
+  backend: "fixture",
+  account: null,
+  synced_at: null,
+  dialogs: [],
+  messages: []
+};
+async function readCache(cachePath) {
+  try {
+    const raw = await readFile(cachePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return EMPTY_CACHE;
+    }
+    throw error;
+  }
+}
+async function writeCache(cachePath, snapshot) {
+  const state = {
+    version: 1,
+    backend: snapshot.backend,
+    account: snapshot.account,
+    synced_at: snapshot.synced_at,
+    dialogs: snapshot.dialogs,
+    messages: snapshot.messages
+  };
+  await writeFile(cachePath, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+
+// ../core/src/fixture.ts
+import { readFile as readFile2 } from "fs/promises";
+var FixtureSource = class {
+  constructor(fixturePath) {
+    this.fixturePath = fixturePath;
+  }
+  backend = "fixture";
+  async sync() {
+    const raw = await readFile2(this.fixturePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.dialogs) || !Array.isArray(parsed.messages)) {
+      throw new TgsmError({
+        code: "INVALID_FIXTURE",
+        message: `Fixture at ${this.fixturePath} is missing dialogs/messages arrays`,
+        retryable: false
+      });
+    }
+    const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      backend: this.backend,
+      account: parsed.account ?? {
+        id: "fixture",
+        display_name: "Fixture Account"
+      },
+      dialogs: parsed.dialogs.map((dialog) => ({
+        ...dialog,
+        last_synced_at: syncedAt
+      })),
+      messages: parsed.messages,
+      synced_at: syncedAt
+    };
+  }
+  async authStatus() {
+    return {
+      authenticated: true,
+      user: {
+        id: "fixture",
+        display_name: "Fixture Account"
+      }
+    };
+  }
+};
+
+// ../core/src/service.ts
+import path2 from "path";
+var DEFAULT_CHRONOLOGY_LIMIT = 20;
+var TgsmService = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async authLogin(input) {
+    if (!this.options.source?.authLogin) {
+      throw new TgsmError({
+        code: "AUTH_UNSUPPORTED",
+        message: "This backend does not support auth login.",
+        retryable: false
+      });
+    }
+    return this.options.source.authLogin(this.accountDir(), input);
+  }
+  async authStatus() {
+    if (!this.options.source?.authStatus) {
+      return {
+        authenticated: false,
+        user: null
+      };
+    }
+    return this.options.source.authStatus(this.accountDir());
+  }
+  async sync() {
+    if (!this.options.source) {
+      throw new TgsmError({
+        code: "SYNC_UNAVAILABLE",
+        message: "No source backend configured for sync.",
+        retryable: false
+      });
+    }
+    const snapshot = await this.options.source.sync(this.accountDir());
+    await writeCache(this.options.cachePath, snapshot);
+    return {
+      backend: snapshot.backend,
+      synced_at: snapshot.synced_at,
+      synced_dialogs: snapshot.dialogs.length,
+      synced_messages: snapshot.messages.length
+    };
+  }
+  async listSavedDialogs() {
+    const cache = await this.loadCache();
+    return [...cache.dialogs].sort((a, b) => {
+      const left = a.last_synced_at ?? "";
+      const right = b.last_synced_at ?? "";
+      return right.localeCompare(left) || a.saved_peer_id.localeCompare(b.saved_peer_id);
+    });
+  }
+  async listMessages(options = {}) {
+    const cache = await this.loadCache();
+    const indexes = this.buildIndexes(cache);
+    const dialogId = options.dialog ?? null;
+    if (dialogId && !indexes.dialogsById.has(dialogId)) {
+      throw new TgsmError({
+        code: "DIALOG_NOT_FOUND",
+        message: `Saved dialog ${dialogId} was not found.`,
+        retryable: false,
+        suggestion: "Run `tgsm saved-dialogs list` to inspect available dialogs."
+      });
+    }
+    const scoped = dialogId ? indexes.messagesByDialog.get(dialogId) ?? [] : cache.messages;
+    const filtered = options.search ? scoped.filter((message) => matchesSearch(message, options.search)) : scoped;
+    const sorted = [...filtered].sort(compareByDateDesc);
+    const limit = Math.max(1, options.limit ?? 20);
+    const offset = decodeCursor(options.cursor);
+    const slice = sorted.slice(offset, offset + limit);
+    return {
+      items: slice.map((message) => this.toMessageListItem(message, indexes)),
+      scope: dialogId ? "saved_dialog" : "all_saved_dialogs",
+      saved_peer_id: dialogId,
+      next_cursor: offset + limit < sorted.length ? encodeCursor(offset + limit) : null,
+      result_count: filtered.length
+    };
+  }
+  async getMessage(messageId, options = {}) {
+    const cache = await this.loadCache();
+    const indexes = this.buildIndexes(cache);
+    const target = this.findMessage(indexes, messageId, options.dialog);
+    return this.buildContextBundle(target, indexes);
+  }
+  async getContext(messageId, options = {}) {
+    return this.getMessage(messageId, options);
+  }
+  async inspectThread(messageId, options = {}) {
+    const cache = await this.loadCache();
+    const indexes = this.buildIndexes(cache);
+    const target = this.findMessage(indexes, messageId, options.dialog);
+    const root = this.findThreadRoot(target, indexes);
+    const dialog = indexes.dialogsById.get(root.saved_peer_id);
+    if (!dialog) {
+      throw new TgsmError({
+        code: "DIALOG_NOT_FOUND",
+        message: `Saved dialog ${root.saved_peer_id} was not found.`,
+        retryable: false
+      });
+    }
+    return {
+      dialog,
+      root: this.toEnvelope(root, indexes),
+      nodes: [this.buildThreadNode(root, indexes, 0)]
+    };
+  }
+  accountDir() {
+    return path2.dirname(this.options.cachePath);
+  }
+  async loadCache() {
+    return readCache(this.options.cachePath);
+  }
+  buildIndexes(cache) {
+    const dialogsById = new Map(
+      cache.dialogs.map((dialog) => [dialog.saved_peer_id, dialog])
+    );
+    const messagesByKey = /* @__PURE__ */ new Map();
+    const messagesByGlobalId = /* @__PURE__ */ new Map();
+    const messagesByDialog = /* @__PURE__ */ new Map();
+    const backreplyIndex = /* @__PURE__ */ new Map();
+    for (const message of cache.messages) {
+      messagesByKey.set(makeMessageKey(message.saved_peer_id, message.message_id), message);
+      const existingGlobal = messagesByGlobalId.get(message.message_id) ?? [];
+      existingGlobal.push(message);
+      messagesByGlobalId.set(message.message_id, existingGlobal);
+      const dialogMessages = messagesByDialog.get(message.saved_peer_id) ?? [];
+      dialogMessages.push(message);
+      messagesByDialog.set(message.saved_peer_id, dialogMessages);
+      if (message.reply_to_message_id !== null) {
+        const replyDialog = message.reply_to_saved_peer_id ?? message.saved_peer_id;
+        const key = makeMessageKey(replyDialog, message.reply_to_message_id);
+        const children = backreplyIndex.get(key) ?? [];
+        children.push(message);
+        backreplyIndex.set(key, children);
+      }
+    }
+    for (const records of messagesByDialog.values()) {
+      records.sort(compareByDateAsc);
+    }
+    for (const records of backreplyIndex.values()) {
+      records.sort(compareByDateAsc);
+    }
+    return {
+      dialogsById,
+      messagesByKey,
+      messagesByGlobalId,
+      messagesByDialog,
+      backreplyIndex
+    };
+  }
+  findMessage(indexes, messageId, dialog) {
+    if (dialog) {
+      const scoped = indexes.messagesByKey.get(makeMessageKey(dialog, messageId));
+      if (!scoped) {
+        throw new TgsmError({
+          code: "MESSAGE_NOT_FOUND",
+          message: `Message ${messageId} was not found in dialog ${dialog}.`,
+          retryable: false,
+          suggestion: "Run `tgsm messages list --dialog <saved_peer_id>` to inspect the dialog."
+        });
+      }
+      return scoped;
+    }
+    const candidates = indexes.messagesByGlobalId.get(messageId) ?? [];
+    if (candidates.length === 0) {
+      throw new TgsmError({
+        code: "MESSAGE_NOT_FOUND",
+        message: `Message ${messageId} was not found in the selected scope.`,
+        retryable: false,
+        suggestion: "Run `tgsm messages list` or narrow the dialog scope."
+      });
+    }
+    if (candidates.length > 1) {
+      throw new TgsmError({
+        code: "AMBIGUOUS_MESSAGE_ID",
+        message: `Message ID ${messageId} exists in multiple saved dialogs.`,
+        retryable: false,
+        suggestion: "Pass `--dialog <saved_peer_id>` to disambiguate."
+      });
+    }
+    return candidates[0];
+  }
+  buildContextBundle(target, indexes) {
+    const dialog = indexes.dialogsById.get(target.saved_peer_id);
+    if (!dialog) {
+      throw new TgsmError({
+        code: "DIALOG_NOT_FOUND",
+        message: `Saved dialog ${target.saved_peer_id} was not found.`,
+        retryable: false
+      });
+    }
+    const chronological = indexes.messagesByDialog.get(target.saved_peer_id) ?? [];
+    const targetIndex = chronological.findIndex(
+      (message) => message.message_id === target.message_id && message.saved_peer_id === target.saved_peer_id
+    );
+    const maxEachSide = Math.floor(DEFAULT_CHRONOLOGY_LIMIT / 2);
+    const before = chronological.slice(Math.max(0, targetIndex - maxEachSide), targetIndex);
+    const after = chronological.slice(targetIndex + 1, targetIndex + 1 + maxEachSide);
+    const replyParent = target.reply_to_message_id ? indexes.messagesByKey.get(
+      makeMessageKey(target.reply_to_saved_peer_id ?? target.saved_peer_id, target.reply_to_message_id)
+    ) ?? null : null;
+    const directBackreplies = indexes.backreplyIndex.get(makeMessageKey(target.saved_peer_id, target.message_id)) ?? [];
+    const notes = [];
+    if (target.reply_to_message_id !== null && !replyParent) {
+      notes.push(`Reply target #${target.reply_to_message_id} could not be resolved in cache.`);
+    }
+    const contexts = /* @__PURE__ */ new Map();
+    const pushContext = (message, role) => {
+      const key = makeMessageKey(message.saved_peer_id, message.message_id);
+      const existing = contexts.get(key);
+      if (existing) {
+        if (!existing.context_roles.includes(role)) {
+          existing.context_roles.push(role);
+        }
+        return;
+      }
+      contexts.set(key, {
+        message: this.toEnvelope(message, indexes),
+        context_roles: [role]
+      });
+    };
+    for (const message of before) pushContext(message, "chronology_before");
+    if (replyParent) pushContext(replyParent, "reply_parent");
+    pushContext(target, "target");
+    for (const message of directBackreplies) pushContext(message, "backreply_child");
+    for (const message of after) pushContext(message, "chronology_after");
+    const contextMessages = [...contexts.values()].sort((left, right) => {
+      const rank = (roles) => {
+        if (roles.includes("chronology_before")) return 1;
+        if (roles.includes("reply_parent")) return 2;
+        if (roles.includes("target")) return 3;
+        if (roles.includes("backreply_child")) return 4;
+        return 5;
+      };
+      return rank(left.context_roles) - rank(right.context_roles) || left.message.date.localeCompare(right.message.date) || left.message.message_id - right.message.message_id;
+    });
+    return {
+      target: this.toEnvelope(target, indexes),
+      dialog,
+      context_messages: contextMessages,
+      window: {
+        chronology_total_limit: DEFAULT_CHRONOLOGY_LIMIT,
+        chronology_before_count: before.length,
+        chronology_after_count: after.length,
+        direct_reply_ancestor_included: Boolean(replyParent),
+        direct_backreply_count_included: directBackreplies.length
+      },
+      notes
+    };
+  }
+  toMessageListItem(message, indexes) {
+    const dialog = indexes.dialogsById.get(message.saved_peer_id);
+    const directBackreplyCount = indexes.backreplyIndex.get(makeMessageKey(message.saved_peer_id, message.message_id))?.length ?? 0;
+    return {
+      message_id: message.message_id,
+      saved_peer_id: message.saved_peer_id,
+      dialog_title: dialog?.title ?? message.saved_peer_id,
+      date: message.date,
+      text_preview: previewText(message.text),
+      from_self: message.from_self,
+      forwarded: message.forwarded,
+      reply_to_message_id: message.reply_to_message_id,
+      direct_backreply_count: directBackreplyCount,
+      queued_for_delete: message.queued_for_delete
+    };
+  }
+  toEnvelope(message, indexes) {
+    const replyTarget = message.reply_to_message_id !== null ? indexes.messagesByKey.get(
+      makeMessageKey(message.reply_to_saved_peer_id ?? message.saved_peer_id, message.reply_to_message_id)
+    ) ?? null : null;
+    const directBackreplies = indexes.backreplyIndex.get(makeMessageKey(message.saved_peer_id, message.message_id)) ?? [];
+    const reply = message.reply_to_message_id === null ? {
+      exists: false,
+      target: null,
+      status: "resolved"
+    } : {
+      exists: true,
+      target: replyTarget ? this.toMessageRef(replyTarget, "reply_to") : {
+        message_id: message.reply_to_message_id,
+        saved_peer_id: message.reply_to_saved_peer_id ?? message.saved_peer_id,
+        text_preview: "(missing from cache)",
+        date: "",
+        relationship: "reply_to"
+      },
+      status: replyTarget ? "resolved" : "missing"
+    };
+    const backreplies = directBackreplies.map((child) => ({
+      message: this.toMessageRef(child, "backreply"),
+      thread_depth_from_target: 1,
+      subtree_size_hint: this.countDescendants(child, indexes)
+    }));
+    return {
+      message_id: message.message_id,
+      saved_peer_id: message.saved_peer_id,
+      date: message.date,
+      edit_date: message.edit_date,
+      text: message.text,
+      text_preview: previewText(message.text),
+      from_self: message.from_self,
+      forwarded: message.forwarded,
+      forward_origin: message.forward_origin,
+      reply,
+      backreplies,
+      thread: {
+        ancestors_known: this.countAncestors(message, indexes),
+        direct_backreply_count: backreplies.length,
+        descendant_count_hint: this.countDescendants(message, indexes),
+        max_known_depth: this.maxDepth(message, indexes)
+      },
+      links: message.links,
+      media_summary: message.media_summary,
+      queued_for_delete: message.queued_for_delete
+    };
+  }
+  toMessageRef(message, relationship) {
+    return {
+      message_id: message.message_id,
+      saved_peer_id: message.saved_peer_id,
+      text_preview: previewText(message.text),
+      date: message.date,
+      relationship
+    };
+  }
+  findThreadRoot(message, indexes) {
+    let current = message;
+    while (current.reply_to_message_id !== null) {
+      const parent = indexes.messagesByKey.get(
+        makeMessageKey(current.reply_to_saved_peer_id ?? current.saved_peer_id, current.reply_to_message_id)
+      );
+      if (!parent || parent.saved_peer_id !== current.saved_peer_id) {
+        break;
+      }
+      current = parent;
+    }
+    return current;
+  }
+  buildThreadNode(message, indexes, depth) {
+    const children = indexes.backreplyIndex.get(makeMessageKey(message.saved_peer_id, message.message_id)) ?? [];
+    return {
+      message: this.toEnvelope(message, indexes),
+      depth,
+      children: children.map((child) => this.buildThreadNode(child, indexes, depth + 1))
+    };
+  }
+  countAncestors(message, indexes) {
+    let count = 0;
+    let current = message;
+    while (current.reply_to_message_id !== null) {
+      const parent = indexes.messagesByKey.get(
+        makeMessageKey(current.reply_to_saved_peer_id ?? current.saved_peer_id, current.reply_to_message_id)
+      );
+      if (!parent) break;
+      count += 1;
+      current = parent;
+    }
+    return count;
+  }
+  countDescendants(message, indexes) {
+    const children = indexes.backreplyIndex.get(makeMessageKey(message.saved_peer_id, message.message_id)) ?? [];
+    return children.reduce((count, child) => count + 1 + this.countDescendants(child, indexes), 0);
+  }
+  maxDepth(message, indexes) {
+    const children = indexes.backreplyIndex.get(makeMessageKey(message.saved_peer_id, message.message_id)) ?? [];
+    if (children.length === 0) return 0;
+    return 1 + Math.max(...children.map((child) => this.maxDepth(child, indexes)));
+  }
+};
+function makeMessageKey(savedPeerId, messageId) {
+  return `${savedPeerId}:${messageId}`;
+}
+function encodeCursor(offset) {
+  return Buffer.from(String(offset), "utf8").toString("base64url");
+}
+function decodeCursor(cursor) {
+  if (!cursor) return 0;
+  try {
+    const value = Number(Buffer.from(cursor, "base64url").toString("utf8"));
+    return Number.isFinite(value) && value >= 0 ? value : 0;
+  } catch {
+    return 0;
+  }
+}
+function compareByDateAsc(left, right) {
+  return left.date.localeCompare(right.date) || left.message_id - right.message_id;
+}
+function compareByDateDesc(left, right) {
+  return right.date.localeCompare(left.date) || right.message_id - left.message_id;
+}
+function matchesSearch(message, query) {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) return true;
+  return [
+    message.text,
+    message.forward_origin?.title ?? "",
+    message.saved_peer_id
+  ].join("\n").toLowerCase().includes(normalized);
+}
+function previewText(text, limit = 80) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (!normalized) return "(no text)";
+  return normalized.length <= limit ? normalized : `${normalized.slice(0, limit - 1)}\u2026`;
+}
+
+// ../core/src/telegram.ts
+import path3 from "path";
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { TelegramClient, getMarkedPeerId } from "@mtcute/node";
+var TelegramSource = class {
+  backend = "telegram";
+  async authLogin(accountDir, input) {
+    const config = {
+      apiId: input.apiId,
+      apiHash: input.apiHash,
+      phone: input.phone
+    };
+    await saveTelegramConfig(accountDir, config);
+    const client = new TelegramClient({
+      apiId: config.apiId,
+      apiHash: config.apiHash,
+      storage: path3.join(accountDir, "mtcute-session")
+    });
+    try {
+      const user = await client.start({
+        phone: input.phone,
+        code: input.code,
+        password: input.password || void 0
+      });
+      return {
+        authenticated: true,
+        user: {
+          id: String(user.id),
+          display_name: user.displayName
+        }
+      };
+    } catch (error) {
+      throw new TgsmError({
+        code: "AUTH_FAILED",
+        message: error instanceof Error ? error.message : "Telegram auth failed.",
+        retryable: false
+      });
+    } finally {
+    }
+  }
+  async authStatus(accountDir) {
+    const config = await loadTelegramConfig(accountDir);
+    if (!config) {
+      return {
+        authenticated: false,
+        user: null
+      };
+    }
+    const client = new TelegramClient({
+      apiId: config.apiId,
+      apiHash: config.apiHash,
+      storage: path3.join(accountDir, "mtcute-session")
+    });
+    try {
+      await client.start({});
+      const me = await client.getMe();
+      return {
+        authenticated: true,
+        user: {
+          id: String(me.id),
+          display_name: me.displayName
+        }
+      };
+    } catch {
+      return {
+        authenticated: false,
+        user: null
+      };
+    } finally {
+    }
+  }
+  async sync(accountDir) {
+    const config = await loadTelegramConfig(accountDir);
+    if (!config) {
+      throw new TgsmError({
+        code: "AUTH_REQUIRED",
+        message: "Telegram credentials are not configured.",
+        retryable: false,
+        suggestion: "Run `tgsm auth login` first."
+      });
+    }
+    const client = new TelegramClient({
+      apiId: config.apiId,
+      apiHash: config.apiHash,
+      storage: path3.join(accountDir, "mtcute-session")
+    });
+    try {
+      const me = await client.start({});
+      const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const dialogsResponse = await client.call({
+        _: "messages.getSavedDialogs",
+        excludePinned: false,
+        offsetDate: 0,
+        offsetId: 0,
+        offsetPeer: { _: "inputPeerEmpty" },
+        limit: 1e3,
+        hash: 0
+      });
+      if (dialogsResponse._ === "messages.savedDialogsNotModified") {
+        return {
+          backend: this.backend,
+          account: {
+            id: String(me.id),
+            display_name: me.displayName
+          },
+          dialogs: [],
+          messages: [],
+          synced_at: syncedAt
+        };
+      }
+      const lookup = {
+        users: /* @__PURE__ */ new Map(),
+        chats: /* @__PURE__ */ new Map(),
+        selfUserId: Number(me.id)
+      };
+      ingestEntities(lookup, dialogsResponse.users, dialogsResponse.chats);
+      const dialogs = [];
+      const messagesByKey = /* @__PURE__ */ new Map();
+      for (const dialog of dialogsResponse.dialogs) {
+        if (dialog._ !== "savedDialog") continue;
+        const savedPeerId = savedPeerIdFromPeer(dialog.peer, lookup.selfUserId);
+        const peerInput = await client.resolvePeer(getMarkedPeerId(dialog.peer));
+        const title = peerTitle(dialog.peer, lookup);
+        const messages2 = await fetchSavedHistory(client, peerInput, lookup);
+        const topMessage = messages2.find((message) => message.message_id === dialog.topMessage) ?? messages2[0] ?? null;
+        dialogs.push({
+          saved_peer_id: savedPeerId,
+          kind: peerKindFromPeer(dialog.peer, lookup.selfUserId),
+          title,
+          top_message_id: dialog.topMessage ?? topMessage?.message_id ?? null,
+          top_text_preview: topMessage ? previewText2(topMessage.text) : null,
+          message_count: messages2.length,
+          pinned: dialog.pinned ?? null,
+          last_synced_at: syncedAt
+        });
+        for (const message of messages2) {
+          messagesByKey.set(`${message.saved_peer_id}:${message.message_id}`, message);
+        }
+      }
+      return {
+        backend: this.backend,
+        account: {
+          id: String(me.id),
+          display_name: me.displayName
+        },
+        dialogs,
+        messages: [...messagesByKey.values()].sort(
+          (a, b) => a.saved_peer_id.localeCompare(b.saved_peer_id) || a.date.localeCompare(b.date) || a.message_id - b.message_id
+        ),
+        synced_at: syncedAt
+      };
+    } catch (error) {
+      throw new TgsmError({
+        code: "TELEGRAM_SYNC_FAILED",
+        message: error instanceof Error ? error.message : "Telegram sync failed.",
+        retryable: true
+      });
+    } finally {
+    }
+  }
+};
+async function fetchSavedHistory(client, peer, lookup) {
+  let offsetId = 0;
+  let offsetDate = 0;
+  const records = /* @__PURE__ */ new Map();
+  while (true) {
+    const history = await client.call({
+      _: "messages.getSavedHistory",
+      peer,
+      offsetId,
+      offsetDate,
+      addOffset: 0,
+      limit: 100,
+      maxId: 0,
+      minId: 0,
+      hash: 0
+    });
+    if (!("messages" in history)) {
+      break;
+    }
+    ingestEntities(lookup, history.users ?? [], history.chats ?? []);
+    const rawMessages = history.messages.filter(
+      (message) => message._ === "message" || message._ === "messageService"
+    );
+    if (rawMessages.length === 0) {
+      break;
+    }
+    for (const raw of rawMessages) {
+      const record = normalizeRawMessage(raw, lookup);
+      records.set(`${record.saved_peer_id}:${record.message_id}`, record);
+    }
+    const oldest = rawMessages[rawMessages.length - 1];
+    offsetId = oldest.id;
+    offsetDate = oldest.date;
+    if (rawMessages.length < 100) {
+      break;
+    }
+  }
+  return [...records.values()].sort((a, b) => a.date.localeCompare(b.date) || a.message_id - b.message_id);
+}
+function normalizeRawMessage(raw, lookup) {
+  const savedPeerId = savedPeerIdFromPeer(raw.peerId, lookup.selfUserId);
+  const replyHeader = "replyTo" in raw && raw.replyTo && raw.replyTo._ === "messageReplyHeader" ? raw.replyTo : null;
+  const replyPeer = replyHeader?.replyToPeerId ?? raw.peerId;
+  const fwdFrom = "fwdFrom" in raw ? raw.fwdFrom : void 0;
+  const editDate = "editDate" in raw ? raw.editDate : void 0;
+  const media = "media" in raw ? raw.media : void 0;
+  const text = "message" in raw ? raw.message : "";
+  return {
+    message_id: raw.id,
+    saved_peer_id: savedPeerId,
+    date: new Date(raw.date * 1e3).toISOString(),
+    edit_date: editDate ? new Date(editDate * 1e3).toISOString() : null,
+    text,
+    from_self: peerIsSelf("fromId" in raw ? raw.fromId : null, lookup.selfUserId),
+    forwarded: Boolean(fwdFrom),
+    forward_origin: fwdFrom ? forwardOriginFromHeader(fwdFrom, lookup) : null,
+    reply_to_message_id: replyHeader?.replyToMsgId ?? null,
+    reply_to_saved_peer_id: replyHeader?.replyToMsgId ? savedPeerIdFromPeer(replyPeer, lookup.selfUserId) : null,
+    links: extractLinks(text),
+    media_summary: mediaSummary(media),
+    queued_for_delete: false
+  };
+}
+function forwardOriginFromHeader(header, lookup) {
+  if (header.savedFromPeer) {
+    return {
+      saved_peer_id: savedPeerIdFromPeer(header.savedFromPeer, lookup.selfUserId),
+      title: peerTitle(header.savedFromPeer, lookup),
+      message_id: header.savedFromMsgId ?? null
+    };
+  }
+  if (header.fromId) {
+    return {
+      saved_peer_id: savedPeerIdFromPeer(header.fromId, lookup.selfUserId),
+      title: header.fromName ?? peerTitle(header.fromId, lookup),
+      message_id: header.savedFromMsgId ?? null
+    };
+  }
+  return {
+    saved_peer_id: null,
+    title: header.fromName ?? header.savedFromName ?? null,
+    message_id: header.savedFromMsgId ?? null
+  };
+}
+function peerIsSelf(peer, selfUserId) {
+  return Boolean(peer && peer._ === "peerUser" && peer.userId === selfUserId);
+}
+function peerKindFromPeer(peer, selfUserId) {
+  if (peer._ === "peerUser" && peer.userId === selfUserId) return "self";
+  if (peer._ === "peerUser" || peer._ === "peerChat") return "peer";
+  if (peer._ === "peerChannel") return "channel";
+  return "unknown";
+}
+function savedPeerIdFromPeer(peer, selfUserId) {
+  if (peer._ === "peerUser" && peer.userId === selfUserId) {
+    return "self";
+  }
+  if (peer._ === "peerUser") return `user:${peer.userId}`;
+  if (peer._ === "peerChat") return `chat:${peer.chatId}`;
+  if (peer._ === "peerChannel") return `channel:${peer.channelId}`;
+  return `unknown:${getMarkedPeerId(peer)}`;
+}
+function peerTitle(peer, lookup) {
+  if (peer._ === "peerUser") {
+    if (peer.userId === lookup.selfUserId) return "Self";
+    const user = lookup.users.get(peer.userId);
+    const firstName = user && user._ === "user" ? user.firstName ?? "" : "";
+    const lastName = user && user._ === "user" ? user.lastName ?? "" : "";
+    const username = user && user._ === "user" ? user.username ?? "" : "";
+    const parts = [firstName, lastName].filter(Boolean);
+    return parts.join(" ").trim() || username || `User ${peer.userId}`;
+  }
+  const entity = lookup.chats.get(peer._ === "peerChat" ? peer.chatId : peer.channelId);
+  if (entity && "title" in entity) {
+    return entity.title;
+  }
+  if (peer._ === "peerChat") return `Chat ${peer.chatId}`;
+  if (peer._ === "peerChannel") return `Channel ${peer.channelId}`;
+  return "Unknown";
+}
+function ingestEntities(lookup, users, chats) {
+  for (const user of users) {
+    if ("id" in user) {
+      lookup.users.set(Number(user.id), user);
+    }
+  }
+  for (const chat of chats) {
+    if ("id" in chat) {
+      lookup.chats.set(Number(chat.id), chat);
+    }
+  }
+}
+function extractLinks(text) {
+  const matches = text.matchAll(/https?:\/\/[^\s)]+/g);
+  const seen = /* @__PURE__ */ new Set();
+  const links = [];
+  for (const match of matches) {
+    const url = match[0];
+    if (seen.has(url)) continue;
+    seen.add(url);
+    links.push({ url });
+  }
+  return links;
+}
+function mediaSummary(media) {
+  if (!media) return null;
+  return media._;
+}
+function previewText2(text, limit = 80) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (!normalized) return "(no text)";
+  return normalized.length <= limit ? normalized : `${normalized.slice(0, limit - 1)}\u2026`;
+}
+async function loadTelegramConfig(accountDir) {
+  try {
+    const raw = await readFile3(path3.join(accountDir, "telegram.json"), "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function saveTelegramConfig(accountDir, config) {
+  await writeFile2(
+    path3.join(accountDir, "telegram.json"),
+    `${JSON.stringify(config, null, 2)}
+`,
+    "utf8"
+  );
+}
+
+// src/format.ts
+function formatSyncResult(result) {
+  return [
+    `sync backend=${result.backend}`,
+    `synced_at=${result.synced_at}`,
+    `dialogs=${result.synced_dialogs}`,
+    `messages=${result.synced_messages}`
+  ].join("\n");
+}
+function formatAuthStatus(status) {
+  if (!status.authenticated || !status.user) {
+    return "authenticated: false";
+  }
+  return [`authenticated: true`, `user: ${status.user.display_name}`, `id: ${status.user.id}`].join("\n");
+}
+function formatSavedDialogs(dialogs) {
+  if (dialogs.length === 0) return "No saved dialogs found.";
+  return dialogs.map(
+    (dialog) => [
+      `${dialog.saved_peer_id} (${dialog.kind})`,
+      `title: ${dialog.title}`,
+      `messages: ${dialog.message_count}`,
+      `top_message_id: ${dialog.top_message_id ?? "n/a"}`,
+      `top_text: ${dialog.top_text_preview ?? "(none)"}`
+    ].join("\n")
+  ).join("\n\n");
+}
+function formatMessagesPage(page) {
+  if (page.items.length === 0) return "No messages found.";
+  const header = page.scope === "saved_dialog" ? `messages scope=${page.saved_peer_id} total=${page.result_count}` : `messages scope=all_saved_dialogs total=${page.result_count}`;
+  const blocks = page.items.map(
+    (item) => [
+      `#${item.message_id} ${item.date}`,
+      `dialog: ${item.saved_peer_id} (${item.dialog_title})`,
+      `from_self: ${item.from_self} forwarded: ${item.forwarded}`,
+      `reply_to: ${item.reply_to_message_id ?? "none"} backreplies: ${item.direct_backreply_count}`,
+      `text: ${item.text_preview}`
+    ].join("\n")
+  );
+  return [header, ...blocks, page.next_cursor ? `next_cursor: ${page.next_cursor}` : ""].filter(Boolean).join("\n\n");
+}
+function formatContextBundle(bundle) {
+  const lines = [
+    `MESSAGE #${bundle.target.message_id}`,
+    `dialog: ${bundle.dialog.saved_peer_id} (${bundle.dialog.title})`,
+    `date: ${bundle.target.date}`,
+    `from_self: ${bundle.target.from_self}`,
+    `thread: direct_backreplies=${bundle.target.thread.direct_backreply_count} descendant_hint=${bundle.target.thread.descendant_count_hint ?? 0}`,
+    "",
+    "text:",
+    bundle.target.text || "(no text)"
+  ];
+  const replySection = bundle.target.reply.exists ? bundle.target.reply.target ? [``, "reply_to:", `- #${bundle.target.reply.target.message_id} ${bundle.target.reply.target.text_preview}`] : [``, "reply_to:", "- (missing from cache)"] : [];
+  const backreplySection = bundle.target.backreplies.length > 0 ? [
+    "",
+    "backreplies:",
+    ...bundle.target.backreplies.map(
+      (item) => `- #${item.message.message_id} ${item.message.text_preview}`
+    )
+  ] : [];
+  const before = bundle.context_messages.filter((item) => item.context_roles.includes("chronology_before"));
+  const after = bundle.context_messages.filter((item) => item.context_roles.includes("chronology_after"));
+  if (before.length > 0) {
+    lines.push("", "chronology_before:");
+    for (const item of before) lines.push(`- #${item.message.message_id} ${item.message.text_preview}`);
+  }
+  if (after.length > 0) {
+    lines.push("", "chronology_after:");
+    for (const item of after) lines.push(`- #${item.message.message_id} ${item.message.text_preview}`);
+  }
+  lines.push(...replySection, ...backreplySection);
+  if (bundle.notes.length > 0) {
+    lines.push("", "notes:");
+    for (const note of bundle.notes) lines.push(`- ${note}`);
+  }
+  return lines.join("\n");
+}
+function formatThread(result) {
+  const lines = [`THREAD #${result.root.message_id}`, `dialog: ${result.dialog.saved_peer_id} (${result.dialog.title})`, ""];
+  const root = result.nodes[0];
+  if (!root) return lines.join("\n");
+  renderNode(root, "", true, lines);
+  return lines.join("\n");
+}
+function renderNode(node, prefix, isLast, lines) {
+  const branch = prefix ? `${prefix}${isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}` : "";
+  lines.push(`${branch}#${node.message.message_id} ${node.message.text_preview}`);
+  const nextPrefix = prefix ? `${prefix}${isLast ? "    " : "\u2502   "}` : "";
+  node.children.forEach((child, index) => {
+    renderNode(child, nextPrefix, index === node.children.length - 1, lines);
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("tgsm").description("Retrieval-first Telegram Saved Messages CLI").option("--json", "Emit JSON instead of default text output").option("--backend <backend>", "telegram or fixture", "telegram").option("--fixture <path>", "Fixture path for the fixture backend").option("--home <path>", "Override TGSM home directory").option("--account <name>", "Account namespace", "default");
+program.command("auth").description("Telegram auth commands").addCommand(
+  new Command("login").action(async (_, command) => {
+    await withService(command.optsWithGlobals(), async (service, options) => {
+      if (options.backend !== "telegram") {
+        throw new TgsmError({
+          code: "AUTH_UNSUPPORTED",
+          message: "Auth login is only supported with the telegram backend.",
+          retryable: false
+        });
+      }
+      const rl = createInterface({
+        input: process2.stdin,
+        output: process2.stderr
+      });
+      try {
+        const apiId = Number(await rl.question("API ID: "));
+        const apiHash = await rl.question("API Hash: ");
+        const phone = await rl.question("Phone: ");
+        const code = await rl.question("Code: ");
+        const password = await rl.question("2FA password (optional): ");
+        const result = await service.authLogin({
+          apiId,
+          apiHash,
+          phone,
+          code,
+          password: password || void 0
+        });
+        emit(result, options);
+      } finally {
+        rl.close();
+      }
+    });
+  })
+).addCommand(
+  new Command("status").action(async (_, command) => {
+    await withService(command.optsWithGlobals(), async (service, options) => {
+      emit(await service.authStatus(), options, formatAuthStatus);
+    });
+  })
+);
+program.command("sync").action(async (_, command) => {
+  await withService(command.optsWithGlobals(), async (service, options) => {
+    emit(await service.sync(), options, formatSyncResult);
+  });
+});
+program.command("saved-dialogs").description("Saved dialog commands").addCommand(
+  new Command("list").action(async (_, command) => {
+    await withService(command.optsWithGlobals(), async (service, options) => {
+      emit(await service.listSavedDialogs(), options, formatSavedDialogs);
+    });
+  })
+);
+var messages = program.command("messages").description("Message commands");
+messages.command("list").option("--dialog <savedPeerId>").option("--search <query>").option("--limit <number>", "Page size", "20").option("--cursor <cursor>").action(async (commandOptions, command) => {
+  await withService(command.optsWithGlobals(), async (service, options) => {
+    const result = await service.listMessages({
+      dialog: commandOptions.dialog,
+      search: commandOptions.search,
+      limit: Number(commandOptions.limit),
+      cursor: commandOptions.cursor
+    });
+    emit(result, options, formatMessagesPage);
+  });
+});
+messages.command("get").argument("<id>").option("--dialog <savedPeerId>").action(async (id, commandOptions, command) => {
+  await withService(command.optsWithGlobals(), async (service, options) => {
+    const result = await service.getMessage(Number(id), {
+      dialog: commandOptions.dialog
+    });
+    emit(result, options, formatContextBundle);
+  });
+});
+messages.command("context").argument("<id>").option("--dialog <savedPeerId>").action(async (id, commandOptions, command) => {
+  await withService(command.optsWithGlobals(), async (service, options) => {
+    const result = await service.getContext(Number(id), {
+      dialog: commandOptions.dialog
+    });
+    emit(result, options, formatContextBundle);
+  });
+});
+program.command("threads").description("Thread commands").addCommand(
+  new Command("inspect").argument("<id>").option("--dialog <savedPeerId>").action(async (id, commandOptions, command) => {
+    await withService(command.optsWithGlobals(), async (service, options) => {
+      const result = await service.inspectThread(Number(id), {
+        dialog: commandOptions.dialog
+      });
+      emit(result, options, formatThread);
+    });
+  })
+);
+program.parseAsync(process2.argv).catch((error) => {
+  const tgsmError = error instanceof TgsmError ? error : new TgsmError({
+    code: "UNEXPECTED_ERROR",
+    message: error instanceof Error ? error.message : "Unexpected error",
+    retryable: false
+  });
+  const options = program.opts();
+  if (options.json) {
+    process2.stdout.write(`${JSON.stringify(tgsmError.toJSON(), null, 2)}
+`);
+  } else {
+    process2.stderr.write(`error: ${tgsmError.message}
+`);
+    if (tgsmError.suggestion) {
+      process2.stderr.write(`suggestion: ${tgsmError.suggestion}
+`);
+    }
+  }
+  process2.exitCode = errorCode(tgsmError.code);
+});
+async function withService(options, fn) {
+  const normalized = {
+    json: Boolean(options.json),
+    backend: options.backend ?? "telegram",
+    fixture: options.fixture ?? "",
+    home: options.home ?? "",
+    account: options.account ?? "default"
+  };
+  await ensureAccountDir({
+    homeDir: normalized.home || void 0,
+    account: normalized.account
+  });
+  const cachePath = getCachePath({
+    homeDir: normalized.home || void 0,
+    account: normalized.account
+  });
+  const source = resolveSource(normalized);
+  const service = new TgsmService({
+    cachePath,
+    source
+  });
+  await fn(service, normalized);
+}
+function resolveSource(options) {
+  if (options.backend === "fixture") {
+    if (!options.fixture) {
+      throw new TgsmError({
+        code: "FIXTURE_REQUIRED",
+        message: "The fixture backend requires --fixture <path>.",
+        retryable: false
+      });
+    }
+    return new FixtureSource(options.fixture);
+  }
+  return new TelegramSource();
+}
+function emit(value, options, format) {
+  if (options.json) {
+    process2.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+    return;
+  }
+  process2.stdout.write(`${format ? format(value) : String(value)}
+`);
+}
+function errorCode(code) {
+  if (code.startsWith("AUTH")) return 3;
+  if (code.includes("SYNC") || code.includes("TELEGRAM")) return 2;
+  return 1;
+}
+//# sourceMappingURL=index.js.map