@thibautrey/chatons-channel-telegram 1.0.0

package/README.md

@@ -0,0 +1,16 @@
+# @thibautrey/chatons-channel-telegram
+
+Telegram channel extension for Chatons.
+
+## Files
+
+- `chaton.extension.json`: extension manifest
+- `index.html`: main webview entry
+- `index.js`: Telegram channel UI and host integration logic
+- `components.js`: shared UI helpers and styles
+
+## Publish
+
+```bash
+npm publish --access public
+```

package/chaton.extension.json

@@ -0,0 +1,38 @@
+{
+  "id": "@thibautrey/chatons-channel-telegram",
+  "name": "Telegram Channel",
+  "version": "1.0.0",
+  "kind": "channel",
+  "capabilities": [
+    "ui.mainView",
+    "storage.kv",
+    "queue.publish",
+    "queue.consume",
+    "events.subscribe",
+    "events.publish",
+    "host.notifications",
+    "host.conversations.read",
+    "host.conversations.write"
+  ],
+  "ui": {
+    "mainViews": [
+      {
+        "viewId": "telegram.main",
+        "title": "Telegram",
+        "webviewUrl": "chaton-extension://@thibautrey/chatons-channel-telegram/index.html",
+        "initialRoute": "/"
+      }
+    ]
+  },
+  "apis": {
+    "exposes": [
+      { "name": "channel.connect", "version": "1.0.0" },
+      { "name": "channel.disconnect", "version": "1.0.0" },
+      { "name": "channel.status", "version": "1.0.0" },
+      { "name": "channel.receive", "version": "1.0.0" },
+      { "name": "channel.send", "version": "1.0.0" },
+      { "name": "telegram.poll_once", "version": "1.0.0" },
+      { "name": "telegram.get_updates", "version": "1.0.0" }
+    ]
+  }
+}

package/components.js

@@ -0,0 +1,108 @@
+(function () {
+  var STYLE_ID = 'chaton-telegram-extension-style';
+
+  function ensureStyles() {
+    if (document.getElementById(STYLE_ID)) return;
+    var style = document.createElement('style');
+    style.id = STYLE_ID;
+    style.textContent = [
+      ':root {',
+      '  --ce-bg: hsl(220 12% 96%);',
+      '  --ce-fg: hsl(222 12% 14%);',
+      '  --ce-card: hsl(0 0% 100%);',
+      '  --ce-muted-fg: hsl(220 6% 44%);',
+      '  --ce-border: hsl(220 9% 85%);',
+      '  --ce-input: hsl(220 9% 85%);',
+      '  --ce-primary: hsl(220 7% 32%);',
+      '  --ce-primary-fg: hsl(0 0% 100%);',
+      '  --ce-accent: hsl(220 10% 93%);',
+      '  --ce-success: hsl(145 48% 42%);',
+      '  --ce-danger: hsl(0 62% 52%);',
+      '}',
+      ':root.dark {',
+      '  --ce-bg: hsl(220 24% 10%);',
+      '  --ce-fg: hsl(214 32% 93%);',
+      '  --ce-card: hsl(220 22% 14%);',
+      '  --ce-muted-fg: hsl(216 18% 72%);',
+      '  --ce-border: hsl(220 18% 24%);',
+      '  --ce-input: hsl(220 18% 24%);',
+      '  --ce-primary: hsl(214 30% 82%);',
+      '  --ce-primary-fg: hsl(220 24% 12%);',
+      '  --ce-accent: hsl(220 18% 20%);',
+      '  --ce-success: hsl(145 48% 58%);',
+      '  --ce-danger: hsl(0 72% 70%);',
+      '}',
+      '.ce-root, .ce-root * { box-sizing: border-box; }',
+      '.ce-root { min-height: 100vh; color: var(--ce-fg); background: var(--ce-bg); font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }',
+      '.ce-page { max-width: 1080px; margin: 0 auto; padding: 24px; display: grid; gap: 18px; }',
+      '.ce-header { display: flex; justify-content: space-between; gap: 16px; align-items: flex-start; }',
+      '.ce-title { margin: 0; font-size: clamp(30px, 5vw, 42px); font-weight: 700; letter-spacing: -0.03em; }',
+      '.ce-subtitle { margin: 8px 0 0; color: var(--ce-muted-fg); line-height: 1.5; max-width: 760px; }',
+      '.ce-grid { display: grid; gap: 16px; }',
+      '.ce-grid--2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }',
+      '.ce-card { background: color-mix(in srgb, var(--ce-card) 86%, transparent); border: 1px solid color-mix(in srgb, var(--ce-border) 76%, transparent); border-radius: 24px; backdrop-filter: blur(16px); box-shadow: 0 18px 40px rgba(15, 23, 42, 0.08); }',
+      '.ce-card__body { padding: 20px; display: grid; gap: 14px; }',
+      '.ce-section-title { margin: 0; font-size: 18px; font-weight: 650; }',
+      '.ce-copy { margin: 0; color: var(--ce-muted-fg); font-size: 14px; line-height: 1.5; }',
+      '.ce-field { display: grid; gap: 6px; }',
+      '.ce-label { font-size: 13px; font-weight: 650; }',
+      '.ce-input, .ce-textarea, .ce-select { width: 100%; border: 1px solid var(--ce-input); background: var(--ce-card); color: var(--ce-fg); border-radius: 14px; padding: 11px 12px; font: inherit; }',
+      '.ce-textarea { min-height: 100px; resize: vertical; }',
+      '.ce-button { display: inline-flex; align-items: center; justify-content: center; min-height: 42px; border-radius: 14px; border: 1px solid transparent; padding: 0 16px; font-size: 14px; font-weight: 650; cursor: pointer; }',
+      '.ce-button--default { background: var(--ce-primary); color: var(--ce-primary-fg); }',
+      '.ce-button--outline { background: var(--ce-card); color: var(--ce-fg); border-color: var(--ce-border); }',
+      '.ce-button--ghost { background: transparent; color: var(--ce-muted-fg); }',
+      '.ce-inline { display: flex; gap: 10px; align-items: center; flex-wrap: wrap; }',
+      '.ce-badge { display: inline-flex; align-items: center; min-height: 24px; border-radius: 999px; padding: 0 10px; font-size: 12px; font-weight: 700; border: 1px solid var(--ce-border); }',
+      '.ce-badge--success { color: var(--ce-success); }',
+      '.ce-badge--danger { color: var(--ce-danger); }',
+      '.ce-badge--muted { color: var(--ce-muted-fg); }',
+      '.ce-list { display: grid; gap: 10px; }',
+      '.ce-row { display: flex; justify-content: space-between; gap: 12px; align-items: flex-start; border: 1px solid var(--ce-border); background: color-mix(in srgb, var(--ce-card) 72%, transparent); border-radius: 16px; padding: 14px; }',
+      '.ce-row__title { margin: 0; font-size: 15px; font-weight: 650; }',
+      '.ce-row__meta { margin: 4px 0 0; color: var(--ce-muted-fg); font-size: 13px; line-height: 1.45; white-space: pre-wrap; }',
+      '.ce-note { border-left: 3px solid var(--ce-border); padding-left: 12px; color: var(--ce-muted-fg); font-size: 13px; line-height: 1.5; }',
+      '@media (max-width: 900px) { .ce-grid--2 { grid-template-columns: 1fr; } .ce-header { flex-direction: column; } }'
+    ].join('\n');
+    document.head.appendChild(style);
+  }
+
+  function el(tag, className, text) {
+    var node = document.createElement(tag);
+    if (className) node.className = className;
+    if (typeof text === 'string') node.textContent = text;
+    return node;
+  }
+
+  function createButton(opts) {
+    var node = el('button', 'ce-button ce-button--' + ((opts && opts.variant) || 'default'));
+    node.type = (opts && opts.type) || 'button';
+    node.textContent = (opts && opts.text) || '';
+    return node;
+  }
+
+  function createCard() {
+    var root = el('section', 'ce-card');
+    var body = el('div', 'ce-card__body');
+    root.appendChild(body);
+    return { root: root, body: body };
+  }
+
+  function createField(labelText, input, help) {
+    var wrap = el('div', 'ce-field');
+    var label = el('label', 'ce-label', labelText);
+    if (input && input.id) label.htmlFor = input.id;
+    wrap.appendChild(label);
+    wrap.appendChild(input);
+    if (help) wrap.appendChild(el('div', 'ce-copy', help));
+    return wrap;
+  }
+
+  window.telegramChannelUi = {
+    ensureStyles: ensureStyles,
+    el: el,
+    createButton: createButton,
+    createCard: createCard,
+    createField: createField,
+  };
+})();

package/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="fr">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Telegram Channel</title>
+  </head>
+  <body>
+    <div id="app" class="ce-root"></div>
+    <script src="./components.js"></script>
+    <script src="./index.js"></script>
+  </body>
+</html>

package/index.js

@@ -0,0 +1,474 @@
+(function () {
+  var EXTENSION_ID = '@chaton/channel-telegram';
+  var ui = window.telegramChannelUi;
+  if (!ui) throw new Error('telegramChannelUi is required');
+  ui.ensureStyles();
+
+  function syncThemeClass() {
+    var root = document.documentElement;
+    if (!root) return;
+    root.classList.toggle('dark', !!(window.parent && window.parent.document && window.parent.document.documentElement && window.parent.document.documentElement.classList.contains('dark')));
+  }
+  syncThemeClass();
+
+  var MODEL_KEY = 'chatons:telegram-channel:model';
+  var app = document.getElementById('app');
+  var state = {
+    status: null,
+    log: [],
+    updates: [],
+    conversations: [],
+    allModels: [],
+    modelPicker: null,
+  };
+
+  function log(msg) {
+    state.log.unshift({ at: new Date().toISOString(), message: String(msg || '') });
+    state.log = state.log.slice(0, 20);
+    renderLog();
+  }
+
+  function relTime(iso) {
+    var ts = Date.parse(iso);
+    if (!Number.isFinite(ts)) return 'unknown';
+    var diff = Math.max(0, Date.now() - ts);
+    var sec = Math.floor(diff / 1000);
+    if (sec < 60) return sec + 's';
+    var min = Math.floor(sec / 60);
+    if (min < 60) return min + 'm';
+    var h = Math.floor(min / 60);
+    if (h < 24) return h + 'h';
+    return Math.floor(h / 24) + 'd';
+  }
+
+  function extensionCall(api, payload) {
+    return window.chaton.extensionCall('chatons-ui', EXTENSION_ID, api, '^1.0.0', payload);
+  }
+
+  async function kvGet(key) {
+    var res = await window.chaton.extensionStorageKvGet(EXTENSION_ID, key);
+    return res && res.ok ? res.data : null;
+  }
+
+  async function kvSet(key, value) {
+    return window.chaton.extensionStorageKvSet(EXTENSION_ID, key, value);
+  }
+
+  async function hostNotify(title, body) {
+    return window.chaton.extensionHostCall(EXTENSION_ID, 'notifications.notify', { title: title, body: body });
+  }
+
+  async function getStatus() {
+    var statusRes = await extensionCall('channel.status', {});
+    if (statusRes && statusRes.ok) {
+      state.status = statusRes.data || null;
+    } else {
+      state.status = null;
+    }
+    renderStatus();
+  }
+
+  async function loadConversations() {
+    var res = await window.chaton.extensionHostCall(EXTENSION_ID, 'conversations.list', {});
+    state.conversations = res && res.ok && Array.isArray(res.data) ? res.data : [];
+  }
+
+  async function fetchTelegramUpdates(token, offset, limit) {
+    var url = 'https://api.telegram.org/bot' + encodeURIComponent(token) + '/getUpdates?timeout=1&allowed_updates=%5B%22message%22%5D';
+    if (typeof offset === 'number' && Number.isFinite(offset)) url += '&offset=' + encodeURIComponent(String(offset));
+    if (typeof limit === 'number' && Number.isFinite(limit)) url += '&limit=' + encodeURIComponent(String(limit));
+    var response = await fetch(url);
+    var json = await response.json();
+    return json;
+  }
+
+  function splitModelKey(modelKey) {
+    if (typeof modelKey !== 'string') return { provider: null, modelId: null };
+    var idx = modelKey.indexOf('/');
+    if (idx <= 0 || idx >= modelKey.length - 1) return { provider: null, modelId: null };
+    return { provider: modelKey.slice(0, idx), modelId: modelKey.slice(idx + 1) };
+  }
+
+  async function sendTelegramMessage(token, chatId, text) {
+    var response = await fetch('https://api.telegram.org/bot' + encodeURIComponent(token) + '/sendMessage', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ chat_id: chatId, text: text })
+    });
+    return response.json();
+  }
+
+  function buildShell() {
+    app.innerHTML = '';
+    var page = ui.el('div', 'ce-page');
+    var header = ui.el('div', 'ce-header');
+    var headerText = ui.el('div', '');
+    headerText.appendChild(ui.el('h1', 'ce-title', 'Telegram'));
+    headerText.appendChild(ui.el('p', 'ce-subtitle', 'Connecte un bot Telegram a Chatons. Cette extension gere la configuration, le polling, le statut, et les tests d\'envoi. En l\'etat actuel du host, l\'injection directe des messages Telegram dans les threads Chatons reste limitee par l\'absence d\'une API host dediee d\'ingestion externe.'));
+    header.appendChild(headerText);
+    page.appendChild(header);
+
+    var grid = ui.el('div', 'ce-grid ce-grid--2');
+
+    var configCard = ui.createCard();
+    configCard.body.appendChild(ui.el('h2', 'ce-section-title', 'Configuration'));
+    configCard.body.appendChild(ui.el('p', 'ce-copy', 'Renseignez le token du bot Telegram et les options de polling.'));
+    var tokenInput = ui.el('input', 'ce-input');
+    tokenInput.id = 'token';
+    tokenInput.placeholder = '123456:ABCDEF...';
+    var usernameInput = ui.el('input', 'ce-input');
+    usernameInput.id = 'botUsername';
+    usernameInput.placeholder = 'my_chaton_bot';
+    var pollLimitInput = ui.el('input', 'ce-input');
+    pollLimitInput.id = 'pollLimit';
+    pollLimitInput.type = 'number';
+    pollLimitInput.min = '1';
+    pollLimitInput.value = '10';
+    var modelPickerHost = ui.el('div', '');
+    modelPickerHost.id = 'modelPickerHost';
+    var testChatIdInput = ui.el('input', 'ce-input');
+    testChatIdInput.id = 'testChatId';
+    testChatIdInput.placeholder = '123456789';
+    var testMessageInput = ui.el('textarea', 'ce-textarea');
+    testMessageInput.id = 'testMessage';
+    testMessageInput.value = 'Hello from Chatons Telegram Channel';
+
+    configCard.body.appendChild(ui.createField('Bot token', tokenInput, 'Stocke dans l\'espace KV de l\'extension.'));
+    configCard.body.appendChild(ui.createField('Bot username', usernameInput, 'Optionnel, pour affichage et verification.'));
+    configCard.body.appendChild(ui.createField('Modele Chatons', modelPickerHost, 'Utilise le model selector de Chatons pour choisir le modele du channel Telegram.'));
+    configCard.body.appendChild(ui.createField('Polling limit', pollLimitInput, 'Nombre max d\'updates recuperes par appel.'));
+    configCard.body.appendChild(ui.createField('Chat ID de test', testChatIdInput, 'Utilise pour envoyer un message de test.'));
+    configCard.body.appendChild(ui.createField('Message de test', testMessageInput));
+
+    var configActions = ui.el('div', 'ce-inline');
+    var saveBtn = ui.createButton({ text: 'Sauvegarder', variant: 'default' });
+    var connectBtn = ui.createButton({ text: 'Connecter', variant: 'outline' });
+    var disconnectBtn = ui.createButton({ text: 'Deconnecter', variant: 'ghost' });
+    var pollBtn = ui.createButton({ text: 'Poll une fois', variant: 'outline' });
+    var testSendBtn = ui.createButton({ text: 'Envoyer test', variant: 'outline' });
+    configActions.appendChild(saveBtn);
+    configActions.appendChild(connectBtn);
+    configActions.appendChild(disconnectBtn);
+    configActions.appendChild(pollBtn);
+    configActions.appendChild(testSendBtn);
+    configCard.body.appendChild(configActions);
+
+    var statusCard = ui.createCard();
+    statusCard.body.appendChild(ui.el('h2', 'ce-section-title', 'Statut'));
+    statusCard.body.appendChild(ui.el('p', 'ce-copy', 'Connexion, offsets Telegram, conversations mappees et diagnostics.'));
+    var statusWrap = ui.el('div', 'ce-grid');
+    statusWrap.id = 'status';
+    statusCard.body.appendChild(statusWrap);
+
+    grid.appendChild(configCard.root);
+    grid.appendChild(statusCard.root);
+
+    var updatesCard = ui.createCard();
+    updatesCard.body.appendChild(ui.el('h2', 'ce-section-title', 'Dernieres updates Telegram'));
+    updatesCard.body.appendChild(ui.el('p', 'ce-copy', 'Les messages entrants detectes par polling apparaissent ici.'));
+    var updatesList = ui.el('div', 'ce-list');
+    updatesList.id = 'updates';
+    updatesCard.body.appendChild(updatesList);
+
+    var logCard = ui.createCard();
+    logCard.body.appendChild(ui.el('h2', 'ce-section-title', 'Journal'));
+    logCard.body.appendChild(ui.el('p', 'ce-copy', 'Trace locale de l\'extension.'));
+    var logList = ui.el('div', 'ce-list');
+    logList.id = 'log';
+    logCard.body.appendChild(logList);
+
+    page.appendChild(grid);
+    page.appendChild(updatesCard.root);
+    page.appendChild(logCard.root);
+    app.appendChild(page);
+
+    return {
+      tokenInput: tokenInput,
+      usernameInput: usernameInput,
+      pollLimitInput: pollLimitInput,
+      modelPickerHost: modelPickerHost,
+      testChatIdInput: testChatIdInput,
+      testMessageInput: testMessageInput,
+      saveBtn: saveBtn,
+      connectBtn: connectBtn,
+      disconnectBtn: disconnectBtn,
+      pollBtn: pollBtn,
+      testSendBtn: testSendBtn,
+      statusWrap: statusWrap,
+      updatesList: updatesList,
+      logList: logList,
+    };
+  }
+
+  var refs = buildShell();
+
+  function renderStatus() {
+    refs.statusWrap.innerHTML = '';
+    var s = state.status;
+    if (!s) {
+      refs.statusWrap.appendChild(ui.el('div', 'ce-note', 'Aucun statut charge.'));
+      return;
+    }
+    var rows = [
+      ['Connexion', s.connected ? 'connecte' : 'deconnecte'],
+      ['Provider', s.provider || 'telegram'],
+      ['Bot', s.account && s.account.label ? s.account.label : 'n/a'],
+      ['Mapped threads', String((s.counters && s.counters.mappedThreads) || 0)],
+      ['Pending inbound', String((s.counters && s.counters.pendingInbound) || 0)],
+      ['Pending outbound', String((s.counters && s.counters.pendingOutbound) || 0)],
+      ['Dead letters', String((s.counters && s.counters.deadLetters) || 0)],
+      ['Last inbound', s.lastInboundAt ? relTime(s.lastInboundAt) : 'never'],
+      ['Last outbound', s.lastOutboundAt ? relTime(s.lastOutboundAt) : 'never'],
+      ['Last update offset', String(s.lastUpdateOffset || 0)],
+      ['Modele', s.modelKey || 'non selectionne'],
+      ['Bridge limitation', s.bridgeReady ? 'host bridge available' : 'host bridge missing'],
+    ];
+    rows.forEach(function (entry) {
+      var row = ui.el('div', 'ce-row');
+      var left = ui.el('div', '');
+      left.appendChild(ui.el('p', 'ce-row__title', entry[0]));
+      row.appendChild(left);
+      row.appendChild(ui.el('div', 'ce-row__meta', entry[1]));
+      refs.statusWrap.appendChild(row);
+    });
+  }
+
+  function renderUpdates() {
+    refs.updatesList.innerHTML = '';
+    if (!state.updates.length) {
+      refs.updatesList.appendChild(ui.el('div', 'ce-note', 'Aucune update Telegram recente.'));
+      return;
+    }
+    state.updates.forEach(function (update) {
+      var row = ui.el('div', 'ce-row');
+      var left = ui.el('div', '');
+      left.appendChild(ui.el('p', 'ce-row__title', 'Update #' + update.update_id + ' - chat ' + (update.chat_id || 'unknown')));
+      left.appendChild(ui.el('div', 'ce-row__meta', (update.text || '[no text]') + '\nfrom: ' + (update.from_name || 'unknown') + ' (' + (update.from_id || 'n/a') + ')'));
+      row.appendChild(left);
+      row.appendChild(ui.el('div', 'ce-row__meta', update.receivedAt ? relTime(update.receivedAt) : 'now'));
+      refs.updatesList.appendChild(row);
+    });
+  }
+
+  function renderLog() {
+    refs.logList.innerHTML = '';
+    if (!state.log.length) {
+      refs.logList.appendChild(ui.el('div', 'ce-note', 'Aucun evenement journalise.'));
+      return;
+    }
+    state.log.forEach(function (entry) {
+      var row = ui.el('div', 'ce-row');
+      var left = ui.el('div', '');
+      left.appendChild(ui.el('p', 'ce-row__title', entry.message));
+      left.appendChild(ui.el('div', 'ce-row__meta', entry.at));
+      row.appendChild(left);
+      refs.logList.appendChild(row);
+    });
+  }
+
+  async function loadModels() {
+    if (!window.chatonUi || typeof window.chatonUi.createModelPicker !== 'function') return;
+    var res = await window.chaton.listPiModels();
+    if (!res || !res.ok) return;
+    state.allModels = Array.isArray(res.models) ? res.models : [];
+    if (state.modelPicker) {
+      state.modelPicker.setModels(state.allModels);
+      var cfg = await kvGet('telegram.config');
+      var saved = cfg && typeof cfg === 'object' && typeof cfg.modelKey === 'string' ? cfg.modelKey : localStorage.getItem(MODEL_KEY);
+      state.modelPicker.setSelected(saved || null);
+      var selected = state.modelPicker.getSelected();
+      if (selected) localStorage.setItem(MODEL_KEY, selected);
+    }
+  }
+
+  async function loadConfigIntoForm() {
+    var cfg = await kvGet('telegram.config');
+    cfg = cfg && typeof cfg === 'object' ? cfg : {};
+    refs.tokenInput.value = cfg.token || '';
+    refs.usernameInput.value = cfg.botUsername || '';
+    refs.pollLimitInput.value = String(cfg.pollLimit || 10);
+    refs.testChatIdInput.value = cfg.testChatId || '';
+    refs.testMessageInput.value = cfg.testMessage || 'Hello from Chatons Telegram Channel';
+    if (state.modelPicker) {
+      state.modelPicker.setSelected(typeof cfg.modelKey === 'string' ? cfg.modelKey : (localStorage.getItem(MODEL_KEY) || null));
+    }
+    state.updates = Array.isArray(cfg.lastUpdates) ? cfg.lastUpdates : [];
+    renderUpdates();
+  }
+
+  async function saveConfigFromForm() {
+    var modelKey = state.modelPicker ? state.modelPicker.getSelected() : null;
+    if (modelKey) localStorage.setItem(MODEL_KEY, modelKey);
+    var cfg = {
+      token: String(refs.tokenInput.value || '').trim(),
+      botUsername: String(refs.usernameInput.value || '').trim(),
+      modelKey: modelKey,
+      pollLimit: Math.max(1, Number(refs.pollLimitInput.value || 10) || 10),
+      testChatId: String(refs.testChatIdInput.value || '').trim(),
+      testMessage: String(refs.testMessageInput.value || '').trim(),
+    };
+    await kvSet('telegram.config', cfg);
+    log('Configuration sauvegardee');
+    return cfg;
+  }
+
+  async function processTelegramUpdatesFromApi(result) {
+    var cfg = await kvGet('telegram.config');
+    cfg = cfg && typeof cfg === 'object' ? cfg : {};
+    var normalized = [];
+    var updates = result && result.ok && Array.isArray(result.result) ? result.result : [];
+    var maxUpdateId = Number(cfg.lastUpdateOffset || 0);
+
+    for (var i = 0; i < updates.length; i += 1) {
+      var update = updates[i] || {};
+      var message = update.message || {};
+      var chat = message.chat || {};
+      var from = message.from || {};
+      var text = typeof message.text === 'string' ? message.text : '';
+      var updateId = Number(update.update_id || 0);
+      if (updateId > maxUpdateId) maxUpdateId = updateId;
+      if (!text.trim()) continue;
+
+      var item = {
+        update_id: updateId,
+        message_id: String(message.message_id || updateId || ''),
+        chat_id: String(chat.id || ''),
+        from_id: String(from.id || ''),
+        from_name: [from.first_name, from.last_name].filter(Boolean).join(' ').trim() || from.username || 'unknown',
+        text: text,
+        receivedAt: new Date().toISOString(),
+      };
+      normalized.push(item);
+
+      var mappingKey = 'telegram:' + item.chat_id;
+      var threadRes = await window.chaton.extensionHostCall(EXTENSION_ID, 'channels.upsertGlobalThread', {
+        mappingKey: mappingKey,
+        title: item.from_name ? ('Telegram - ' + item.from_name) : ('Telegram - ' + item.chat_id),
+        modelKey: cfg.modelKey || null,
+      });
+      if (!threadRes || !threadRes.ok || !threadRes.data || !threadRes.data.conversation || !threadRes.data.conversation.id) {
+        log('Impossible de creer/resoudre le thread global pour chat ' + item.chat_id);
+        continue;
+      }
+
+      var ingestRes = await window.chaton.extensionHostCall(EXTENSION_ID, 'channels.ingestMessage', {
+        conversationId: threadRes.data.conversation.id,
+        message: item.text,
+        idempotencyKey: item.message_id,
+        metadata: {
+          remoteThreadId: item.chat_id,
+          remoteUserId: item.from_id,
+          remoteUserName: item.from_name,
+          provider: 'telegram',
+          source: 'poll',
+          updateId: item.update_id,
+        },
+      });
+
+      if (ingestRes && ingestRes.ok) {
+        log('Message importe dans Chatons pour chat ' + item.chat_id);
+        if (typeof ingestRes.data.reply === 'string' && ingestRes.data.reply.trim() && cfg.token) {
+          try {
+            await sendTelegramMessage(cfg.token, item.chat_id, ingestRes.data.reply.trim());
+            log('Reponse Chatons renvoyee vers Telegram pour chat ' + item.chat_id);
+          } catch (error) {
+            log('Echec d\'envoi de la reponse Telegram: ' + (error && error.message ? error.message : String(error)));
+          }
+        }
+      } else {
+        log('Echec d\'import Chatons pour chat ' + item.chat_id);
+      }
+    }
+
+    cfg.lastUpdateOffset = maxUpdateId > 0 ? (maxUpdateId + 1) : Number(cfg.lastUpdateOffset || 0);
+    cfg.lastUpdates = normalized.slice(0, 50);
+    await kvSet('telegram.config', cfg);
+    state.updates = cfg.lastUpdates;
+    renderUpdates();
+    return normalized;
+  }
+
+  refs.saveBtn.addEventListener('click', async function () {
+    await saveConfigFromForm();
+    await hostNotify('Telegram', 'Configuration sauvegardee.');
+  });
+
+  refs.connectBtn.addEventListener('click', async function () {
+    var cfg = await saveConfigFromForm();
+    var res = await extensionCall('channel.connect', { config: cfg, interactive: true });
+    log(res && res.ok ? 'Connexion Telegram reussie' : 'Connexion Telegram echouee');
+    await getStatus();
+  });
+
+  refs.disconnectBtn.addEventListener('click', async function () {
+    var res = await extensionCall('channel.disconnect', {});
+    log(res && res.ok ? 'Deconnexion Telegram effectuee' : 'Deconnexion Telegram echouee');
+    await getStatus();
+  });
+
+  refs.pollBtn.addEventListener('click', async function () {
+    var cfg = await saveConfigFromForm();
+    if (!cfg.token) {
+      log('Polling Telegram impossible: token absent');
+      return;
+    }
+    try {
+      var apiResult = await fetchTelegramUpdates(cfg.token, Number(cfg.lastUpdateOffset || 0) || 0, cfg.pollLimit || 10);
+      await processTelegramUpdatesFromApi(apiResult);
+      log('Polling Telegram termine');
+    } catch (error) {
+      log('Polling Telegram echoue: ' + (error && error.message ? error.message : String(error)));
+    }
+    await getStatus();
+  });
+
+  refs.testSendBtn.addEventListener('click', async function () {
+    var cfg = await saveConfigFromForm();
+    if (!cfg.token) {
+      log('Envoi test impossible: token absent');
+      return;
+    }
+    try {
+      var sendResult = await sendTelegramMessage(cfg.token, String(refs.testChatIdInput.value || '').trim(), String(refs.testMessageInput.value || '').trim());
+      log(sendResult && sendResult.ok ? 'Message test envoye' : 'Envoi test echoue');
+    } catch (error) {
+      log('Envoi test echoue: ' + (error && error.message ? error.message : String(error)));
+    }
+    await getStatus();
+  });
+
+  window.addEventListener('message', function (event) {
+    var data = event && event.data;
+    if (!data || data.type !== 'chaton.extension.deeplink') return;
+    var payload = data.payload || {};
+    if (payload.viewId !== 'telegram.main') return;
+    if (payload.target === 'open-create' || payload.target === 'open-config') {
+      refs.tokenInput.focus();
+    }
+  });
+
+  if (window.chatonUi && typeof window.chatonUi.createModelPicker === 'function') {
+    state.modelPicker = window.chatonUi.createModelPicker({
+      host: refs.modelPickerHost,
+      onChange: function (modelKey) {
+        if (modelKey) localStorage.setItem(MODEL_KEY, modelKey);
+      },
+      labels: {
+        filterPlaceholder: 'Filtrer les modeles...',
+        more: 'plus',
+        scopedOnly: 'scoped uniquement',
+        noScoped: 'Aucun modele scoped',
+        noModels: 'Aucun modele disponible'
+      }
+    });
+  }
+
+  (async function init() {
+    await loadConversations();
+    await loadModels();
+    await loadConfigIntoForm();
+    await getStatus();
+    renderLog();
+    log('Extension Telegram initialisee');
+  })();
+})();

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@thibautrey/chatons-channel-telegram",
+  "version": "1.0.0",
+  "description": "Telegram channel extension for Chatons",
+  "private": false,
+  "license": "MIT",
+  "files": [
+    "chaton.extension.json",
+    "index.html",
+    "index.js",
+    "components.js"
+  ],
+  "keywords": [
+    "chatons",
+    "telegram",
+    "extension",
+    "channel"
+  ]
+}