@iaforged/context-code 1.0.57 → 1.0.59

package/dist/src/mirrors/shared.js

@@ -118,6 +118,55 @@ function truncate(text, max) {
         return text;
     return `${text.slice(0, max - 1)}…`;
 }
+/** Escapa caracteres especiales de HTML para envío seguro a Telegram con parse_mode HTML. */
+export function escapeHTML(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+/**
+ * Convierte Markdown básico a HTML compatible con Telegram.
+ * Soporta: bloques de código, código inline, negritas, itálicas, tachado.
+ * El texto fuera de esos patrones se escapa para evitar errores de parseo.
+ */
+export function markdownToTelegramHTML(text) {
+    const result = [];
+    // Procesa bloque a bloque para no escapar lo que ya es HTML
+    const codeBlockRe = /```(\w*)\n?([\s\S]*?)```/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = codeBlockRe.exec(text)) !== null) {
+        // Texto antes del bloque de código
+        if (match.index > lastIndex) {
+            result.push(inlineMarkdownToHTML(text.slice(lastIndex, match.index)));
+        }
+        const code = match[2] ?? '';
+        result.push(`<pre><code>${escapeHTML(code.trimEnd())}</code></pre>`);
+        lastIndex = match.index + match[0].length;
+    }
+    // Resto del texto
+    if (lastIndex < text.length) {
+        result.push(inlineMarkdownToHTML(text.slice(lastIndex)));
+    }
+    return result.join('');
+}
+function inlineMarkdownToHTML(text) {
+    // Escape HTML primero, luego restauramos los marcadores de formato
+    let out = escapeHTML(text);
+    // Código inline: `...`
+    out = out.replace(/`([^`]+)`/g, '<code>$1</code>');
+    // Negrita: **texto** o __texto__
+    out = out.replace(/\*\*(.+?)\*\*/g, '<b>$1</b>');
+    out = out.replace(/__(.+?)__/g, '<b>$1</b>');
+    // Itálica: *texto* o _texto_ (no conflicta con negrita ya procesada)
+    out = out.replace(/\*(.+?)\*/g, '<i>$1</i>');
+    out = out.replace(/_(.+?)_/g, '<i>$1</i>');
+    // Tachado: ~~texto~~
+    out = out.replace(/~~(.+?)~~/g, '<s>$1</s>');
+    return out;
+}
 /** Divide un texto en trozos ≤ `max` chars, cortando en newline cuando se puede. */
 export function splitForChannel(text, max) {
     if (text.length <= max)

package/dist/src/telegram/bridge.js

@@ -5,6 +5,7 @@ import { getOpenAICompatibleAccessToken } from '../utils/auth.js';
 import { getConfiguredProviderBaseUrl } from '../utils/model/providerBaseUrls.js';
 import { getStoredActiveProviderPreference, getStoredLastModelForProvider, setStoredActiveProviderPreference, setStoredLastModelForProvider, } from '../utils/model/providerProfilesDb.js';
 import { setMirrorBot } from './mirror.js';
+import { markdownToTelegramHTML, escapeHTML } from '../mirrors/shared.js';
 let activeBotInstance = null;
 let inboundHandler = null;
 export function setTelegramInboundHandler(handler) {
@@ -159,14 +160,14 @@ export async function startTelegramBridge() {
             }
             const model = getActiveModel();
             const provider = getActiveProvider();
-            await ctx.reply(`🚀 *Context Code Bridge Activo*\n\n` +
-                `📡 Proveedor: *${provider}*\n` +
-                `🤖 Modelo: *${model}*\n\n` +
+            await ctx.reply(`🚀 <b>Context Code Bridge Activo</b>\n\n` +
+                `📡 Proveedor: <b>${escapeHTML(provider)}</b>\n` +
+                `🤖 Modelo: <b>${escapeHTML(model)}</b>\n\n` +
                 `Escríbeme cualquier pregunta y la enviaré al modelo.\n\n` +
-                `Comandos disponibles:\n` +
+                `<b>Comandos disponibles:</b>\n` +
                 `/status - Ver estado actual\n` +
-                `/model <nombre> - Cambiar modelo\n` +
-                `/provider <nombre> - Cambiar proveedor`, { parse_mode: 'Markdown' });
+                `/model &lt;nombre&gt; - Cambiar modelo\n` +
+                `/provider &lt;nombre&gt; - Cambiar proveedor`, { parse_mode: 'HTML' });
         });
         // Comando /status
         bot.command('status', async (ctx) => {
@@ -176,10 +177,10 @@ export async function startTelegramBridge() {
                 return;
             const model = getActiveModel();
             const provider = getActiveProvider();
-            await ctx.reply(`📊 *Estado de Context Code*\n\n` +
-                `📡 Proveedor: *${provider}*\n` +
-                `🤖 Modelo: *${model}*\n` +
-                `🔗 Bridge: ✅ Conectado`, { parse_mode: 'Markdown' });
+            await ctx.reply(`📊 <b>Estado de Context Code</b>\n\n` +
+                `📡 Proveedor: <b>${escapeHTML(provider)}</b>\n` +
+                `🤖 Modelo: <b>${escapeHTML(model)}</b>\n` +
+                `🔗 Bridge: ✅ Conectado`, { parse_mode: 'HTML' });
         });
         // Comando /model
         bot.command('model', async (ctx) => {
@@ -190,15 +191,15 @@ export async function startTelegramBridge() {
             const newModel = ctx.match?.trim();
             if (!newModel) {
                 const model = getActiveModel();
-                await ctx.reply(`🤖 Modelo actual: *${model}*`, {
-                    parse_mode: 'Markdown',
+                await ctx.reply(`🤖 Modelo actual: <b>${escapeHTML(model)}</b>`, {
+                    parse_mode: 'HTML',
                 });
                 return;
             }
             const provider = getActiveProvider();
             setStoredLastModelForProvider(provider, newModel);
-            await ctx.reply(`✅ Modelo cambiado a *${newModel}*`, {
-                parse_mode: 'Markdown',
+            await ctx.reply(`✅ Modelo cambiado a <b>${escapeHTML(newModel)}</b>`, {
+                parse_mode: 'HTML',
             });
         });
         // Comando /provider
@@ -210,8 +211,8 @@ export async function startTelegramBridge() {
             const newProvider = ctx.match?.trim();
             if (!newProvider) {
                 const provider = getActiveProvider();
-                await ctx.reply(`📡 Proveedor actual: *${provider}*`, {
-                    parse_mode: 'Markdown',
+                await ctx.reply(`📡 Proveedor actual: <b>${escapeHTML(provider)}</b>`, {
+                    parse_mode: 'HTML',
                 });
                 return;
             }
@@ -229,8 +230,8 @@ export async function startTelegramBridge() {
                 return;
             }
             setStoredActiveProviderPreference(newProvider.toLowerCase());
-            await ctx.reply(`✅ Proveedor cambiado a *${newProvider}*`, {
-                parse_mode: 'Markdown',
+            await ctx.reply(`✅ Proveedor cambiado a <b>${escapeHTML(newProvider)}</b>`, {
+                parse_mode: 'HTML',
             });
         });
         // Mensajes de texto libre
@@ -266,13 +267,15 @@ export async function startTelegramBridge() {
             const provider = getActiveProvider();
             await ctx.replyWithChatAction('typing');
             const response = await queryModel(ctx.message.text, model, provider);
-            const chunks = splitMessage(response);
+            const htmlResponse = markdownToTelegramHTML(response);
+            const chunks = splitMessage(htmlResponse);
             for (const chunk of chunks) {
                 try {
-                    await ctx.reply(chunk, { parse_mode: 'Markdown' });
+                    await ctx.reply(chunk, { parse_mode: 'HTML' });
                 }
                 catch {
-                    await ctx.reply(chunk);
+                    // Fallback: texto plano sin formato
+                    await ctx.reply(chunk.replace(/<[^>]+>/g, ''));
                 }
             }
         });

package/dist/src/telegram/mirror.js

@@ -1,10 +1,23 @@
 import { getPrimaryChatId } from './config.js';
-import { consumeInjectedMarkIfSameOrigin, markInjected, splitForChannel, } from '../mirrors/shared.js';
+import { consumeInjectedMarkIfSameOrigin, markInjected, markdownToTelegramHTML, escapeHTML, splitForChannel, } from '../mirrors/shared.js';
 const PREFIX = {
     user: '👤',
     assistant: '🤖',
     tool: '🔧',
 };
+function formatMirrorMessage(role, text) {
+    const icon = PREFIX[role];
+    if (role === 'assistant') {
+        // Convierte Markdown del modelo a HTML
+        return `${icon} ${markdownToTelegramHTML(text)}`;
+    }
+    if (role === 'tool') {
+        // Herramientas en bloque de código inline para distinguirlas
+        return `${icon} <code>${escapeHTML(text)}</code>`;
+    }
+    // Usuario: texto plano escapado
+    return `${icon} <b>${escapeHTML(text)}</b>`;
+}
 const TELEGRAM_MAX = 4000;
 const SEND_INTERVAL_MS = 150;
 const MAX_QUEUE = 200;
@@ -49,14 +62,20 @@ async function drain() {
             const chatId = getPrimaryChatId();
             if (!chatId)
                 break;
-            const chunks = splitForChannel(`${PREFIX[item.role]} ${item.text}`, TELEGRAM_MAX);
+            const formatted = formatMirrorMessage(item.role, item.text);
+            const chunks = splitForChannel(formatted, TELEGRAM_MAX);
             for (const chunk of chunks) {
                 try {
-                    await botRef.api.sendMessage(chatId, chunk);
+                    await botRef.api.sendMessage(chatId, chunk, { parse_mode: 'HTML' });
                 }
                 catch {
-                    // Si el send falla (token inválido, user bloqueó, etc.) no reintentamos
-                    // este item — seguimos con la cola para no bloquear mensajes nuevos.
+                    // Fallback sin formato si el HTML falla (e.g. tag roto por corte de chunk)
+                    try {
+                        await botRef.api.sendMessage(chatId, `${PREFIX[item.role]} ${item.text}`.slice(0, TELEGRAM_MAX));
+                    }
+                    catch {
+                        // Si el send falla (token inválido, user bloqueó, etc.) no reintentamos
+                    }
                     break;
                 }
                 await sleep(SEND_INTERVAL_MS);

package/dist/src/utils/secureStorage/sqliteStorage.js

@@ -17,6 +17,9 @@ function getDatabasePath() {
 function getKeyPath() {
     return join(getClaudeConfigHomeDir(), KEY_FILENAME);
 }
+function getLegacyCredentialsPath() {
+    return join(getClaudeConfigHomeDir(), '.credentials.json');
+}
 let _db = null;
 let _legacyMigrationAttempted = false;
 let _cachedEncryptionKey = null;
@@ -81,6 +84,20 @@ function savePayload(db, plainText) {
     ON CONFLICT(key) DO UPDATE SET value = excluded.value
   `).run('main_storage', encryptPayload(plainText));
 }
+function getStoredPayload() {
+    const db = getDb();
+    if (!db)
+        return null;
+    try {
+        const row = db
+            .prepare('SELECT value FROM secure_storage WHERE key = ?')
+            .get('main_storage');
+        return typeof row?.value === 'string' ? row.value : null;
+    }
+    catch {
+        return null;
+    }
+}
 function getDb() {
     if (_db)
         return _db;
@@ -177,3 +194,24 @@ export const sqliteStorage = {
         }
     }
 };
+export function getSecureStorageDbPath() {
+    return getDatabasePath();
+}
+export function getSecureStorageKeyPath() {
+    return getKeyPath();
+}
+export function getLegacyCredentialsFilePath() {
+    return getLegacyCredentialsPath();
+}
+export function hasLegacyCredentialsFile() {
+    try {
+        return getFsImplementation().existsSync(getLegacyCredentialsPath());
+    }
+    catch {
+        return false;
+    }
+}
+export function isSecureStorageEncrypted() {
+    const payload = getStoredPayload();
+    return payload ? payload.startsWith(ENCRYPTED_PREFIX) : false;
+}

package/dist/src/utils/status.js

@@ -20,6 +20,7 @@ import { checkInstall } from './nativeInstaller/index.js';
 import { getProxyUrl } from './proxy.js';
 import { SandboxManager } from './sandbox/sandbox-adapter.js';
 import { getSecureStorage } from './secureStorage/index.js';
+import { getLegacyCredentialsFilePath, getSecureStorageDbPath, getSecureStorageKeyPath, hasLegacyCredentialsFile, isSecureStorageEncrypted, } from './secureStorage/sqliteStorage.js';
 import { getSettingsWithAllErrors } from './settings/allErrors.js';
 import { getEnabledSettingSources, getSettingSourceDisplayNameCapitalized } from './settings/constants.js';
 import { getManagedFileSettingsPresence, getPolicySettingsOrigin, getSettingsForSource } from './settings/settings.js';
@@ -313,8 +314,30 @@ export function buildAPIProviderProperties() {
     });
     properties.push({
         label: 'Credenciales providers',
-        value: getSecureStorage().name === 'sqlite' ? 'SQLite' : getSecureStorage().name,
+        value: getSecureStorage().name === 'sqlite'
+            ? 'SQLite (cifrado local)'
+            : getSecureStorage().name,
     });
+    if (getSecureStorage().name === 'sqlite') {
+        properties.push({
+            label: 'Credenciales DB',
+            value: getSecureStorageDbPath(),
+        });
+        properties.push({
+            label: 'Clave cifrado',
+            value: getSecureStorageKeyPath(),
+        });
+        properties.push({
+            label: 'Estado cifrado credenciales',
+            value: isSecureStorageEncrypted() ? 'Cifrado activo' : 'Sin payload o pendiente',
+        });
+        properties.push({
+            label: 'Legacy credentials file',
+            value: hasLegacyCredentialsFile()
+                ? `Presente (${getLegacyCredentialsFilePath()})`
+                : 'No presente',
+        });
+    }
     if (apiProvider !== 'firstParty') {
         const providerLabels = {
             bedrock: 'AWS Bedrock',

package/dist/src/whatsapp/bridge.js

@@ -180,6 +180,15 @@ export async function startLoginWithQr(options) {
         }
     }
     closeSocketSafe(sock);
+    // Force-save credentials before closing so they are on disk even if Baileys
+    // hasn't emitted a creds.update yet. This is the only explicit save point that
+    // guarantees the JID is available to startWhatsAppBridge on the next launch.
+    try {
+        await saveCreds();
+    }
+    catch {
+        // non-fatal: continue and let readSelfIdentity report what was persisted
+    }
     const identity = await readSelfIdentity(authDir);
     if (identity.jid) {
         setSelfIdentity(identity.jid, identity.e164);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iaforged/context-code",
-  "version": "1.0.57",
+  "version": "1.0.59",
   "bin": {
     "context": "context-bootstrap.js",
     "context-recovery": "context-bootstrap.js"