@openlife/cli 1.7.11 → 1.7.13

package/dist/cli/ProviderSelector.js

@@ -0,0 +1,178 @@
+"use strict";
+// src/cli/ProviderSelector.ts
+// Reusable arrow-key radio menu — used by ConfigTui and any TUI that
+// needs a "pick one of N options" interaction.
+//
+// Matches the Hermes Agent provider-selector UX:
+//   - ↑↓ navigate
+//   - ENTER / SPACE select
+//   - ESC cancel
+//   - currently-active option marked with `(•)` and `← currently active`
+//   - other options marked with `(o)`
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectOne = selectOne;
+exports.numberedChoice = numberedChoice;
+const readline = __importStar(require("readline"));
+const MatrixTheme_1 = require("./MatrixTheme");
+/**
+ * Show the menu, await user input, return the selected value (or null on ESC).
+ *
+ * In non-TTY contexts (CI, piped), prints the menu once and returns
+ * `options[initialIndex].value` without blocking — keeps scripts working.
+ */
+async function selectOne(opts) {
+    const activeIdx = opts.options.findIndex(o => o.value === opts.active);
+    let cursor = opts.initialIndex ?? (activeIdx >= 0 ? activeIdx : 0);
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stdout.write(renderMenu(opts.title, opts.options, cursor, opts.active));
+        return opts.options[cursor]?.value ?? null;
+    }
+    return new Promise((resolve) => {
+        const previousRaw = process.stdin.isRaw === true;
+        try {
+            readline.emitKeypressEvents(process.stdin);
+            process.stdin.setRawMode(true);
+        }
+        catch {
+            // Non-TTY edge case — fall back to first option.
+            resolve(opts.options[cursor]?.value ?? null);
+            return;
+        }
+        process.stdout.write(MatrixTheme_1.ANSI.hideCursor);
+        let firstDraw = true;
+        const draw = () => {
+            const block = renderMenu(opts.title, opts.options, cursor, opts.active);
+            if (!firstDraw) {
+                // Move cursor up by the number of lines previously printed so we
+                // overwrite the menu in place rather than scroll.
+                const lineCount = block.split('\n').length;
+                process.stdout.write(`\x1b[${lineCount}A`);
+            }
+            firstDraw = false;
+            process.stdout.write(block);
+        };
+        const cleanup = () => {
+            process.stdin.removeListener('keypress', onKey);
+            try {
+                process.stdin.setRawMode(previousRaw);
+            }
+            catch { /* ignore */ }
+            process.stdout.write(MatrixTheme_1.ANSI.showCursor);
+            process.stdout.write(MatrixTheme_1.ANSI.reset);
+        };
+        const onKey = (_str, key) => {
+            if (!key)
+                return;
+            if (key.ctrl && key.name === 'c') {
+                cleanup();
+                process.stdout.write('\n');
+                resolve(null);
+                return;
+            }
+            if (key.name === 'escape') {
+                cleanup();
+                process.stdout.write('\n');
+                resolve(null);
+                return;
+            }
+            if (key.name === 'up' || key.name === 'k') {
+                cursor = (cursor - 1 + opts.options.length) % opts.options.length;
+                draw();
+                return;
+            }
+            if (key.name === 'down' || key.name === 'j') {
+                cursor = (cursor + 1) % opts.options.length;
+                draw();
+                return;
+            }
+            if (key.name === 'return' || key.name === 'space') {
+                cleanup();
+                process.stdout.write('\n');
+                resolve(opts.options[cursor]?.value ?? null);
+                return;
+            }
+        };
+        process.stdin.on('keypress', onKey);
+        draw();
+    });
+}
+function renderMenu(title, options, cursor, active) {
+    const useColor = (0, MatrixTheme_1.supportsColor)();
+    const head = useColor ? MatrixTheme_1.MATRIX.head : '';
+    const body = useColor ? MatrixTheme_1.MATRIX.body : '';
+    const tail = useColor ? MatrixTheme_1.MATRIX.tail : '';
+    const reset = useColor ? MatrixTheme_1.ANSI.reset : '';
+    const lines = [];
+    lines.push(`${head}${title}${reset}`);
+    lines.push(`${tail}↑↓ navigate · ENTER select · ESC cancel${reset}`);
+    lines.push('');
+    for (let i = 0; i < options.length; i++) {
+        const opt = options[i];
+        const isCursor = i === cursor;
+        const isActive = opt.value === active;
+        const marker = isActive ? '(•)' : '(o)';
+        const arrow = isCursor ? '▶' : ' ';
+        const hint = opt.hint ? `${tail} — ${opt.hint}${reset}` : '';
+        const activeTag = isActive ? `  ${tail}← currently active${reset}` : '';
+        const color = isCursor ? head : body;
+        lines.push(`  ${color}${arrow} ${marker} ${opt.label}${reset}${hint}${activeTag}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Convenience: numbered 1/2/3 choice prompt — used after provider
+ * selection for the `1) Use existing  2) Reauth  3) Cancel` flow.
+ */
+async function numberedChoice(question, choices) {
+    const useColor = (0, MatrixTheme_1.supportsColor)();
+    const head = useColor ? MatrixTheme_1.MATRIX.head : '';
+    const body = useColor ? MatrixTheme_1.MATRIX.body : '';
+    const reset = useColor ? MatrixTheme_1.ANSI.reset : '';
+    process.stdout.write(`\n${head}${question}${reset}\n`);
+    for (const c of choices) {
+        process.stdout.write(`  ${body}${c.key}) ${c.label}${reset}\n`);
+    }
+    const keys = choices.map(c => c.key).join('/');
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`\n  ${body}choice [${keys}]:${reset} `, (answer) => {
+            rl.close();
+            const k = answer.trim();
+            resolve(choices.find(c => c.key === k)?.key ?? null);
+        });
+    });
+}

package/dist/index.js

@@ -2825,4 +2825,43 @@ profileCmd.command('import <file>').description('Import a profile from a JSON fi
         process.exitCode = 1;
     }
 });
-program.parse(process.argv);
+// `openlife config` — interactive configuration TUI (provider, keys, telegram, voice, daemon)
+program
+    .command('config')
+    .description('Configurações interativas (provider, API keys, Telegram, voz, daemon)')
+    .option('--focus <section>', 'Open directly into a section: provider | api-keys | telegram | voice | daemon')
+    .action(async (opts) => {
+    const { runConfig } = require('./cli/ConfigTui');
+    await runConfig({ focus: opts.focus });
+});
+// `openlife chat` — explicit alias for the interactive chat TUI (matches docs)
+program
+    .command('chat')
+    .description('Inicia o chat interativo no terminal (Matrix-themed REPL)')
+    .action(async () => {
+    const { runChat } = require('./cli/ChatTui');
+    await runChat();
+});
+// Bare invocation (no subcommand + interactive TTY) → launch chat TUI.
+// Piped, CI, or `--help` flows fall through to the standard Commander parse.
+const isBareInteractive = process.argv.length === 2 &&
+    process.stdout.isTTY === true &&
+    process.stdin.isTTY === true &&
+    !process.env.OPENLIFE_DISABLE_CHAT_TUI;
+if (isBareInteractive) {
+    // Defer to ChatTui — never returns under normal use.
+    (async () => {
+        try {
+            const { runChat } = require('./cli/ChatTui');
+            await runChat();
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`[chat] failed to start: ${msg}`);
+            process.exitCode = 1;
+        }
+    })();
+}
+else {
+    program.parse(process.argv);
+}

package/dist/orchestrator/Brain.js

@@ -58,11 +58,6 @@ function getCodexFastTimeoutMs() {
 function getCodexDeepTimeoutMs() {
     return Number(process.env.OPENLIFE_CODEX_DEEP_TIMEOUT_MS || DEFAULT_MODEL_TIMEOUT_MS);
 }
-/**
- * Typed Codex CLI timeout. Callers (Gateway, Gatekeeper) can distinguish a
- * real timeout from a generic provider failure and present a clearer message.
- * The `depth` attribute marks whether the fast or deep budget fired.
- */
 class CodexTimeoutError extends Error {
     depth;
     timeoutMs;
@@ -117,23 +112,31 @@ class Brain {
             return true;
         return false;
     }
-    async think(systemPrompt, userMessage) {
+    async think(systemPrompt, userMessage, opts) {
         const config = this.modelManager.getModelConfig();
         const modelsToTry = [config.primary, ...config.fallbacks].filter((model, index, arr) => arr.findIndex(m => m.raw === model.raw) === index);
-        return this.runModelChain(systemPrompt, userMessage, modelsToTry, 'deep');
+        return this.runModelChain(systemPrompt, userMessage, modelsToTry, 'deep', opts);
     }
     /** Fast conversational path. Keeps the configured model chain order intact. */
-    async thinkFast(systemPrompt, userMessage) {
+    async thinkFast(systemPrompt, userMessage, opts) {
         const config = this.modelManager.getModelConfig();
         const models = [config.primary, ...config.fallbacks].filter((model, index, arr) => arr.findIndex(m => m.raw === model.raw) === index);
-        return this.runModelChain(systemPrompt, userMessage, models, 'fast');
+        return this.runModelChain(systemPrompt, userMessage, models, 'fast', opts);
     }
-    async runModelChain(systemPrompt, userMessage, modelsToTry, depth = 'deep') {
+    async runModelChain(systemPrompt, userMessage, modelsToTry, depth = 'deep', opts) {
+        const emitReasoning = (chunk) => {
+            try {
+                opts?.onReasoning?.(chunk);
+            }
+            catch { /* never let a callback break the chain */ }
+        };
+        emitReasoning(`🧭 chain: ${modelsToTry.map(m => m.raw).join(' → ')}`);
         const failures = [];
         for (let i = 0; i < modelsToTry.length; i++) {
             const modelIdent = modelsToTry[i];
             try {
                 console.log(`[BRAIN] Tentando modelo ${i === 0 ? 'PRIMÁRIO' : 'FALLBACK ' + i}: ${modelIdent.raw}...`);
+                emitReasoning(`🔎 trying ${i === 0 ? 'primary' : `fallback ${i}`}: ${modelIdent.raw}`);
                 let out = '';
                 switch (modelIdent.provider) {
                     case 'openai-api':
@@ -173,8 +176,11 @@ class Brain {
                 const reason = error instanceof Error ? error.message : String(error);
                 failures.push({ model: modelIdent.raw, reason });
                 console.error(`[BRAIN ERROR - ${modelIdent.raw}]`, reason);
-                if (i !== modelsToTry.length - 1)
+                emitReasoning(`✗ ${modelIdent.raw} failed: ${reason.slice(0, 120)}`);
+                if (i !== modelsToTry.length - 1) {
                     console.log(`[BRAIN] Rotacionando para o próximo fallback da cadeia...`);
+                    emitReasoning('↻ rotating to next fallback');
+                }
             }
         }
         const concise = failures.slice(-3).map(f => `- ${f.model}: ${f.reason}`).join('\n');
@@ -282,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

@@ -418,6 +418,70 @@ class Gateway {
         const detailed = await this.processTextForTestDetailed(userId, text);
         return detailed.finalText;
     }
+    /**
+     * Public chat entry point for non-Telegram surfaces (CLI chat TUI, HTTP
+     * pilots, etc.). Wraps the same processInput pipeline used by the Telegram
+     * flow but routes replies through a minimal in-memory ctx so no Telegraf
+     * dependency is required at the call site.
+     *
+     * onReasoning fires for each pipeline trace event (classify → route →
+     * finalize) so a TUI can stream the agent's thinking into the Matrix-rain
+     * region instead of showing an opaque spinner.
+     */
+    async processChat(userId, text, opts) {
+        let finalReply = '';
+        let lastEdit = null;
+        let mid = 0;
+        const ctx = {
+            sendChatAction: async () => { },
+            reply: async (m) => {
+                finalReply = m;
+                return { message_id: ++mid };
+            },
+            sendVoice: async (_src, options) => {
+                finalReply = options?.caption || finalReply;
+                return { message_id: ++mid };
+            },
+            chat: { id: userId },
+            telegram: {
+                editMessageText: async (_chat, _msg, _inline, edited) => {
+                    lastEdit = edited;
+                    return true;
+                }
+            }
+        };
+        // Bridge: every line containing one of the Gateway trace markers also
+        // becomes an onReasoning event. We patch the trace array indirectly by
+        // wrapping safeReply / editMessageText to detect when the final ACK
+        // edit lands. For per-step events we rely on processInput's existing
+        // trace.push() calls — to expose those we use a console.log shim only
+        // for THIS call (not global) when a callback is provided.
+        const onReasoning = opts?.onReasoning;
+        if (typeof onReasoning === 'function') {
+            const originalLog = console.log;
+            const restore = () => { console.log = originalLog; };
+            console.log = ((...args) => {
+                originalLog(...args);
+                const line = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+                if (/\[BRAIN\]|\[GATEWAY\]|\[GATEKEEPER\]|classify_intent|route_task|finalize_reply/.test(line)) {
+                    try {
+                        onReasoning(line);
+                    }
+                    catch { /* ignore */ }
+                }
+            });
+            try {
+                await this.processInput(ctx, userId, text);
+            }
+            finally {
+                restore();
+            }
+        }
+        else {
+            await this.processInput(ctx, userId, text);
+        }
+        return lastEdit ?? finalReply;
+    }
     /**
      * Test seam that captures the full ACK + final timeline for the fast-ACK
      * pattern. Used by the regression test to assert the placeholder reply

package/dist/test_chat_tui.js

@@ -0,0 +1,116 @@
+"use strict";
+// src/test_chat_tui.ts
+// Tests for the ChatTui non-TTY surface area:
+// - buildInventoryStats reads .catalog counts correctly
+// - reading models.json returns the active model
+// - session log appends to .openlife/chat-sessions/<id>.jsonl
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const ChatTui_1 = require("./cli/ChatTui");
+let failed = 0;
+function check(label, condition, detail) {
+    if (condition) {
+        console.log(`✅ ${label}`);
+    }
+    else {
+        console.error(`❌ ${label}${detail ? ` — ${detail}` : ''}`);
+        failed++;
+    }
+}
+function makeTempRoot() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-chat-tui-'));
+    // .catalog skeleton with a couple of fake entries
+    fs.mkdirSync(path.join(root, '.catalog', 'agents', 'agent-a'), { recursive: true });
+    fs.mkdirSync(path.join(root, '.catalog', 'agents', 'agent-b'), { recursive: true });
+    fs.mkdirSync(path.join(root, '.catalog', 'squads', 'squad-a'), { recursive: true });
+    fs.mkdirSync(path.join(root, '.catalog', 'skills', 'skill-a'), { recursive: true });
+    fs.mkdirSync(path.join(root, '.catalog', 'mcps'), { recursive: true });
+    // package.json with version
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'test', version: '9.9.9' }), 'utf-8');
+    // models.json with a primary
+    fs.writeFileSync(path.join(root, 'models.json'), JSON.stringify({ primary: { provider: 'p', name: 'm', raw: 'p/m' }, fallbacks: [] }), 'utf-8');
+    return root;
+}
+// 1. buildInventoryStats reads .catalog and models.json
+{
+    const root = makeTempRoot();
+    try {
+        const stats = (0, ChatTui_1.buildInventoryStats)(root, 'sess-1');
+        check('version reads from package.json', stats.version === 'v9.9.9', `got=${stats.version}`);
+        check('model reads from models.json', stats.model === 'p/m', `got=${stats.model}`);
+        check('agents counted', stats.agents === 2, `got=${stats.agents}`);
+        check('squads counted', stats.squads === 1, `got=${stats.squads}`);
+        check('skills counted', stats.skills === 1, `got=${stats.skills}`);
+        check('mcps counted (0 ok)', stats.mcps === 0, `got=${stats.mcps}`);
+        check('sessionId echoed', stats.sessionId === 'sess-1');
+        check('cwd reflects root', stats.cwd === root);
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+// 2. test-* directories are ignored (matches clean-test-pollution semantics)
+{
+    const root = makeTempRoot();
+    try {
+        fs.mkdirSync(path.join(root, '.catalog', 'agents', 'test-pollution-1'), { recursive: true });
+        const stats = (0, ChatTui_1.buildInventoryStats)(root, 's');
+        check('test-* agents excluded from counts', stats.agents === 2, `got=${stats.agents} (should ignore test-pollution-1)`);
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+// 3. Missing .catalog returns zeros, doesn't throw
+{
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-chat-tui-empty-'));
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'x', version: '1.0.0' }), 'utf-8');
+    try {
+        const stats = (0, ChatTui_1.buildInventoryStats)(root, 's');
+        check('empty .catalog yields zero counts', stats.agents === 0 && stats.squads === 0 && stats.skills === 0 && stats.mcps === 0);
+        check('missing models.json yields unknown', stats.model === 'unknown');
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+if (failed > 0) {
+    console.error(`\n${failed} check(s) failed.`);
+    process.exit(1);
+}
+console.log('\nTEST_CHAT_TUI_OK');

package/dist/test_config_tui.js

@@ -0,0 +1,116 @@
+"use strict";
+// src/test_config_tui.ts
+// Tests for ConfigTui persistence helpers — focused on file-level effects
+// (the interactive surface is exercised separately via the TUI).
+//
+// What we verify:
+// - saveApiKeysToEnv writes to .env, masks correctly via existing helper
+// - saveTelegramConfig persists token + chat id
+// - validateTelegramToken catches format errors before going to the network
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const InstallModules_1 = require("./cli/InstallModules");
+let failed = 0;
+function check(label, condition, detail) {
+    if (condition) {
+        console.log(`✅ ${label}`);
+    }
+    else {
+        console.error(`❌ ${label}${detail ? ` — ${detail}` : ''}`);
+        failed++;
+    }
+}
+// 1. saveApiKeysToEnv idempotent (writing same key twice does not duplicate)
+{
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-cfg-keys-'));
+    try {
+        (0, InstallModules_1.saveApiKeysToEnv)(root, { openai: 'sk-aaa' });
+        (0, InstallModules_1.saveApiKeysToEnv)(root, { openai: 'sk-bbb' });
+        const env = fs.readFileSync(path.join(root, '.env'), 'utf-8');
+        const matches = env.match(/^OPENAI_API_KEY=/gm) || [];
+        check('OPENAI_API_KEY appears exactly once after two saves', matches.length === 1, `count=${matches.length}`);
+        check('OPENAI_API_KEY reflects latest value', env.includes('OPENAI_API_KEY=sk-bbb'));
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+// 2. saveApiKeysToEnv preserves unrelated lines
+{
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-cfg-keys-mix-'));
+    try {
+        fs.writeFileSync(path.join(root, '.env'), 'SOME_OTHER=preserve_me\nFOO=bar\n', 'utf-8');
+        (0, InstallModules_1.saveApiKeysToEnv)(root, { gemini: 'gem-xyz' });
+        const env = fs.readFileSync(path.join(root, '.env'), 'utf-8');
+        check('preserved unrelated SOME_OTHER', env.includes('SOME_OTHER=preserve_me'));
+        check('preserved unrelated FOO', env.includes('FOO=bar'));
+        check('added new GEMINI_API_KEY', env.includes('GEMINI_API_KEY=gem-xyz'));
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+// 3. saveTelegramConfig sets token + chat id idempotently
+{
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-cfg-tg-'));
+    try {
+        (0, InstallModules_1.saveTelegramConfig)(root, '123456789:AAEEABCDEFGHIJKLMNOPQRSTUVWXYZ0123', '999');
+        (0, InstallModules_1.saveTelegramConfig)(root, '999999999:ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '999');
+        const env = fs.readFileSync(path.join(root, '.env'), 'utf-8');
+        const tokenCount = (env.match(/^TELEGRAM_BOT_TOKEN=/gm) || []).length;
+        check('TELEGRAM_BOT_TOKEN appears exactly once', tokenCount === 1, `count=${tokenCount}`);
+        check('TELEGRAM_BOT_TOKEN updated to second value', env.includes('TELEGRAM_BOT_TOKEN=999999999:'));
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+// 4. validateTelegramToken rejects bad format without going to network
+{
+    const r1 = (0, InstallModules_1.validateTelegramToken)(undefined);
+    check('validate rejects undefined token', r1.ok === false);
+    const r2 = (0, InstallModules_1.validateTelegramToken)('not-a-token');
+    check('validate rejects malformed token', r2.ok === false && r2.detail.includes('inválido'));
+    const r3 = (0, InstallModules_1.validateTelegramToken)('123:short');
+    check('validate rejects token with short secret', r3.ok === false);
+}
+if (failed > 0) {
+    console.error(`\n${failed} check(s) failed.`);
+    process.exit(1);
+}
+console.log('\nTEST_CONFIG_TUI_OK');