ticlawk 0.1.15-dev.6 → 0.1.16-dev.1

package/src/adapters/telegram/index.mjs

@@ -1,359 +0,0 @@
-import { basename, extname } from 'node:path';
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { randomUUID } from 'node:crypto';
-import { join } from 'node:path';
-import { JsonFileStore } from '../../core/store/json-file-store.mjs';
-import { parseOptionArgs } from '../../core/argv.mjs';
-import { AF_ADAPTER_KEY, AF_HOME, loadPersistentConfig, persistConfig } from '../../core/config.mjs';
-
-const TELEGRAM_API = 'https://api.telegram.org';
-const TEXT_LIMIT = 4000;
-const UNBOUND_REPLY_COOLDOWN_MS = 30000;
-const UNCLAIMED_TARGET_KEY = 'telegram:unclaimed';
-const DEFAULT_BINDING_ID = 'telegram:default';
-
-function splitText(text) {
-  const normalized = String(text || '');
-  if (normalized.length <= TEXT_LIMIT) return [normalized];
-  const chunks = [];
-  for (let index = 0; index < normalized.length; index += TEXT_LIMIT) {
-    chunks.push(normalized.slice(index, index + TEXT_LIMIT));
-  }
-  return chunks;
-}
-
-export function createTelegramAdapter(ctx) {
-  const stateStore = new JsonFileStore(join(AF_HOME, 'telegram-state.json'), {
-    updateOffset: 0,
-    botId: null,
-    username: null,
-  });
-  const typingSentAt = new Map();
-  const unboundReplySentAt = new Map();
-  let polling = false;
-  let stopped = false;
-
-  function getToken() {
-    const config = loadPersistentConfig();
-    return String(process.env.TELEGRAM_BOT_TOKEN || config.TELEGRAM_BOT_TOKEN || '').trim();
-  }
-
-  async function apiCall(method, body, opts = {}) {
-    const token = getToken();
-    if (!token) throw new Error('TELEGRAM_BOT_TOKEN is not configured');
-    const url = `${TELEGRAM_API}/bot${token}/${method}`;
-    const response = await fetch(url, {
-      method: 'POST',
-      body: opts.formData ? body : JSON.stringify(body || {}),
-      headers: opts.formData ? undefined : { 'Content-Type': 'application/json' },
-    });
-    const json = await response.json().catch(() => ({}));
-    if (!response.ok || json.ok === false) {
-      throw new Error(json.description || `telegram ${method} failed`);
-    }
-    return json.result;
-  }
-
-  async function sendMessage(chatId, text, replyToMessageId = null) {
-    const chunks = splitText(text);
-    for (const chunk of chunks) {
-      await apiCall('sendMessage', {
-        chat_id: chatId,
-        text: chunk,
-        ...(replyToMessageId ? { reply_to_message_id: Number(replyToMessageId) } : {}),
-      });
-    }
-  }
-
-  async function sendMedia(chatId, item, replyToMessageId = null) {
-    const formData = new FormData();
-    formData.append('chat_id', String(chatId));
-    if (replyToMessageId) {
-      formData.append('reply_to_message_id', String(replyToMessageId));
-    }
-    const file = new Blob([readFileSync(item.value)], { type: item.mime || 'application/octet-stream' });
-    const fileName = basename(item.value);
-    if ((item.mime || '').startsWith('image/')) {
-      formData.append('photo', file, fileName);
-      await apiCall('sendPhoto', formData, { formData: true });
-    } else {
-      formData.append('document', file, fileName);
-      await apiCall('sendDocument', formData, { formData: true });
-    }
-  }
-
-  async function ensureBotInfo() {
-    const me = await apiCall('getMe', {});
-    await stateStore.update((current) => ({
-      ...current,
-      botId: me.id,
-      username: me.username || null,
-    }));
-    return me;
-  }
-
-  async function downloadTelegramFile(fileId) {
-    const token = getToken();
-    const fileInfo = await apiCall('getFile', { file_id: fileId });
-    const filePath = fileInfo?.file_path;
-    if (!filePath) return null;
-    const url = `${TELEGRAM_API}/file/bot${token}/${filePath}`;
-    const ext = extname(filePath) || '.bin';
-    const localDir = '/tmp/ticlawk/telegram-inbound';
-    mkdirSync(localDir, { recursive: true });
-    const localPath = `${localDir}/${randomUUID()}${ext}`;
-    const response = await fetch(url);
-    const buffer = Buffer.from(await response.arrayBuffer());
-    writeFileSync(localPath, buffer);
-    return localPath;
-  }
-
-  async function normalizeInbound(message) {
-    const media = [];
-    if (Array.isArray(message.photo) && message.photo.length > 0) {
-      const photo = message.photo[message.photo.length - 1];
-      const localPath = await downloadTelegramFile(photo.file_id);
-      if (localPath) {
-        media.push({ kind: 'local_path', value: localPath, mime: 'image/jpeg' });
-      }
-    } else if (message.document?.mime_type?.startsWith('image/')) {
-      const localPath = await downloadTelegramFile(message.document.file_id);
-      if (localPath) {
-        media.push({ kind: 'local_path', value: localPath, mime: message.document.mime_type });
-      }
-    }
-    return {
-      bindingId: `telegram:dm:${message.chat.id}`,
-      messageId: String(message.message_id),
-      text: message.caption || message.text || '',
-      action: media.length > 0 ? 'image' : 'task',
-      media,
-      raw: message,
-    };
-  }
-
-  function getTelegramBinding() {
-    return ctx.getBinding(DEFAULT_BINDING_ID);
-  }
-
-  async function replyWithUnboundMessage(message, text) {
-    const targetKey = `telegram:dm:${message.chat.id}`;
-    const now = Date.now();
-    const lastSentAt = unboundReplySentAt.get(targetKey) || 0;
-    if (now - lastSentAt < UNBOUND_REPLY_COOLDOWN_MS) return;
-    unboundReplySentAt.set(targetKey, now);
-    await sendMessage(message.chat.id, text, message.message_id);
-  }
-
-  async function claimBinding(message, binding) {
-    const chatId = message.chat.id;
-    const targetKey = `telegram:dm:${chatId}`;
-    const claimed = await ctx.upsertBinding({
-      ...binding,
-      targetKey,
-      targetMeta: {
-        chatId,
-        userId: message.from?.id || null,
-        username: message.from?.username || null,
-        firstName: message.from?.first_name || null,
-      },
-      status: 'connected',
-    });
-    await sendMessage(chatId, `Connected this chat to ${claimed.displayName}.`, message.message_id);
-    return claimed;
-  }
-
-  async function handleMessage(message) {
-    if (!message?.chat || message.chat.type !== 'private') return;
-    if (message.from?.is_bot) return;
-    let binding = getTelegramBinding();
-    if (!binding) {
-      await replyWithUnboundMessage(
-        message,
-        'This bot is online, but no local runtime is connected yet. Run `ticlawk connect --adapter telegram --workdir /path/to/project` there first. Add `--session-id <id>` only if you want to resume an existing session.'
-      );
-      return;
-    }
-    if (!binding.targetMeta?.chatId) {
-      binding = await claimBinding(message, binding);
-    } else if (String(binding.targetMeta.chatId) !== String(message.chat.id)) {
-      await replyWithUnboundMessage(message, 'This bot is already connected to another chat.');
-      return;
-    }
-    const inbound = await normalizeInbound(message);
-    inbound.bindingId = binding.id;
-    await ctx.bus.dispatchToAgent(binding.runtime, binding.id, inbound);
-  }
-
-  async function pollLoop() {
-    if (polling) return;
-    polling = true;
-    while (!stopped) {
-      try {
-        const state = stateStore.read();
-        const updates = await apiCall('getUpdates', {
-          timeout: 50,
-          offset: state.updateOffset || 0,
-          allowed_updates: ['message'],
-        });
-        let nextOffset = state.updateOffset || 0;
-        for (const update of updates || []) {
-          nextOffset = Math.max(nextOffset, (update.update_id || 0) + 1);
-          if (update.message) {
-            await handleMessage(update.message);
-          }
-        }
-        if (nextOffset !== (state.updateOffset || 0)) {
-          await stateStore.update((current) => ({ ...current, updateOffset: nextOffset }));
-        }
-      } catch {
-        await new Promise((resolve) => setTimeout(resolve, 3000));
-      }
-    }
-    polling = false;
-  }
-
-  return {
-    id: 'telegram',
-
-    async start() {
-      await ensureBotInfo();
-      void pollLoop();
-    },
-
-    async health() {
-      const binding = getTelegramBinding();
-      const state = stateStore.read();
-      const runtimeHealthEntries = await Promise.all(Object.entries(ctx.runtimes || {})
-        .filter(([, runtime]) => typeof runtime?.health === 'function')
-        .map(async ([name, runtime]) => [name, await runtime.health(binding?.runtimeMeta || {})]));
-      const runtimesHealth = Object.fromEntries(runtimeHealthEntries);
-      const codexHealth = runtimesHealth.codex || {};
-      return {
-        botConfigured: Boolean(getToken()),
-        botId: state.botId || null,
-        botUsername: state.username || null,
-        runtimeConnected: Boolean(binding),
-        connectedChat: Boolean(binding?.targetMeta?.chatId),
-        runtimes: runtimesHealth,
-        codexAvailable: codexHealth.available,
-        codexPath: codexHealth.path || null,
-        codexVersion: codexHealth.version || null,
-      };
-    },
-
-    async connect(payload) {
-      if (!getToken()) {
-        return {
-          statusCode: 400,
-          body: {
-            ok: false,
-            error: 'telegram is not authenticated; run `ticlawk auth telegram --bot-token <token>` first',
-          },
-        };
-      }
-      try {
-        const resolved = await ctx.resolveRuntimeBinding(payload);
-        const existing = getTelegramBinding();
-        const binding = await ctx.upsertBinding({
-          ...(existing || {}),
-          id: DEFAULT_BINDING_ID,
-          adapter: 'telegram',
-          targetKey: existing?.targetKey || UNCLAIMED_TARGET_KEY,
-          targetMeta: existing?.targetMeta || {},
-          runtime: resolved.runtime,
-          runtimeMeta: resolved.runtimeMeta,
-          displayName: resolved.displayName,
-          status: existing?.targetMeta?.chatId ? 'connected' : 'unclaimed',
-        });
-        if (binding.targetMeta?.chatId) {
-          await sendMessage(binding.targetMeta.chatId, `Bound this bot to ${binding.displayName}.`);
-        }
-        return {
-          statusCode: 200,
-          body: {
-            ok: true,
-            adapter: 'telegram',
-            bindingId: binding.id,
-            name: binding.displayName,
-            runtime: binding.runtime,
-            connectedChat: Boolean(binding.targetMeta?.chatId),
-            status: binding.targetMeta?.chatId ? 'connected' : 'unclaimed',
-          },
-        };
-      } catch (err) {
-        return { statusCode: 500, body: { ok: false, error: err.message } };
-      }
-    },
-
-    async send(binding, outbound) {
-      const chatId = binding.targetMeta.chatId;
-      if (!chatId) return;
-      if (outbound.text) {
-        await sendMessage(chatId, outbound.text, outbound.replyToMessageId || null);
-      }
-      for (const item of outbound.media || []) {
-        if (item.kind !== 'local_path') continue;
-        await sendMedia(chatId, item, outbound.replyToMessageId || null);
-      }
-    },
-
-    async emitEvent(binding, payload) {
-      const chatId = binding.targetMeta.chatId;
-      if (!chatId) return;
-      const eventName = payload?.event?.worker_event_name || payload?.event?.hook_event_name;
-      if (eventName !== 'worker.turn.start' && eventName !== 'worker.message.delta') return;
-      const key = String(chatId);
-      const now = Date.now();
-      if (now - (typingSentAt.get(key) || 0) < 4000) return;
-      typingSentAt.set(key, now);
-      await apiCall('sendChatAction', {
-        chat_id: chatId,
-        action: 'typing',
-      }).catch(() => {});
-    },
-  };
-}
-
-export function getTelegramAuthHelp() {
-  return `ticlawk auth telegram --bot-token <bot-token>
-
-Options:
-  --bot-token <token>   Telegram bot token from @BotFather
-`;
-}
-
-export async function runTelegramAuth(rawArgs) {
-  const args = parseOptionArgs(rawArgs);
-  if (args.help || args.h) {
-    return {
-      statusCode: 200,
-      body: {
-        ok: true,
-        help: getTelegramAuthHelp(),
-      },
-    };
-  }
-  const botToken = String(args['bot-token'] || '').trim();
-  if (!botToken) {
-    return {
-      statusCode: 400,
-      body: {
-        ok: false,
-        error: 'telegram auth requires --bot-token',
-      },
-    };
-  }
-  persistConfig({
-    [AF_ADAPTER_KEY]: 'telegram',
-    TELEGRAM_BOT_TOKEN: botToken,
-  });
-  return {
-    statusCode: 200,
-    body: {
-      ok: true,
-      adapter: 'telegram',
-      botToken: 'set',
-    },
-  };
-}