blun-king-cli 9.1.567 → 9.1.569

package/telegram-plugin/bin/telegram-mnemo-capture.cjs

@@ -1,297 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-const DEFAULT_TIMEOUT_MS = 5_000;
-const DEFAULT_RETRY_MS = 15_000;
-
-function cleanString(value) {
-  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
-}
-
-function cleanHubUrl(value) {
-  const raw = cleanString(value);
-  if (!raw) return null;
-  try {
-    const url = new URL(raw);
-    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) return null;
-    url.pathname = url.pathname.replace(/\/+$/u, '');
-    url.search = '';
-    url.hash = '';
-    return url.toString().replace(/\/$/u, '');
-  } catch {
-    return null;
-  }
-}
-
-function readProfileMnemoConfig(profileHome) {
-  const root = cleanString(profileHome);
-  if (!root) return null;
-  try {
-    const file = path.join(root, 'mcp.json');
-    const stat = fs.statSync(file);
-    if (!stat.isFile() || stat.size > 1024 * 1024) return null;
-    const config = JSON.parse(fs.readFileSync(file, 'utf8'));
-    const server = config?.mcpServers?.mnemo;
-    if (!server || server.enabled === false) return null;
-    const env = server.env && typeof server.env === 'object' ? server.env : {};
-    const agentName = cleanString(env.BLUN_MNEMO_AGENT) || cleanString(env.MNEMO_AGENT);
-    if (!agentName || /[\u0000-\u001f\u007f]/u.test(agentName) || agentName.length > 128) return null;
-    const configuredUrl = cleanString(env.BLUN_MNEMO_HUB_URL)
-      || cleanString(env.MNEMO_HUB_URL)
-      || cleanString(env.MNEMO_URL);
-    const baseUrl = configuredUrl ? cleanHubUrl(configuredUrl) : null;
-    return baseUrl ? { agentName, baseUrl } : null;
-  } catch {
-    return null;
-  }
-}
-
-function resolveCaptureConfig(options = {}) {
-  const env = options.env || process.env;
-  const profile = readProfileMnemoConfig(options.profileHome || env.BLUN_HOME);
-  const configuredUrl = options.baseUrl
-    || env.BLUN_MNEMO_HUB_URL
-    || env.MNEMO_HUB_URL
-    || env.MNEMO_URL
-    || profile?.baseUrl;
-  const baseUrl = cleanHubUrl(configuredUrl);
-  const agentName = cleanString(options.agentName)
-    || cleanString(env.BLUN_MNEMO_AGENT)
-    || cleanString(env.MNEMO_AGENT)
-    || profile?.agentName;
-  return baseUrl && agentName ? { baseUrl, agentName } : null;
-}
-
-function isLoopOnlyMessage(message) {
-  const text = String(message?.text || '').trim();
-  const eventKind = String(message?.meta?.event_kind || '').trim();
-  return /^\/loop(?:@[A-Za-z0-9_]+)?(?:\s|$)/iu.test(text)
-    || /^(?:loop_tick|loop_nudge|loop_status|runtime_loop)$/iu.test(eventKind);
-}
-
-function booleanMeta(value) {
-  if (value === true || value === 'true') return true;
-  if (value === false || value === 'false') return false;
-  return undefined;
-}
-
-function buildTelegramCapturePayload(message, options = {}) {
-  if (!message || isLoopOnlyMessage(message)) return null;
-  const meta = message.meta && typeof message.meta === 'object' ? message.meta : {};
-  const chatId = cleanString(meta.chat_id);
-  const messageId = cleanString(meta.message_id);
-  if (!chatId || !messageId) return null;
-  const text = typeof message.text === 'string' ? message.text : '';
-  const actor = cleanString(meta.user) || cleanString(meta.user_id) || 'telegram-user';
-  const actorId = cleanString(meta.user_id);
-  const chatType = cleanString(meta.chat_type);
-  const topic = cleanString(meta.telegram_thread_id) || 'root';
-  const agentName = cleanString(options.agentName);
-  const privateScope = chatType === 'private' && agentName ? `${agentName}:` : '';
-  const refId = `${privateScope}${chatId}:${messageId}`;
-  const channelScope = chatType === 'private' && agentName ? `${agentName}:${chatId}` : chatId;
-  const captureMeta = {
-    chat_id: chatId,
-    message_id: messageId,
-    telegram_thread_id: topic,
-    ...(chatType ? { chat_type: chatType } : {}),
-    ...(cleanString(meta.chat_title) ? { chat_title: cleanString(meta.chat_title) } : {}),
-    ...(actorId ? { user_id: actorId } : {}),
-    ...(booleanMeta(meta.is_bot) === undefined ? {} : { is_bot: booleanMeta(meta.is_bot) }),
-    ...(agentName ? { recipient_agent: agentName } : {}),
-  };
-  return {
-    source: 'telegram',
-    channel: `telegram-chat:${channelScope}`,
-    direction: 'inbound',
-    actor,
-    ...(actorId ? { actor_id: actorId } : {}),
-    speaker: actor,
-    event_kind: 'telegram_message',
-    dedupe_key: `telegram:${refId}`,
-    ref_kind: 'telegram_message',
-    ref_id: refId,
-    thread_id: `${channelScope}:${topic}`,
-    ...(cleanString(meta.ts) ? { occurred_at: cleanString(meta.ts) } : {}),
-    content: text,
-    promote_transcript: true,
-    promote_memory: false,
-    meta: captureMeta,
-  };
-}
-
-async function postMnemoTool(baseUrl, tool, payload, options = {}) {
-  const controller = new AbortController();
-  const timer = (options.setTimeoutImpl || setTimeout)(
-    () => controller.abort(),
-    options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-  );
-  timer.unref?.();
-  try {
-    const response = await (options.fetchImpl || fetch)(
-      `${baseUrl}/tool/${encodeURIComponent(tool)}`,
-      {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify(payload),
-        signal: controller.signal,
-      },
-    );
-    if (!response.ok) throw new Error(`Mnemo ${tool} HTTP ${response.status}`);
-    const body = await response.json();
-    if (body && body.error) throw new Error(String(body.error));
-    return body;
-  } finally {
-    (options.clearTimeoutImpl || clearTimeout)(timer);
-  }
-}
-
-function readCheckpoint(file) {
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return Number.isSafeInteger(parsed.offset) && parsed.offset >= 0 ? parsed.offset : 0;
-  } catch {
-    return 0;
-  }
-}
-
-function readPending(queueFile, offset) {
-  try {
-    const bytes = fs.readFileSync(queueFile);
-    if (offset < 0 || offset > bytes.length) offset = 0;
-    const pending = [];
-    let cursor = offset;
-    while (cursor < bytes.length) {
-      const newline = bytes.indexOf(10, cursor);
-      if (newline < 0) break;
-      const endOffset = newline + 1;
-      const line = bytes.subarray(cursor, newline).toString('utf8').trim();
-      cursor = endOffset;
-      if (!line) continue;
-      try {
-        const parsed = JSON.parse(line);
-        if (parsed && typeof parsed.payload === 'object') pending.push({
-          payload: parsed.payload,
-          endOffset,
-        });
-      } catch {
-        // A malformed historical row is skipped; later valid receipts still drain.
-      }
-    }
-    return pending;
-  } catch {
-    return [];
-  }
-}
-
-function writeCheckpoint(file, offset) {
-  const temporary = `${file}.${process.pid}.tmp`;
-  fs.writeFileSync(temporary, `${JSON.stringify({ version: 1, offset })}\n`, { mode: 0o600 });
-  fs.renameSync(temporary, file);
-}
-
-function createTelegramMnemoCapture(options = {}) {
-  const config = resolveCaptureConfig(options);
-  if (!config) {
-    return Object.freeze({
-      enabled: false,
-      enqueue: () => false,
-      flush: async () => true,
-      pendingCount: () => 0,
-      stop: async () => {},
-    });
-  }
-
-  const dir = path.resolve(options.stateDir || path.join(process.cwd(), '.telegram'));
-  fs.mkdirSync(dir, { recursive: true });
-  const queueFile = path.join(dir, 'mnemo-capture-queue.jsonl');
-  const checkpointFile = path.join(dir, 'mnemo-capture.checkpoint.json');
-  if (!fs.existsSync(queueFile)) fs.writeFileSync(queueFile, '', { mode: 0o600 });
-  let checkpointOffset = readCheckpoint(checkpointFile);
-  let pending = readPending(queueFile, checkpointOffset);
-  const pendingKeys = new Set(pending.map((item) => item.payload.dedupe_key));
-  const callTool = options.callTool
-    || ((tool, payload) => postMnemoTool(config.baseUrl, tool, payload, options));
-  const retryMs = options.retryMs ?? DEFAULT_RETRY_MS;
-  const onError = typeof options.onError === 'function' ? options.onError : () => {};
-  let stopped = false;
-  let activeFlush = null;
-  let retryTimer = null;
-
-  const schedule = (delay = 0) => {
-    if (stopped || options.autoStart === false || retryTimer !== null || pending.length === 0) return;
-    retryTimer = setTimeout(() => {
-      retryTimer = null;
-      void flush();
-    }, delay);
-    retryTimer.unref?.();
-  };
-
-  const flush = async () => {
-    if (activeFlush) return activeFlush;
-    activeFlush = (async () => {
-      while (!stopped && pending.length > 0) {
-        const item = pending[0];
-        try {
-          await callTool('mem_capture_ingest', item.payload);
-        } catch (error) {
-          onError(error);
-          schedule(retryMs);
-          return false;
-        }
-        pending.shift();
-        pendingKeys.delete(item.payload.dedupe_key);
-        checkpointOffset = item.endOffset;
-        writeCheckpoint(checkpointFile, checkpointOffset);
-      }
-      return pending.length === 0;
-    })().finally(() => {
-      activeFlush = null;
-    });
-    return activeFlush;
-  };
-
-  const enqueue = (message) => {
-    if (stopped) return false;
-    const payload = buildTelegramCapturePayload(message, { agentName: config.agentName });
-    if (!payload || pendingKeys.has(payload.dedupe_key)) return false;
-    const line = `${JSON.stringify({ version: 1, payload })}\n`;
-    const startOffset = fs.statSync(queueFile).size;
-    fs.appendFileSync(queueFile, line, { encoding: 'utf8', mode: 0o600 });
-    const item = {
-      payload,
-      endOffset: startOffset + Buffer.byteLength(line),
-    };
-    pending.push(item);
-    pendingKeys.add(payload.dedupe_key);
-    schedule();
-    return true;
-  };
-
-  if (pending.length > 0) schedule();
-  return Object.freeze({
-    enabled: true,
-    agentName: config.agentName,
-    baseUrl: config.baseUrl,
-    enqueue,
-    flush,
-    pendingCount: () => pending.length,
-    async stop() {
-      stopped = true;
-      if (retryTimer !== null) clearTimeout(retryTimer);
-      retryTimer = null;
-      if (activeFlush) await activeFlush;
-    },
-  });
-}
-
-module.exports = {
-  buildTelegramCapturePayload,
-  createTelegramMnemoCapture,
-  isLoopOnlyMessage,
-  postMnemoTool,
-  readProfileMnemoConfig,
-  resolveCaptureConfig,
-};