@aion0/forge 0.6.1 → 0.8.0

package/lib/chat/session-store.ts

@@ -0,0 +1,272 @@
+/**
+ * Chat session storage — sqlite-backed. One row per session, one row
+ * per message; message.blocks is JSON-encoded.
+ *
+ * Lives in <data>/workflow.db alongside the rest of Forge's state.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { getDb } from '@/src/core/db/database';
+import { getDataDir } from '@/lib/dirs';
+import type { ContentBlock, Message, Role, Session } from './types';
+
+function db() {
+  return getDb(join(getDataDir(), 'workflow.db'));
+}
+
+interface SessionRow {
+  id: string;
+  title: string | null;
+  created_at: number;
+  updated_at: number;
+  model: string | null;
+  provider: string | null;
+  system_prompt: string | null;
+  meta: string | null;
+}
+
+interface MessageRow {
+  id: string;
+  session_id: string;
+  role: Role;
+  blocks: string;
+  ts: number;
+  error: string | null;
+}
+
+let initialized = false;
+
+function ensureSchema(): void {
+  if (initialized) return;
+  const conn = db();
+  conn.exec(`
+    CREATE TABLE IF NOT EXISTS chat_sessions (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      model TEXT,
+      provider TEXT,
+      system_prompt TEXT,
+      meta TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_chat_sessions_updated ON chat_sessions(updated_at DESC);
+
+    CREATE TABLE IF NOT EXISTS chat_messages (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      blocks TEXT NOT NULL,
+      ts INTEGER NOT NULL,
+      error TEXT,
+      FOREIGN KEY(session_id) REFERENCES chat_sessions(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_chat_messages_session ON chat_messages(session_id, ts);
+  `);
+  initialized = true;
+}
+
+function rowToSession(r: SessionRow): Session {
+  return {
+    id: r.id,
+    title: r.title,
+    created_at: r.created_at,
+    updated_at: r.updated_at,
+    model: r.model,
+    provider: r.provider,
+    system_prompt: r.system_prompt,
+    meta: r.meta ? safeParse(r.meta) : undefined,
+  };
+}
+
+function rowToMessage(r: MessageRow): Message {
+  return {
+    id: r.id,
+    session_id: r.session_id,
+    role: r.role,
+    blocks: safeParse<ContentBlock[]>(r.blocks) ?? [],
+    ts: r.ts,
+    error: r.error ?? undefined,
+  };
+}
+
+function safeParse<T = unknown>(s: string): T | undefined {
+  try { return JSON.parse(s) as T; } catch { return undefined; }
+}
+
+// ─── Sessions ────────────────────────────────────────────
+
+export function createSession(opts: {
+  title?: string;
+  model?: string;
+  provider?: string;
+  system_prompt?: string;
+  meta?: Record<string, unknown>;
+}): Session {
+  ensureSchema();
+  const now = Date.now();
+  const row: SessionRow = {
+    id: randomUUID(),
+    title: opts.title ?? null,
+    created_at: now,
+    updated_at: now,
+    model: opts.model ?? null,
+    provider: opts.provider ?? null,
+    system_prompt: opts.system_prompt ?? null,
+    meta: opts.meta ? JSON.stringify(opts.meta) : null,
+  };
+  db().prepare(`
+    INSERT INTO chat_sessions (id, title, created_at, updated_at, model, provider, system_prompt, meta)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(row.id, row.title, row.created_at, row.updated_at, row.model, row.provider, row.system_prompt, row.meta);
+  return rowToSession(row);
+}
+
+export function getSession(id: string): Session | null {
+  ensureSchema();
+  const r = db().prepare(`SELECT * FROM chat_sessions WHERE id = ?`).get(id) as SessionRow | undefined;
+  return r ? rowToSession(r) : null;
+}
+
+export function listSessions(limit = 50): Session[] {
+  ensureSchema();
+  const rows = db().prepare(`
+    SELECT * FROM chat_sessions ORDER BY updated_at DESC LIMIT ?
+  `).all(limit) as SessionRow[];
+  return rows.map(rowToSession);
+}
+
+export function updateSession(id: string, patch: Partial<Pick<Session, 'title' | 'model' | 'provider' | 'system_prompt' | 'meta'>>): boolean {
+  ensureSchema();
+  const cur = getSession(id);
+  if (!cur) return false;
+  const merged = {
+    title: patch.title ?? cur.title,
+    model: patch.model ?? cur.model,
+    provider: patch.provider ?? cur.provider,
+    system_prompt: patch.system_prompt ?? cur.system_prompt,
+    meta: patch.meta !== undefined ? patch.meta : cur.meta,
+  };
+  db().prepare(`
+    UPDATE chat_sessions SET title=?, model=?, provider=?, system_prompt=?, meta=?, updated_at=?
+    WHERE id=?
+  `).run(
+    merged.title, merged.model, merged.provider, merged.system_prompt,
+    merged.meta ? JSON.stringify(merged.meta) : null,
+    Date.now(), id,
+  );
+  return true;
+}
+
+export function deleteSession(id: string): boolean {
+  ensureSchema();
+  const r = db().prepare(`DELETE FROM chat_sessions WHERE id = ?`).run(id);
+  return r.changes > 0;
+}
+
+/**
+ * Empty all messages in a session WITHOUT deleting the session row.
+ * Use for the main chat's "clear" — keep the session, drop history.
+ */
+export function clearSessionMessages(id: string): number {
+  ensureSchema();
+  const r = db().prepare(`DELETE FROM chat_messages WHERE session_id = ?`).run(id);
+  touchSession(id);
+  return r.changes;
+}
+
+/**
+ * Find-or-create the user's persistent main session. Identified by
+ * meta.kind === 'main'. Only one is ever returned (oldest wins if
+ * multiple — caller can collapse later). Job dispatches and the "new
+ * conversation" button create sessions with meta.kind = 'temp', so
+ * the main session is naturally pinned and never auto-deleted.
+ */
+export function ensureMainSession(): Session {
+  ensureSchema();
+  const existing = db().prepare(
+    `SELECT * FROM chat_sessions WHERE json_extract(meta, '$.kind') = 'main' ORDER BY created_at ASC LIMIT 1`,
+  ).get() as SessionRow | undefined;
+  if (existing) return rowToSession(existing);
+  return createSession({ title: 'Main conversation', meta: { kind: 'main' } });
+}
+
+/**
+ * Fork a session: copy its current messages into a brand-new session.
+ * The fork starts as a temp session so it can be deleted later. Optional
+ * upToTs lets the caller branch from a specific point (everything with
+ * ts <= upToTs is copied).
+ */
+export function forkSession(srcId: string, opts: { title?: string; upToTs?: number } = {}): Session | null {
+  ensureSchema();
+  const src = getSession(srcId);
+  if (!src) return null;
+  const title = opts.title || `${src.title || 'Conversation'} (fork)`;
+  const fork = createSession({
+    title,
+    model: src.model || undefined,
+    provider: src.provider || undefined,
+    system_prompt: src.system_prompt || undefined,
+    meta: { kind: 'temp', forked_from: srcId },
+  });
+  const ts = opts.upToTs ?? Date.now();
+  const msgs = db().prepare(
+    `SELECT * FROM chat_messages WHERE session_id = ? AND ts <= ? ORDER BY ts ASC`,
+  ).all(srcId, ts) as MessageRow[];
+  const ins = db().prepare(`
+    INSERT INTO chat_messages (id, session_id, role, blocks, ts, error)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+  for (const m of msgs) {
+    ins.run(randomUUID(), fork.id, m.role, m.blocks, m.ts, m.error);
+  }
+  touchSession(fork.id);
+  return fork;
+}
+
+function touchSession(id: string): void {
+  db().prepare(`UPDATE chat_sessions SET updated_at = ? WHERE id = ?`).run(Date.now(), id);
+}
+
+// ─── Messages ────────────────────────────────────────────
+
+export function appendMessage(opts: {
+  session_id: string;
+  role: Role;
+  blocks: ContentBlock[];
+  error?: string;
+}): Message {
+  ensureSchema();
+  const row: MessageRow = {
+    id: randomUUID(),
+    session_id: opts.session_id,
+    role: opts.role,
+    blocks: JSON.stringify(opts.blocks),
+    ts: Date.now(),
+    error: opts.error ?? null,
+  };
+  db().prepare(`
+    INSERT INTO chat_messages (id, session_id, role, blocks, ts, error)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(row.id, row.session_id, row.role, row.blocks, row.ts, row.error);
+  touchSession(opts.session_id);
+  return rowToMessage(row);
+}
+
+export function listMessages(session_id: string, opts?: { limit?: number; after_ts?: number }): Message[] {
+  ensureSchema();
+  const limit = opts?.limit ?? 500;
+  const after = opts?.after_ts ?? 0;
+  const rows = db().prepare(`
+    SELECT * FROM chat_messages WHERE session_id = ? AND ts > ?
+    ORDER BY ts ASC LIMIT ?
+  `).all(session_id, after, limit) as MessageRow[];
+  return rows.map(rowToMessage);
+}
+
+export function deleteMessage(id: string): boolean {
+  ensureSchema();
+  const r = db().prepare(`DELETE FROM chat_messages WHERE id = ?`).run(id);
+  return r.changes > 0;
+}

package/lib/chat/telegram-bridge.ts

@@ -0,0 +1,276 @@
+/**
+ * Telegram ↔ chat-standalone bridge.
+ *
+ * Each Telegram chat_id maps to one Forge chat session. The map is
+ * persisted as JSON in <dataDir>/telegram-chat-sessions.json so a
+ * conversation survives bot restarts.
+ *
+ * Per turn we:
+ *   1. Send a "thinking…" placeholder to Telegram, remember its message_id
+ *   2. Open SSE on chat-standalone, then POST the user text
+ *   3. Stream agent events:
+ *        - tool_use → edit placeholder with "⚙ running <tool>(args)…"
+ *        - text_delta → buffer; throttled edit (every 2s) to show progress
+ *        - turn_done → final edit with full assistant text (split if >MAX)
+ *        - error → final edit with "✗ <error>"
+ *
+ * Telegram has a ~30 msg/sec API limit and edit rate-limits per chat;
+ * we throttle edits to once per 2s during streaming.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getDataDir } from '../dirs';
+
+const CHAT_PORT = Number(process.env.CHAT_PORT) || 8408;
+const BASE = `http://127.0.0.1:${CHAT_PORT}`;
+const MAX_TELEGRAM_MSG = 4000; // a bit under 4096 to allow markers
+const EDIT_THROTTLE_MS = 2000;
+
+// ─── Session map persistence ──────────────────────────────
+
+interface SessionMap {
+  /** telegram chat_id → forge session_id */
+  sessions: Record<string, string>;
+}
+
+function mapFile(): string {
+  return join(getDataDir(), 'telegram-chat-sessions.json');
+}
+
+function loadMap(): SessionMap {
+  try {
+    const f = mapFile();
+    if (!existsSync(f)) return { sessions: {} };
+    return JSON.parse(readFileSync(f, 'utf-8')) as SessionMap;
+  } catch { return { sessions: {} }; }
+}
+
+function saveMap(m: SessionMap): void {
+  try {
+    mkdirSync(getDataDir(), { recursive: true });
+    writeFileSync(mapFile(), JSON.stringify(m, null, 2));
+  } catch (e) {
+    console.error('[chat-tg] save map failed', e);
+  }
+}
+
+export function getTelegramSession(telegramChatId: number): string | null {
+  const m = loadMap();
+  return m.sessions[String(telegramChatId)] || null;
+}
+
+export function setTelegramSession(telegramChatId: number, sessionId: string): void {
+  const m = loadMap();
+  m.sessions[String(telegramChatId)] = sessionId;
+  saveMap(m);
+}
+
+export function clearTelegramSession(telegramChatId: number): void {
+  const m = loadMap();
+  delete m.sessions[String(telegramChatId)];
+  saveMap(m);
+}
+
+// ─── chat-standalone client ───────────────────────────────
+
+async function createSession(title: string): Promise<string> {
+  const res = await fetch(`${BASE}/api/sessions`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ title }),
+  });
+  if (!res.ok) throw new Error(`create session: HTTP ${res.status}`);
+  const j = await res.json();
+  if (!j?.session?.id) throw new Error('create session: no id');
+  return j.session.id as string;
+}
+
+async function ensureSession(telegramChatId: number): Promise<string> {
+  const existing = getTelegramSession(telegramChatId);
+  if (existing) {
+    // Validate it still exists; if not, drop and recreate.
+    try {
+      const r = await fetch(`${BASE}/api/sessions/${encodeURIComponent(existing)}`);
+      if (r.status === 404) {
+        clearTelegramSession(telegramChatId);
+      } else if (r.ok) {
+        return existing;
+      }
+    } catch {/* fall through to recreate */}
+  }
+  const id = await createSession(`Telegram chat ${telegramChatId}`);
+  setTelegramSession(telegramChatId, id);
+  return id;
+}
+
+async function openSse(sessionId: string): Promise<ReadableStreamDefaultReader<Uint8Array>> {
+  const res = await fetch(`${BASE}/api/sessions/${encodeURIComponent(sessionId)}/events`, {
+    headers: { accept: 'text/event-stream' },
+  });
+  if (!res.ok || !res.body) throw new Error(`SSE open: HTTP ${res.status}`);
+  const reader = res.body.getReader();
+  await reader.read(); // wait for initial `: subscribed` comment
+  return reader;
+}
+
+async function postMessage(sessionId: string, text: string): Promise<void> {
+  const res = await fetch(`${BASE}/api/sessions/${encodeURIComponent(sessionId)}/messages`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ text }),
+  });
+  if (res.status !== 202 && !res.ok) {
+    throw new Error(`POST message: HTTP ${res.status}`);
+  }
+}
+
+// ─── Turn driver ──────────────────────────────────────────
+
+export interface TelegramTurnCallbacks {
+  /** Send placeholder; return message_id. Bot edits this with progress. */
+  sendPlaceholder: (text: string) => Promise<number | null>;
+  /** Edit a previously-sent placeholder. Failures are swallowed (rate-limit). */
+  editPlaceholder: (messageId: number, text: string) => Promise<void>;
+  /** Send a brand-new message (used for the final text when it splits). */
+  sendNew: (text: string) => Promise<number | null>;
+}
+
+interface AgentEvent { type: string; data?: any; message_id?: string }
+
+function summarizeToolInput(input: unknown): string {
+  try {
+    const s = JSON.stringify(input ?? {});
+    return s.length > 80 ? s.slice(0, 80) + '…' : s;
+  } catch { return ''; }
+}
+
+/**
+ * Run one chat turn against chat-standalone, streaming progress to Telegram.
+ * Returns the final assistant text (joined if multi-block).
+ */
+export async function runTelegramTurn(args: {
+  telegramChatId: number;
+  userText: string;
+  cb: TelegramTurnCallbacks;
+}): Promise<{ ok: boolean; sessionId: string; finalText?: string; error?: string }> {
+  const sessionId = await ensureSession(args.telegramChatId);
+
+  const placeholderId = await args.cb.sendPlaceholder('🤖 thinking…');
+
+  let reader: ReadableStreamDefaultReader<Uint8Array>;
+  try {
+    reader = await openSse(sessionId);
+  } catch (e) {
+    const msg = (e as Error).message;
+    if (placeholderId) await args.cb.editPlaceholder(placeholderId, `✗ ${msg}`);
+    return { ok: false, sessionId, error: msg };
+  }
+
+  try {
+    await postMessage(sessionId, args.userText);
+  } catch (e) {
+    try { await reader.cancel(); } catch {}
+    const msg = (e as Error).message;
+    if (placeholderId) await args.cb.editPlaceholder(placeholderId, `✗ ${msg}`);
+    return { ok: false, sessionId, error: msg };
+  }
+
+  // Streaming consume + throttled edits.
+  const decoder = new TextDecoder();
+  let buf = '';
+  let assistantText = '';
+  let currentTool: string | null = null;
+  let lastEditAt = 0;
+  let lastEditPayload = '';
+  let errorMsg: string | null = null;
+
+  async function maybeEdit(force = false) {
+    if (!placeholderId) return;
+    const now = Date.now();
+    if (!force && now - lastEditAt < EDIT_THROTTLE_MS) return;
+    let payload: string;
+    if (currentTool) {
+      payload = assistantText
+        ? `${assistantText}\n\n⚙ ${currentTool}…`
+        : `⚙ ${currentTool}…`;
+    } else {
+      payload = assistantText || '🤖 thinking…';
+    }
+    if (payload.length > MAX_TELEGRAM_MSG) payload = payload.slice(0, MAX_TELEGRAM_MSG) + '…';
+    if (payload === lastEditPayload) return;
+    lastEditPayload = payload;
+    lastEditAt = now;
+    await args.cb.editPlaceholder(placeholderId, payload);
+  }
+
+  outer:
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+
+    let idx: number;
+    while ((idx = buf.indexOf('\n\n')) >= 0) {
+      const frame = buf.slice(0, idx);
+      buf = buf.slice(idx + 2);
+      const dataLine = frame.split('\n').find((l) => l.startsWith('data: '));
+      if (!dataLine) continue;
+      let evt: AgentEvent;
+      try { evt = JSON.parse(dataLine.slice(6)); } catch { continue; }
+
+      switch (evt.type) {
+        case 'text_delta': {
+          assistantText += String(evt.data?.delta || '');
+          void maybeEdit();
+          break;
+        }
+        case 'tool_use': {
+          const name = String(evt.data?.name || '?');
+          currentTool = `${name}(${summarizeToolInput(evt.data?.input)})`;
+          void maybeEdit(true);
+          break;
+        }
+        case 'tool_result': {
+          currentTool = null;
+          void maybeEdit(true);
+          break;
+        }
+        case 'turn_done': {
+          break outer;
+        }
+        case 'error': {
+          errorMsg = String(evt.data?.error || 'unknown');
+          break outer;
+        }
+      }
+    }
+  }
+  try { await reader.cancel(); } catch {}
+
+  if (errorMsg) {
+    if (placeholderId) await args.cb.editPlaceholder(placeholderId, `✗ ${errorMsg}`);
+    return { ok: false, sessionId, error: errorMsg };
+  }
+
+  const finalText = assistantText.trim() || '(no reply)';
+
+  // Final delivery: if it fits one message, edit the placeholder. Else
+  // edit with the first slice and send follow-ups as new messages.
+  if (placeholderId) {
+    const first = finalText.length > MAX_TELEGRAM_MSG ? finalText.slice(0, MAX_TELEGRAM_MSG) : finalText;
+    await args.cb.editPlaceholder(placeholderId, first);
+    if (finalText.length > MAX_TELEGRAM_MSG) {
+      for (let i = MAX_TELEGRAM_MSG; i < finalText.length; i += MAX_TELEGRAM_MSG) {
+        await args.cb.sendNew(finalText.slice(i, i + MAX_TELEGRAM_MSG));
+      }
+    }
+  } else {
+    // Placeholder failed; send fresh
+    for (let i = 0; i < finalText.length; i += MAX_TELEGRAM_MSG) {
+      await args.cb.sendNew(finalText.slice(i, i + MAX_TELEGRAM_MSG));
+    }
+  }
+
+  return { ok: true, sessionId, finalText };
+}