@amanm/openpaw 0.1.0

package/gateway/telegram/session-file-discovery.ts

@@ -0,0 +1,62 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { readdir, stat } from "node:fs/promises";
+import { getSessionsDir } from "../../config/paths";
+import { TELEGRAM_ACTIVE_THREADS_FILENAME } from "./constants";
+
+export type TelegramSessionListEntry = {
+  sessionId: string;
+  mtimeMs: number;
+};
+
+function parseTelegramSessionFilename(
+  filename: string,
+  chatId: number,
+): string | null {
+  if (!filename.endsWith(".json") || filename === TELEGRAM_ACTIVE_THREADS_FILENAME) {
+    return null;
+  }
+  const stem = filename.slice(0, -".json".length);
+  const idStr = String(chatId);
+  const prefix = `telegram_${idStr}`;
+  if (stem === prefix) {
+    return `telegram:${chatId}`;
+  }
+  if (stem.startsWith(`${prefix}_`)) {
+    const suffix = stem.slice(prefix.length + 1);
+    if (!suffix) {
+      return null;
+    }
+    return `telegram:${chatId}:${suffix}`;
+  }
+  return null;
+}
+
+/**
+ * Lists on-disk session files for this Telegram chat, newest first.
+ */
+export async function listTelegramSessionsForChat(
+  chatId: number,
+): Promise<TelegramSessionListEntry[]> {
+  const dir = getSessionsDir();
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const names = await readdir(dir);
+  const entries: TelegramSessionListEntry[] = [];
+  for (const name of names) {
+    const sessionId = parseTelegramSessionFilename(name, chatId);
+    if (!sessionId) {
+      continue;
+    }
+    const path = join(dir, name);
+    try {
+      const st = await stat(path);
+      entries.push({ sessionId, mtimeMs: st.mtimeMs });
+    } catch {
+      continue;
+    }
+  }
+  entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return entries;
+}

package/gateway/telegram/session-key.ts

@@ -0,0 +1,13 @@
+import type { Context } from "grammy";
+
+/**
+ * Per-chat serialization key for the Telegram gateway (message queue).
+ * Persistence ids may add a thread suffix; see {@link getTelegramPersistenceSessionId} in `./active-thread-store.ts`.
+ */
+export function telegramSessionKey(ctx: Context): string {
+  const id = ctx.chat?.id;
+  if (id === undefined) {
+    return "telegram:unknown";
+  }
+  return `telegram:${id}`;
+}

package/gateway/telegram/session-label.ts

@@ -0,0 +1,14 @@
+/**
+ * Human-readable label for a session row in /sessions (legacy → "main", else full thread id suffix).
+ */
+export function formatTelegramSessionLabel(sessionId: string, chatId: number): string {
+  const legacy = `telegram:${chatId}`;
+  if (sessionId === legacy) {
+    return "main";
+  }
+  const prefix = `${legacy}:`;
+  if (sessionId.startsWith(prefix)) {
+    return sessionId.slice(prefix.length);
+  }
+  return sessionId;
+}

package/gateway/telegram/sessions-list-reply.ts

@@ -0,0 +1,39 @@
+import type { Context } from "grammy";
+import { getTelegramPersistenceSessionId } from "./active-thread-store";
+import { listTelegramSessionsForChat } from "./session-file-discovery";
+import { formatTelegramSessionLabel } from "./session-label";
+
+const MAX_LINES = 20;
+const MAX_CHARS = 3500;
+
+/**
+ * Sends the /sessions reply for one chat (numbered list, active marker, truncation).
+ */
+export async function replyWithSessionsList(ctx: Context, chatId: number): Promise<void> {
+  const entries = await listTelegramSessionsForChat(chatId);
+  const active = await getTelegramPersistenceSessionId(chatId);
+
+  if (entries.length === 0) {
+    await ctx.reply("No saved sessions yet.");
+    return;
+  }
+
+  const lines: string[] = [];
+  const shown = Math.min(entries.length, MAX_LINES);
+  for (let i = 0; i < shown; i++) {
+    const e = entries[i]!;
+    const n = i + 1;
+    const mark = e.sessionId === active ? " (active)" : "";
+    const label = formatTelegramSessionLabel(e.sessionId, chatId);
+    lines.push(`${n}. ${label}${mark}`);
+  }
+  if (entries.length > MAX_LINES) {
+    lines.push(`…and ${entries.length - MAX_LINES} more.`);
+  }
+
+  let body = "Saved sessions (newest first):\n" + lines.join("\n");
+  if (body.length > MAX_CHARS) {
+    body = `${body.slice(0, MAX_CHARS - 20)}\n…(truncated)`;
+  }
+  await ctx.reply(body);
+}