@openlife/cli 1.7.12 → 1.7.14

package/dist/index.js

@@ -2825,6 +2825,91 @@ profileCmd.command('import <file>').description('Import a profile from a JSON fi
         process.exitCode = 1;
     }
 });
+// `openlife telegram` — manage Telegram delivery mode (polling vs webhook)
+const telegramCmd = program
+    .command('telegram')
+    .description('Gerencia o modo de entrega do Telegram (polling vs webhook)');
+telegramCmd
+    .command('status')
+    .description('Mostra modo atual + webhook info')
+    .action(async () => {
+    const token = (process.env.TELEGRAM_BOT_TOKEN || '').trim();
+    if (!token) {
+        console.log(JSON.stringify({ ok: false, error: 'TELEGRAM_BOT_TOKEN ausente' }, null, 2));
+        return;
+    }
+    const { execFileSync } = require('child_process');
+    try {
+        const raw = String(execFileSync('curl', ['-sS', '--max-time', '8', `https://api.telegram.org/bot${token}/getWebhookInfo`], { encoding: 'utf-8' })).trim();
+        const j = JSON.parse(raw);
+        const info = (j && j.result) || {};
+        const mode = info.url ? 'webhook' : 'polling';
+        const onRailway = !!(process.env.RAILWAY_ENVIRONMENT || process.env.RAILWAY_PUBLIC_DOMAIN || process.env.RAILWAY_STATIC_URL);
+        const configured = String(process.env.OPENLIFE_TELEGRAM_MODE || 'auto').toLowerCase();
+        console.log(JSON.stringify({
+            ok: true,
+            mode_telegram_thinks: mode,
+            mode_configured: configured,
+            railway_detected: onRailway,
+            webhook_url: info.url || null,
+            pending_updates: info.pending_update_count || 0,
+            last_error: info.last_error_message || null,
+        }, null, 2));
+    }
+    catch (e) {
+        console.log(JSON.stringify({ ok: false, error: 'getWebhookInfo_failed', detail: e.message }, null, 2));
+        process.exitCode = 1;
+    }
+});
+telegramCmd
+    .command('webhook-set <domain>')
+    .description('Configura webhook (uso típico Railway). Ex: openlife telegram webhook-set https://app.up.railway.app')
+    .option('--path <path>', 'Caminho do webhook (default: /api/v1/telegram/webhook)', '/api/v1/telegram/webhook')
+    .action(async (domain, opts) => {
+    const token = (process.env.TELEGRAM_BOT_TOKEN || '').trim();
+    if (!token) {
+        console.error('TELEGRAM_BOT_TOKEN ausente em .env');
+        process.exitCode = 1;
+        return;
+    }
+    const fullDomain = domain.startsWith('http') ? domain : `https://${domain}`;
+    const url = `${fullDomain.replace(/\/$/, '')}${opts.path}`;
+    const { execFileSync } = require('child_process');
+    try {
+        const raw = String(execFileSync('curl', ['-sS', '--max-time', '8', '-X', 'POST', '-d', `url=${url}`, `https://api.telegram.org/bot${token}/setWebhook`], { encoding: 'utf-8' })).trim();
+        const j = JSON.parse(raw);
+        console.log(JSON.stringify({ ok: !!j.ok, url, telegram_response: j }, null, 2));
+        if (!j.ok)
+            process.exitCode = 1;
+    }
+    catch (e) {
+        console.error('webhook-set falhou:', e.message);
+        process.exitCode = 1;
+    }
+});
+telegramCmd
+    .command('webhook-clear')
+    .description('Remove webhook (volta para polling)')
+    .action(async () => {
+    const token = (process.env.TELEGRAM_BOT_TOKEN || '').trim();
+    if (!token) {
+        console.error('TELEGRAM_BOT_TOKEN ausente');
+        process.exitCode = 1;
+        return;
+    }
+    const { execFileSync } = require('child_process');
+    try {
+        const raw = String(execFileSync('curl', ['-sS', '--max-time', '8', '-X', 'POST', `https://api.telegram.org/bot${token}/deleteWebhook`], { encoding: 'utf-8' })).trim();
+        const j = JSON.parse(raw);
+        console.log(JSON.stringify({ ok: !!j.ok, telegram_response: j }, null, 2));
+        if (!j.ok)
+            process.exitCode = 1;
+    }
+    catch (e) {
+        console.error('webhook-clear falhou:', e.message);
+        process.exitCode = 1;
+    }
+});
 // `openlife config` — interactive configuration TUI (provider, keys, telegram, voice, daemon)
 program
     .command('config')
@@ -2838,8 +2923,19 @@ program
 program
     .command('chat')
     .description('Inicia o chat interativo no terminal (Matrix-themed REPL)')
-    .action(async () => {
-    const { runChat } = require('./cli/ChatTui');
+    .option('--test', 'executa smoke não-interativo do chat e sai')
+    .action(async (opts) => {
+    const { runChat, runChatSmoke } = require('./cli/ChatTui');
+    if (opts.test) {
+        const result = runChatSmoke({ cwd: process.cwd() });
+        console.log(`${result.marker}: ${result.detail}`);
+        console.log(`sessionId=${result.sessionId}`);
+        console.log(`model=${result.model}`);
+        console.log(`cwd=${result.cwd}`);
+        if (!result.ok)
+            process.exitCode = 1;
+        return;
+    }
     await runChat();
 });
 // Bare invocation (no subcommand + interactive TTY) → launch chat TUI.

package/dist/orchestrator/Brain.js

@@ -288,7 +288,46 @@ class Brain {
             const commandArgs = process.platform === 'win32'
                 ? args
                 : ['-k', '2s', `${timeoutSeconds}s`, 'codex', ...args];
-            const { stdout } = await execFile(command, commandArgs, { maxBuffer: 1024 * 1024 * 10, timeout: timeoutMs + 3000, killSignal: 'SIGKILL' });
+            // Codex CLI reads stdin when invoked without a TTY. The promisified
+            // execFile doesn't expose stdio, so it keeps the child's stdin
+            // attached to our (open) pipe — codex then waits forever for input
+            // and our outer timeout fires. Use spawn with `stdio: ['ignore', ...]`
+            // to close stdin explicitly. Fixes ~30s phantom timeouts when the
+            // daemon (non-TTY) calls codex.
+            const stdout = await new Promise((resolve, reject) => {
+                const child = child_process.spawn(command, commandArgs, {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                let stdoutBuf = '';
+                let stderrBuf = '';
+                let killed = false;
+                const watchdog = setTimeout(() => {
+                    killed = true;
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch { /* ignore */ }
+                }, timeoutMs + 3000);
+                child.stdout.on('data', (d) => { stdoutBuf += String(d); });
+                child.stderr.on('data', (d) => { stderrBuf += String(d); });
+                child.on('error', (err) => { clearTimeout(watchdog); reject(err); });
+                child.on('close', (code, signal) => {
+                    clearTimeout(watchdog);
+                    if (killed || code === 124 || (signal && killed)) {
+                        const e = new Error('ETIMEDOUT');
+                        e.code = 'ETIMEDOUT';
+                        reject(e);
+                        return;
+                    }
+                    if (code !== 0) {
+                        const e = new Error(`codex exited with code ${code}: ${stderrBuf.slice(-300)}`);
+                        e.code = String(code);
+                        reject(e);
+                        return;
+                    }
+                    resolve(stdoutBuf);
+                });
+            });
             const lastMessage = fs.existsSync(outputFile) ? fs.readFileSync(outputFile, 'utf-8').trim() : '';
             try {
                 fs.unlinkSync(outputFile);

package/dist/orchestrator/Gateway.js

@@ -344,16 +344,56 @@ class Gateway {
                 await ctx.reply("Erro no módulo de visão ao baixar a imagem.");
             }
         });
-        this.bot.launch().catch((err) => {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (msg.includes('409') || msg.includes('terminated by other getUpdates request')) {
-                console.error('[GATEWAY] Telegram 409 Conflict: outra instância está conectada com este bot. Mantendo processo vivo para healthcheck; Telegram polling fica desativado nesta instância.');
-                return;
+        // Decide Telegram delivery mode:
+        //   - OPENLIFE_TELEGRAM_MODE=polling | webhook | auto (default: auto)
+        //   - "auto" → webhook if a Railway env var is present, else polling.
+        // This is the simplest UX for the "Railway + local" topology: Railway
+        // deploys boot in webhook mode (no polling conflict with local), local
+        // dev boots in polling mode (no webhook URL needed). User changes
+        // nothing.
+        const mode = String(process.env.OPENLIFE_TELEGRAM_MODE || 'auto').toLowerCase();
+        const onRailway = !!(process.env.RAILWAY_ENVIRONMENT || process.env.RAILWAY_PUBLIC_DOMAIN || process.env.RAILWAY_STATIC_URL);
+        const useWebhook = mode === 'webhook' || (mode === 'auto' && onRailway);
+        if (useWebhook) {
+            const webhookPath = process.env.OPENLIFE_WEBHOOK_PATH || '/api/v1/telegram/webhook';
+            // Register webhook handler on the existing Express app — no separate
+            // HTTP server, no port conflict. Telegraf's webhookCallback returns
+            // an Express-compatible middleware that parses updates.
+            this.app.use(webhookPath, this.bot.webhookCallback(webhookPath));
+            const rawDomain = process.env.OPENLIFE_WEBHOOK_DOMAIN
+                || process.env.RAILWAY_PUBLIC_DOMAIN
+                || process.env.RAILWAY_STATIC_URL
+                || '';
+            if (rawDomain) {
+                const domain = rawDomain.startsWith('http') ? rawDomain : `https://${rawDomain}`;
+                const fullUrl = `${domain.replace(/\/$/, '')}${webhookPath}`;
+                this.bot.telegram.setWebhook(fullUrl).then(() => {
+                    console.log(`[GATEWAY] Telegram em modo WEBHOOK @ ${fullUrl}`);
+                }).catch((err) => {
+                    console.error('[GATEWAY] setWebhook falhou:', err instanceof Error ? err.message : String(err));
+                });
             }
-            console.error('[GATEWAY] Falha ao iniciar Telegram bot:', err);
-            process.exit(1);
-        });
-        console.log("[GATEWAY] Telegram Bot escutando com suporte Multimodal (Voz/Visão).");
+            else {
+                console.warn('[GATEWAY] Webhook mode ativado mas OPENLIFE_WEBHOOK_DOMAIN (ou RAILWAY_PUBLIC_DOMAIN) não está definido. Telegram não saberá onde entregar mensagens. Defina o domínio público antes de subir.');
+            }
+            console.log("[GATEWAY] Telegram Bot pronto (modo webhook — sem polling).");
+        }
+        else {
+            // Default polling mode (local dev, single-instance bots).
+            // Clear any previously-registered webhook before polling, otherwise
+            // Telegram rejects getUpdates with 409. Best-effort, non-fatal.
+            this.bot.telegram.deleteWebhook({ drop_pending_updates: false }).catch(() => { });
+            this.bot.launch().catch((err) => {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (msg.includes('409') || msg.includes('terminated by other getUpdates request')) {
+                    console.error('[GATEWAY] Telegram 409 Conflict: outra instância está conectada com este bot. Mantendo processo vivo para healthcheck; Telegram polling fica desativado nesta instância.');
+                    return;
+                }
+                console.error('[GATEWAY] Falha ao iniciar Telegram bot:', err);
+                process.exit(1);
+            });
+            console.log("[GATEWAY] Telegram Bot escutando (modo polling) com suporte Multimodal (Voz/Visão).");
+        }
     }
     async shutdown(reason = 'manual') {
         if (this.isShuttingDown)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlife/cli",
-  "version": "1.7.12",
+  "version": "1.7.14",
   "description": "OPEN-LIFE Córtex Orquestrador Dual-Core",
   "main": "dist/index.js",
   "files": [