agent-life-bridge 0.1.1

package/dist/cli/cmd-start.js

@@ -0,0 +1,783 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { loadConfig } from '../config/config.js';
+import { ensureDataDirs, ensureAgentStateDirs } from '../config/agent-dirs.js';
+import { createLogger, resolveLogFilePath } from '../logger.js';
+import { getAllChannels } from '../channels/registry.js';
+import { SessionManager } from '../channels/session.js';
+import { LocalCliTurnExecutor } from '../agents/cli-runner.js';
+import { CliSessionStore, makeAgentSessionKey } from '../agents/cli-session-store.js';
+import { AgentLifeSessionMapStore } from '../agents/agent-life-session-map-store.js';
+import { createFchRuntimeContext } from '../agents/fch-runtime-context.js';
+import { resolveAgentConfigs } from '../agents/agent-resolver.js';
+import { resolveAgent } from '../agents/agent-router.js';
+import { cleanupPidFile, cleanupRuntimeState, ensureNoRunningInstance, writePidFile, writeRuntimeState } from './pid-file.js';
+import { maybeNotifyAboutUpdateWithLogger } from './update-check.js';
+import { normalizeAgentLifeChannelConfigs, } from '../config/zod-schema.js';
+import { TypingLifecycle } from '../channels/typing-lifecycle.js';
+import { agentSessionStorePath } from '../config/paths.js';
+import { extractProvider, extractModel, isCliBackend } from '../agents/cli-backends.js';
+import { routeCommandText } from '../commands/prefix-router.js';
+export async function cmdStart(args) {
+    const channels = getAllChannels();
+    const activeChannels = [];
+    const cliExecutors = new Map();
+    const sessionStores = new Map();
+    const teardownExecutors = async () => {
+        for (const executor of cliExecutors.values()) {
+            await executor.teardown().catch(() => undefined);
+        }
+    };
+    let logger = null;
+    let shutdownPromise = null;
+    let startupSettled = false;
+    const gracefulShutdown = async (signal) => {
+        if (!shutdownPromise) {
+            shutdownPromise = (async () => {
+                logger?.info({ signal }, 'Shutdown signal received');
+                for (const channel of activeChannels) {
+                    await channel.teardown().catch(() => undefined);
+                }
+                await teardownExecutors();
+                cleanupPidFile();
+                cleanupRuntimeState();
+            })();
+        }
+        await shutdownPromise;
+    };
+    const shutdownAndExit = (signal) => {
+        void gracefulShutdown(signal).finally(() => {
+            process.exit(0);
+        });
+    };
+    const onSigInt = () => shutdownAndExit('SIGINT');
+    const onSigTerm = () => shutdownAndExit('SIGTERM');
+    process.on('SIGINT', onSigInt);
+    process.on('SIGTERM', onSigTerm);
+    await ensureNoRunningInstance({
+        waitMs: 25_000,
+        expectedCwd: process.cwd(),
+        onWait(pid, waitMs) {
+            console.log(`Existing instance detected (pid: ${pid}), waiting up to ${Math.round(waitMs / 1000)}s for graceful shutdown...`);
+        },
+        onWaitComplete(pid) {
+            console.log(`Previous instance exited (pid: ${pid}), continuing startup.`);
+        },
+    });
+    if (args.daemon) {
+        const { spawn } = await import('node:child_process');
+        const childArgs = ['start'];
+        if (args.config) {
+            childArgs.push('--config', args.config);
+        }
+        const child = spawn(process.execPath, [process.argv[1], ...childArgs], {
+            detached: true,
+            stdio: 'ignore',
+            env: { ...process.env, AGENT_LIFE_BRIDGE_DAEMON: '1' },
+        });
+        child.unref();
+        console.log(`agent-life-bridge daemon started (pid: ${child.pid})`);
+        process.exit(0);
+    }
+    const config = loadConfig(args.config);
+    ensureDataDirs(config.files.temp_dir);
+    logger = createLogger(config.logging.level, config.logging.pretty);
+    logger.info({ logFilePath: resolveLogFilePath() }, 'agent-life-bridge starting up');
+    writePidFile(process.pid);
+    writeRuntimeState({
+        pid: process.pid,
+        argv: process.argv.slice(2),
+        cwd: process.cwd(),
+    });
+    try {
+        const sessionManager = new SessionManager(logger);
+        const { agents: resolvedAgents, defaultAgentId } = resolveAgentConfigs(config, logger);
+        const agentLifeSessionMapStore = new AgentLifeSessionMapStore();
+        ensureAgentStateDirs([...resolvedAgents.keys()], defaultAgentId);
+        logger.info({ agentCount: resolvedAgents.size, defaultAgentId, agents: [...resolvedAgents.keys()] }, 'Agents resolved');
+        for (const [agentId] of resolvedAgents) {
+            const sessionStore = new CliSessionStore(agentSessionStorePath(agentId));
+            sessionStores.set(agentId, sessionStore);
+            const incompleteCodexSessions = await sessionStore.findIncompleteSessions('codex-cli');
+            if (incompleteCodexSessions.length > 0) {
+                logger.warn({
+                    agentId,
+                    count: incompleteCodexSessions.length,
+                    sessions: incompleteCodexSessions.slice(0, 10).map((entry) => entry.sessionKey),
+                }, 'Found persisted Codex sessions without thread ids; those conversations will resume with fresh turns until rebuilt');
+            }
+            cliExecutors.set(agentId, new LocalCliTurnExecutor({
+                config,
+                logger,
+                sessionStore,
+            }));
+        }
+        const ctx = {
+            logger,
+            async dispatch(envelope) {
+                const agentLifeConfig = resolveAgentLifeAccountConfig(config.channels['agent-life'], envelope);
+                const agent = resolveAgent(envelope, config.bindings ?? [], resolvedAgents, defaultAgentId);
+                const agentLifeConversationKey = envelope.source.agentLifeSessionKey ?? envelope.sessionId;
+                const rootAgentSessionKey = makeAgentSessionKey(agent.id, agentLifeConversationKey);
+                const fchContext = createFchRuntimeContext({
+                    sessionId: envelope.sessionId,
+                    agentId: agent.id,
+                });
+                await agentLifeSessionMapStore.upsert({
+                    agentLifeMsgId: envelope.source.messageId,
+                    sessionId: envelope.sessionId,
+                    agentId: agent.id,
+                    applyId: fchContext.applyId,
+                    userId: String(envelope.source.userId),
+                });
+                logger.info({ sessionId: envelope.sessionId, agentId: agent.id, chatType: envelope.source.chatType }, 'Dispatching message');
+                sessionManager.getOrCreate(envelope);
+                const primaryModelRef = agent.model.primary;
+                const provider = extractProvider(primaryModelRef);
+                const model = extractModel(primaryModelRef);
+                const sessionStore = sessionStores.get(agent.id);
+                if (!isCliBackend(primaryModelRef, agent.cliBackends)) {
+                    logger.warn({ sessionId: envelope.sessionId, agentId: agent.id, model: primaryModelRef }, 'Primary API model runtime is not implemented yet');
+                    await sendAgentLifeTextReply(agentLifeConfig, envelope, '当前仅支持 CLI 模式模型。');
+                    return;
+                }
+                const cliExecutor = cliExecutors.get(agent.id);
+                if (!cliExecutor) {
+                    throw new Error(`No CLI executor found for agent "${agent.id}"`);
+                }
+                if (!sessionStore) {
+                    throw new Error(`No session store found for agent "${agent.id}"`);
+                }
+                const routedCommand = routeCommandText(envelope.content.text);
+                if (routedCommand.kind === 'cli') {
+                    logger.info({
+                        sessionId: envelope.sessionId,
+                        agentId: agent.id,
+                        originalText: envelope.content.text,
+                        forwardedText: routedCommand.forwardedText,
+                    }, 'Sanitized CLI command for passthrough');
+                }
+                if (routedCommand.kind === 'bridge' && routedCommand.command === 'status') {
+                    await sendAgentLifeTextReply(agentLifeConfig, envelope, [
+                        'agent-life-bridge is running',
+                        `agentId: ${agent.id}`,
+                        `provider: ${provider}`,
+                        `sessionId: ${envelope.sessionId}`,
+                    ].join('\n'));
+                    return;
+                }
+                if (routedCommand.kind === 'bridge' && routedCommand.command === 'stop') {
+                    await sendAgentLifeTextReply(agentLifeConfig, envelope, '已收到停止请求，但当前后端暂不支持强制终止。');
+                    return;
+                }
+                if (routedCommand.kind === 'bridge' && routedCommand.command === 'new') {
+                    const created = await sessionStore.createFreshSession(rootAgentSessionKey);
+                    if (provider === 'codex-cli') {
+                        await cliExecutor.rotateCodexRuntime();
+                    }
+                    logger.info({
+                        sessionId: envelope.sessionId,
+                        agentId: agent.id,
+                        provider,
+                        rootAgentSessionKey,
+                        activeAgentSessionKey: created.sessionKey,
+                        branchCounter: created.branchCounter,
+                        legacyAlias: routedCommand.isLegacyAlias,
+                    }, 'Created fresh chat session via bridge command');
+                    await sendAgentLifeTextReply(agentLifeConfig, envelope, provider === 'codex-cli'
+                        ? '已创建新的 Codex 会话，后续消息将连接到新窗口。'
+                        : '已创建新的会话，后续消息将连接到新会话。');
+                    return;
+                }
+                const agentSessionKey = await sessionStore.resolveActiveSessionKey(rootAgentSessionKey);
+                // Seed CLI session ID from agent config (one-time, does not overwrite runtime values)
+                if (agent.cliSessionId && agentSessionKey === rootAgentSessionKey) {
+                    const existing = await sessionStore.getCliSessionId(agentSessionKey, provider);
+                    if (!existing) {
+                        await sessionStore.setCliSessionId(agentSessionKey, provider, agent.cliSessionId, { model });
+                        logger.info({ agentId: agent.id, provider, cliSessionId: agent.cliSessionId }, 'Seeded CLI session ID from agent config');
+                    }
+                }
+                let typing = null;
+                const shouldStreamDraftReply = shouldUseAgentLifeDraftReply(provider, envelope.content.text);
+                const draftReply = shouldStreamDraftReply
+                    ? createAgentLifeDraftReply(agentLifeConfig, envelope, logger, {
+                        resendOnMessageNotFound: provider !== 'claude-cli',
+                    })
+                    : createNoopDraftReply();
+                try {
+                    typing = new TypingLifecycle(() => sendAgentLifeChatAction(agentLifeConfig, envelope, 'typing'), 4000, logger);
+                    const result = await cliExecutor.run({
+                        envelope: {
+                            ...envelope,
+                            sessionId: agentSessionKey,
+                            content: {
+                                ...envelope.content,
+                                text: routedCommand.kind === 'cli' ? routedCommand.forwardedText : envelope.content.text,
+                                promptMode: routedCommand.kind === 'cli' ? 'cli_passthrough' : 'default',
+                            },
+                        },
+                        provider,
+                        model: model || primaryModelRef,
+                        workspaceDir: agent.workspace,
+                        timeoutMs: 15 * 60 * 1_000,
+                        systemPrompt: agent.systemPrompt,
+                        agentEnv: agent.env,
+                        agentClearEnv: agent.clearEnv,
+                        fchContext,
+                        cliBackends: agent.cliBackends,
+                        callbacks: {
+                            onProcessing() {
+                                logger.info({ sessionId: envelope.sessionId, agentId: agent.id, provider }, 'CLI turn entered processing state');
+                                typing?.start();
+                                void draftReply.update('正在处理你的消息...').catch((error) => {
+                                    logger.warn({
+                                        sessionId: envelope.sessionId,
+                                        agentId: agent.id,
+                                        provider,
+                                        err: error instanceof Error ? error.message : String(error),
+                                    }, 'Failed to send initial draft progress');
+                                });
+                            },
+                            async onProgress(text) {
+                                await draftReply.update(text);
+                            },
+                            async onAssistantMessage(text) {
+                                logger.info({
+                                    sessionId: envelope.sessionId,
+                                    agentId: agent.id,
+                                    provider,
+                                    textPreview: text.length > 200 ? `${text.slice(0, 200)}...` : text,
+                                }, 'Streaming assistant message to agent-life');
+                                await draftReply.appendMessage(text);
+                            },
+                        },
+                    });
+                    typing?.stop();
+                    logger.info({
+                        sessionId: envelope.sessionId,
+                        agentId: agent.id,
+                        provider: result.provider,
+                        model: result.model,
+                        cliSessionId: result.cliSessionId,
+                        isResume: result.isResume,
+                        replyLength: result.text.trim().length,
+                        diagnostics: result.diagnostics,
+                    }, 'CLI turn completed');
+                    logger.debug({ sessionId: envelope.sessionId, text: result.text }, 'CLI turn output');
+                    const replyText = result.text.trim() || 'CLI 已执行完成，但没有返回可显示的文本内容。';
+                    const replyMediaFiles = await resolveReplyMediaFiles(replyText, envelope.content.text);
+                    if (draftReply.hasDraft()) {
+                        if (replyMediaFiles.length > 0) {
+                            const cleanedText = stripMediaPathsFromText(replyText, replyMediaFiles.map((file) => file.path)).trim();
+                            const draftSummary = cleanedText || buildMediaSentSummary(replyMediaFiles);
+                            await draftReply.finalize(draftSummary);
+                            for (const file of replyMediaFiles) {
+                                await sendAgentLifeMediaReply(agentLifeConfig, envelope, file);
+                            }
+                        }
+                        else {
+                            await draftReply.finalize(replyText);
+                        }
+                    }
+                    else {
+                        await sendAgentLifeReply(agentLifeConfig, envelope, replyText);
+                    }
+                }
+                catch (error) {
+                    typing?.stop();
+                    logger.error({
+                        sessionId: envelope.sessionId,
+                        agentId: agent.id,
+                        provider,
+                        err: error instanceof Error ? error.message : String(error),
+                    }, 'CLI turn failed');
+                    const errorText = `执行失败：${error instanceof Error ? error.message : String(error)}`;
+                    if (draftReply.hasDraft()) {
+                        await draftReply.finalize(errorText);
+                    }
+                    else {
+                        await sendAgentLifeTextReply(agentLifeConfig, envelope, errorText);
+                    }
+                }
+                finally {
+                    typing?.stop();
+                }
+            },
+        };
+        if (channels.length === 0) {
+            throw new Error('No channels registered — agent-life channel import is missing');
+        }
+        for (const channel of channels) {
+            const channelConfig = config.channels[channel.id];
+            if (!channelConfig) {
+                logger.warn({ channelId: channel.id }, 'No config found for channel, skipping');
+                continue;
+            }
+            logger.info({ channelId: channel.id }, 'Setting up channel');
+            activeChannels.push(channel);
+            await channel.setup(channelConfig, ctx);
+        }
+        logger.info('agent-life-bridge started');
+        startupSettled = true;
+        maybeNotifyAboutUpdateWithLogger(args, logger);
+    }
+    catch (error) {
+        await teardownExecutors();
+        cleanupPidFile();
+        cleanupRuntimeState();
+        throw error;
+    }
+    finally {
+        if (!startupSettled) {
+            process.off('SIGINT', onSigInt);
+            process.off('SIGTERM', onSigTerm);
+        }
+    }
+}
+async function sendAgentLifeChatAction(agentLife, envelope, action) {
+    await postAgentLifeMethod(agentLife, 'sendChatAction', {
+        chat_id: envelope.source.chatId,
+        ...(typeof envelope.source.messageThreadId === 'number'
+            ? { message_thread_id: envelope.source.messageThreadId }
+            : {}),
+        action,
+    });
+}
+async function sendAgentLifeTextReply(agentLife, envelope, text, options) {
+    const result = await postAgentLifeMethod(agentLife, 'sendMessage', {
+        chat_id: envelope.source.chatId,
+        ...(typeof envelope.source.messageThreadId === 'number'
+            ? { message_thread_id: envelope.source.messageThreadId }
+            : {}),
+        text,
+        reply_to_message_id: envelope.source.messageId,
+        ...(options?.suppressBotStatusRead ? { suppress_bot_status_read: true } : {}),
+        ...(options?.draftProgress ? { draft_progress: true } : {}),
+    });
+    return typeof result?.message_id === 'number' ? result.message_id : null;
+}
+async function sendAgentLifeReply(agentLife, envelope, text) {
+    const mediaFiles = await resolveReplyMediaFiles(text, envelope.content.text);
+    if (mediaFiles.length === 0) {
+        await sendAgentLifeTextReply(agentLife, envelope, text);
+        return;
+    }
+    const cleanedText = stripMediaPathsFromText(text, mediaFiles.map((file) => file.path)).trim();
+    const caption = cleanedText || '截图结果';
+    for (const [index, file] of mediaFiles.entries()) {
+        await sendAgentLifeMediaReply(agentLife, envelope, file, index === 0 ? caption : undefined);
+    }
+}
+async function sendAgentLifeMediaReply(agentLife, envelope, file, caption) {
+    const method = file.kind === 'photo' ? 'sendPhoto' : 'sendDocument';
+    const field = file.kind === 'photo' ? 'photo' : 'document';
+    const form = new FormData();
+    form.append('chat_id', String(envelope.source.chatId));
+    if (typeof envelope.source.messageThreadId === 'number') {
+        form.append('message_thread_id', String(envelope.source.messageThreadId));
+    }
+    form.append('reply_to_message_id', String(envelope.source.messageId));
+    if (caption) {
+        form.append('caption', caption);
+    }
+    const rawBuffer = await readFile(file.path);
+    const buffer = shouldPrefixUtf8Bom(file.mimeType, file.path) ? ensureUtf8Bom(rawBuffer) : rawBuffer;
+    const blob = new Blob([buffer], { type: file.mimeType });
+    form.append(field, blob, path.basename(file.path));
+    await postAgentLifeFormMethod(agentLife, method, form);
+}
+async function postAgentLifeFormMethod(agentLife, method, payload) {
+    const baseUrl = agentLife.gateway_url.replace(/\/+$/, '');
+    const response = await fetch(`${baseUrl}/bot${agentLife.bot_token}/${method}`, {
+        method: 'POST',
+        body: payload,
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`agent-life ${method} failed with HTTP ${response.status}${body ? `: ${body}` : ''}`);
+    }
+    const result = await response.json();
+    if (!result.ok) {
+        throw new Error(`agent-life ${method} failed: ${result.description ?? 'unknown error'}`);
+    }
+}
+async function resolveReplyMediaFiles(replyText, requestText) {
+    const replyCandidates = extractLocalFilePaths(replyText);
+    const requestCandidates = getRequestedTmpFilePaths(requestText ?? '');
+    const candidates = dedupeStringValues([...replyCandidates, ...requestCandidates]);
+    const resolved = [];
+    for (const candidate of candidates) {
+        try {
+            const fileUrl = candidate.startsWith('file://') ? new URL(candidate) : null;
+            const filePath = fileUrl ? decodeURIComponent(fileUrl.pathname) : candidate;
+            const buffer = await readFile(filePath);
+            if (buffer.length === 0)
+                continue;
+            resolved.push({
+                path: filePath,
+                kind: isPhotoPath(filePath) ? 'photo' : 'document',
+                mimeType: inferMimeType(filePath),
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return dedupeMediaFiles(resolved);
+}
+export function extractLocalFilePaths(text) {
+    const matches = text.match(/(?:file:\/\/\/|\/)[^\s"'`]+/g) ?? [];
+    return matches
+        .flatMap((entry) => entry.split(/[、，]/))
+        .map((entry) => entry.replace(/[),.;:!?]+$/g, ''))
+        .filter(Boolean)
+        .filter((entry) => entry.startsWith('/tmp/') || entry.startsWith('file:///tmp/'));
+}
+export function shouldAttachRequestedTmpFiles(text) {
+    if (!text.trim()) {
+        return false;
+    }
+    if (extractLocalFilePaths(text).length === 0) {
+        return false;
+    }
+    return /(发送给我|发给我|传给我|回传给我|发送一下|发一下|上传给我|把.*给我)/.test(text);
+}
+export function shouldUseAgentLifeDraftReply(_provider, requestText) {
+    if (shouldAttachRequestedTmpFiles(requestText)) {
+        return false;
+    }
+    return true;
+}
+export function getRequestedTmpFilePaths(text) {
+    if (!shouldAttachRequestedTmpFiles(text)) {
+        return [];
+    }
+    return extractLocalFilePaths(text);
+}
+function stripMediaPathsFromText(text, filePaths) {
+    let next = text;
+    for (const filePath of filePaths) {
+        const escaped = escapeRegExp(filePath);
+        next = next.replace(new RegExp(escaped, 'g'), '');
+        next = next.replace(new RegExp(escapeRegExp(`file://${filePath}`), 'g'), '');
+    }
+    return next.replace(/\n{3,}/g, '\n\n');
+}
+function dedupeMediaFiles(files) {
+    const seen = new Set();
+    return files.filter((file) => {
+        if (seen.has(file.path))
+            return false;
+        seen.add(file.path);
+        return true;
+    });
+}
+function dedupeStringValues(values) {
+    return [...new Set(values)];
+}
+function buildMediaSentSummary(files) {
+    if (files.length === 1) {
+        return `已发送文件：${path.basename(files[0].path)}`;
+    }
+    return `已发送 ${files.length} 个文件`;
+}
+function isPhotoPath(filePath) {
+    return /\.(png|jpe?g|webp|gif|bmp)$/i.test(filePath);
+}
+function inferMimeType(filePath) {
+    const lower = filePath.toLowerCase();
+    if (lower.endsWith('.png'))
+        return 'image/png';
+    if (lower.endsWith('.jpg') || lower.endsWith('.jpeg'))
+        return 'image/jpeg';
+    if (lower.endsWith('.webp'))
+        return 'image/webp';
+    if (lower.endsWith('.gif'))
+        return 'image/gif';
+    if (lower.endsWith('.bmp'))
+        return 'image/bmp';
+    if (lower.endsWith('.pdf'))
+        return 'application/pdf';
+    if (lower.endsWith('.md') || lower.endsWith('.markdown'))
+        return 'text/markdown; charset=utf-8';
+    if (lower.endsWith('.txt'))
+        return 'text/plain; charset=utf-8';
+    if (lower.endsWith('.json'))
+        return 'application/json; charset=utf-8';
+    if (lower.endsWith('.csv'))
+        return 'text/csv; charset=utf-8';
+    if (lower.endsWith('.html') || lower.endsWith('.htm'))
+        return 'text/html; charset=utf-8';
+    if (lower.endsWith('.xml'))
+        return 'application/xml; charset=utf-8';
+    return 'application/octet-stream';
+}
+function shouldPrefixUtf8Bom(mimeType, filePath) {
+    if (/;\s*charset=utf-8/i.test(mimeType)) {
+        return true;
+    }
+    return /\.(md|markdown|txt|json|csv|html?|xml)$/i.test(filePath);
+}
+function ensureUtf8Bom(buffer) {
+    const utf8Bom = Buffer.from([0xef, 0xbb, 0xbf]);
+    if (buffer.length >= 3 && buffer.subarray(0, 3).equals(utf8Bom)) {
+        return buffer;
+    }
+    return Buffer.concat([utf8Bom, buffer]);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export function createAgentLifeDraftReply(agentLife, envelope, logger, options) {
+    let messageId = null;
+    let editUnsupported = false;
+    let messageNotFound = false;
+    let lastRendered = '';
+    const progressLines = [];
+    const assistantMessages = [];
+    let operationChain = Promise.resolve();
+    const resendOnMessageNotFound = options?.resendOnMessageNotFound ?? true;
+    const renderProgress = () => {
+        const content = progressLines.slice(-12).join('\n').trim() || '正在输入...';
+        return truncateForTelegram(content);
+    };
+    const runExclusive = async (operation) => {
+        const next = operationChain.then(operation, operation);
+        operationChain = next.catch(() => undefined);
+        await next;
+    };
+    const sendDraftMessage = async (text, isFinal = false) => {
+        messageId = await sendAgentLifeTextReply(agentLife, envelope, text, isFinal
+            ? undefined
+            : {
+                suppressBotStatusRead: true,
+                draftProgress: true,
+            });
+        logger.info({
+            sessionId: envelope.sessionId,
+            chatId: envelope.source.chatId,
+            messageId,
+            isFinal,
+            textPreview: text.length > 200 ? `${text.slice(0, 200)}...` : text,
+        }, 'agent-life draft sendMessage sent');
+    };
+    const editDraftMessage = async (text, isFinal = false) => {
+        if (messageId === null) {
+            await sendDraftMessage(text, isFinal);
+            return true;
+        }
+        if (editUnsupported) {
+            if (!isFinal) {
+                return false;
+            }
+            await sendDraftMessage(text, true);
+            return true;
+        }
+        if (messageNotFound) {
+            return false;
+        }
+        try {
+            await postAgentLifeMethod(agentLife, 'editMessageText', {
+                chat_id: envelope.source.chatId,
+                ...(typeof envelope.source.messageThreadId === 'number'
+                    ? { message_thread_id: envelope.source.messageThreadId }
+                    : {}),
+                message_id: messageId,
+                text,
+                ...(isFinal ? { mark_bot_status_read: true } : {}),
+            });
+            logger.info({
+                sessionId: envelope.sessionId,
+                chatId: envelope.source.chatId,
+                messageId,
+                isFinal,
+                textPreview: text.length > 200 ? `${text.slice(0, 200)}...` : text,
+            }, 'agent-life draft editMessageText sent');
+            return true;
+        }
+        catch (error) {
+            if (isAgentLifeEditUnsupportedError(error)) {
+                editUnsupported = true;
+                logger.warn({
+                    sessionId: envelope.sessionId,
+                    chatId: envelope.source.chatId,
+                    messageId,
+                    isFinal,
+                    err: error instanceof Error ? error.message : String(error),
+                }, 'agent-life draft edit unsupported, falling back to sendMessage-only mode');
+                if (!isFinal) {
+                    return false;
+                }
+                await sendDraftMessage(text, true);
+                return true;
+            }
+            if (!isAgentLifeMessageNotFoundError(error)) {
+                throw error;
+            }
+            logger.warn({
+                sessionId: envelope.sessionId,
+                chatId: envelope.source.chatId,
+                messageId,
+                isFinal,
+                err: error instanceof Error ? error.message : String(error),
+            }, 'agent-life draft edit failed with message not found, resending draft');
+            messageNotFound = true;
+            if (!resendOnMessageNotFound) {
+                logger.warn({
+                    sessionId: envelope.sessionId,
+                    chatId: envelope.source.chatId,
+                    messageId,
+                    isFinal,
+                }, 'agent-life draft resend disabled after message not found; keeping single visible draft message');
+                return false;
+            }
+            await sendDraftMessage(text, isFinal);
+            messageNotFound = false;
+            return true;
+        }
+    };
+    const renderAssistantMessages = () => {
+        const content = assistantMessages.join('\n\n').trim();
+        return truncateForTelegram(content);
+    };
+    return {
+        hasDraft() {
+            return messageId !== null;
+        },
+        async update(text) {
+            await runExclusive(async () => {
+                if (assistantMessages.length > 0) {
+                    return;
+                }
+                const normalized = normalizeProgressLine(text);
+                if (!normalized) {
+                    return;
+                }
+                if (progressLines[progressLines.length - 1] !== normalized) {
+                    progressLines.push(normalized);
+                }
+                const rendered = renderProgress();
+                if (!rendered || rendered === lastRendered) {
+                    return;
+                }
+                if (await editDraftMessage(rendered)) {
+                    lastRendered = rendered;
+                }
+            });
+        },
+        async appendMessage(text) {
+            await runExclusive(async () => {
+                const normalized = text.trim();
+                if (!normalized) {
+                    return;
+                }
+                const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
+                if (lastAssistantMessage === normalized) {
+                    return;
+                }
+                if (lastAssistantMessage && normalized.startsWith(lastAssistantMessage)) {
+                    assistantMessages[assistantMessages.length - 1] = normalized;
+                }
+                else {
+                    assistantMessages.push(normalized);
+                }
+                const rendered = renderAssistantMessages();
+                if (!rendered || rendered === lastRendered) {
+                    return;
+                }
+                logger.info({
+                    sessionId: envelope.sessionId,
+                    chatId: envelope.source.chatId,
+                    assistantMessageCount: assistantMessages.length,
+                    textPreview: rendered.length > 200 ? `${rendered.slice(0, 200)}...` : rendered,
+                }, 'agent-life draft aggregated assistant messages');
+                if (await editDraftMessage(rendered)) {
+                    lastRendered = rendered;
+                }
+            });
+        },
+        async finalize(text) {
+            await runExclusive(async () => {
+                const finalText = truncateForTelegram(text.trim() || 'CLI 已执行完成，但没有返回可显示的文本内容。');
+                if (finalText === lastRendered) {
+                    if (messageId !== null && !editUnsupported) {
+                        await editDraftMessage(finalText, true);
+                    }
+                    return;
+                }
+                if (await editDraftMessage(finalText, true)) {
+                    lastRendered = finalText;
+                }
+            });
+        },
+    };
+}
+function createNoopDraftReply() {
+    return {
+        hasDraft() {
+            return false;
+        },
+        async update(_text) {
+            return;
+        },
+        async appendMessage(_text) {
+            return;
+        },
+        async finalize(_text) {
+            return;
+        },
+    };
+}
+function normalizeProgressLine(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function truncateForTelegram(text, maxLength = 3800) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `...${text.slice(-(maxLength - 3))}`;
+}
+function isAgentLifeMessageNotFoundError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /message not found/i.test(error.message);
+}
+export function isAgentLifeEditUnsupportedError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /editMessageText failed with HTTP 405/i.test(error.message)
+        || /method not allowed/i.test(error.message);
+}
+async function postAgentLifeMethod(agentLife, method, payload) {
+    const baseUrl = agentLife.gateway_url.replace(/\/+$/, '');
+    const response = await fetch(`${baseUrl}/bot${agentLife.bot_token}/${method}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`agent-life ${method} failed with HTTP ${response.status}${body ? `: ${body}` : ''}`);
+    }
+    const result = await response.json();
+    if (!result.ok) {
+        throw new Error(`agent-life ${method} failed: ${result.description ?? 'unknown error'}`);
+    }
+    return result.result;
+}
+export function resolveAgentLifeAccountConfig(agentLife, envelope) {
+    const accounts = normalizeAgentLifeChannelConfigs(agentLife);
+    const matched = accounts.find((entry) => entry.accountId === envelope.source.accountId);
+    if (matched) {
+        return matched.config;
+    }
+    const availableAccountIds = accounts.map((entry) => entry.accountId);
+    if (availableAccountIds.length === 0) {
+        throw new Error('No agent-life account config found for reply');
+    }
+    throw new Error(`No agent-life account config found for reply: accountId "${String(envelope.source.accountId ?? '')}" is not configured. Available accounts: ${availableAccountIds.join(', ')}`);
+}
+//# sourceMappingURL=cmd-start.js.map