tg-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,954 @@
+import TelegramBot from "node-telegram-bot-api";
+import { discoverAuthStorage, discoverModels } from "@mariozechner/pi-coding-agent";
+import { getOAuthProviders } from "@mariozechner/pi-ai";
+import { config, assertConfig } from "./config.js";
+import { resolveApiKeyForProvider, resolveProxyInfo } from "./auth.js";
+import { applyFetchProxy } from "./proxy.js";
+import { runPiAgentPrompt } from "./piAgentRunner.js";
+import { readCodexOAuth } from "./codexAuth.js";
+import { formatMcpTarget, loadMcpServers, loadMcpServersSync, probeMcpServer } from "./mcp.js";
+import { appendMessage, closeSession, createSession, deleteSessionFile, getActiveSession, listSessions, loadUserState, pruneExpiredSessions, resetSession, saveUserState, setActiveSession, } from "./sessionStore.js";
+import { chunkText, createQueueMap, createSemaphore, ensureDir, nowMs } from "./utils.js";
+assertConfig();
+const bot = new TelegramBot(config.telegramToken, { polling: true });
+const enqueueUser = createQueueMap();
+const withSemaphore = createSemaphore(config.maxConcurrent);
+const activeRuns = new Map();
+function registerActiveRun(userId, run) {
+    activeRuns.set(userId, run);
+}
+function clearActiveRun(userId) {
+    activeRuns.delete(userId);
+}
+function resolveTelegramParseMode(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (trimmed === "Markdown" || trimmed === "MarkdownV2" || trimmed === "HTML") {
+        return trimmed;
+    }
+    console.warn(`[tg-agent] invalid TELEGRAM_PARSE_MODE=${trimmed}, ignoring`);
+    return undefined;
+}
+const MARKDOWN_V2_RESERVED = new Set([
+    "_",
+    "*",
+    "[",
+    "]",
+    "(",
+    ")",
+    "~",
+    "`",
+    ">",
+    "#",
+    "+",
+    "-",
+    "=",
+    "|",
+    "{",
+    "}",
+    ".",
+    "!",
+]);
+function countUnescaped(text, target) {
+    let count = 0;
+    for (let i = 0; i < text.length; i += 1) {
+        const char = text[i];
+        if (char === "\\") {
+            i += 1;
+            continue;
+        }
+        if (char === target) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function isMarkdownSafe(text) {
+    const stars = countUnescaped(text, "*");
+    if (stars % 2 !== 0)
+        return false;
+    const underscores = countUnescaped(text, "_");
+    if (underscores % 2 !== 0)
+        return false;
+    const backticks = countUnescaped(text, "`");
+    if (backticks % 2 !== 0)
+        return false;
+    const left = countUnescaped(text, "[");
+    const right = countUnescaped(text, "]");
+    if (left !== right)
+        return false;
+    return true;
+}
+function isMarkdownV2Safe(text) {
+    for (let i = 0; i < text.length; i += 1) {
+        const char = text[i];
+        if (char === "\\") {
+            i += 1;
+            continue;
+        }
+        if (MARKDOWN_V2_RESERVED.has(char)) {
+            return false;
+        }
+    }
+    return true;
+}
+function resolveBestParseModes(text) {
+    const configured = resolveTelegramParseMode(config.telegramParseMode);
+    if (configured) {
+        return [configured];
+    }
+    if (isMarkdownV2Safe(text)) {
+        return ["MarkdownV2", "Markdown"];
+    }
+    if (isMarkdownSafe(text)) {
+        return ["Markdown"];
+    }
+    return [];
+}
+const AUTH_PROMPT_TIMEOUT_MS = 10 * 60 * 1000;
+const authPromptState = new Map();
+const authInFlight = new Set();
+const PROVIDER_ALIASES = new Map([
+    ["codex", "openai-codex"],
+    ["antigravity", "google-antigravity"],
+    ["gemini", "google-gemini-cli"],
+    ["gemini-cli", "google-gemini-cli"],
+]);
+const CODEX_MODEL_ALIASES = {
+    "codex-mini-latest": "gpt-5.1-codex-mini",
+    "codex-max-latest": "gpt-5.1-codex-max",
+    "codex-latest": "gpt-5.2-codex",
+};
+function normalizeProviderId(input) {
+    const trimmed = input.trim().toLowerCase();
+    return PROVIDER_ALIASES.get(trimmed) ?? trimmed;
+}
+function normalizeModelId(provider, modelId) {
+    if (provider !== "openai-codex") {
+        return modelId;
+    }
+    return CODEX_MODEL_ALIASES[modelId] ?? modelId;
+}
+async function loadModelRegistry() {
+    await ensureDir(config.agentDir);
+    const authStorage = discoverAuthStorage(config.agentDir);
+    const codex = readCodexOAuth();
+    if (codex) {
+        authStorage.setRuntimeApiKey("openai-codex", codex.accessToken);
+    }
+    const modelRegistry = discoverModels(authStorage, config.agentDir);
+    return { authStorage, modelRegistry };
+}
+function clearAuthPrompt(userId) {
+    const pending = authPromptState.get(userId);
+    if (!pending)
+        return;
+    clearTimeout(pending.timeoutId);
+    authPromptState.delete(userId);
+}
+function cancelAuthPrompt(userId, reason) {
+    const pending = authPromptState.get(userId);
+    if (!pending)
+        return;
+    clearTimeout(pending.timeoutId);
+    authPromptState.delete(userId);
+    pending.reject(new Error(reason));
+}
+async function promptForAuthInput(userId, chatId, prompt) {
+    if (authPromptState.has(userId)) {
+        throw new Error("Login is already awaiting input.");
+    }
+    const text = prompt.placeholder ? `${prompt.message} (${prompt.placeholder})` : prompt.message;
+    await sendLongMessage(chatId, text);
+    return await new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            authPromptState.delete(userId);
+            reject(new Error("Login prompt timed out."));
+        }, AUTH_PROMPT_TIMEOUT_MS);
+        authPromptState.set(userId, { resolve, reject, timeoutId, chatId });
+    });
+}
+async function handleStopCommand(chatId, userId) {
+    const active = activeRuns.get(userId);
+    if (!active) {
+        await sendLongMessage(chatId, "No active request to stop.");
+        return;
+    }
+    active.cancelRequested = true;
+    active.abortRequested = true;
+    if (active.status) {
+        active.status.update("Cancelled by user.", true);
+    }
+    if (active.abort) {
+        active.abort();
+    }
+    if (!active.status || active.chatId !== chatId) {
+        await sendLongMessage(chatId, "Stopping current request...");
+    }
+}
+function logStartupInfo() {
+    const proxyVars = {
+        https_proxy: process.env.https_proxy ?? process.env.HTTPS_PROXY ?? "",
+        http_proxy: process.env.http_proxy ?? process.env.HTTP_PROXY ?? "",
+        all_proxy: process.env.all_proxy ?? process.env.ALL_PROXY ?? "",
+        no_proxy: process.env.no_proxy ?? process.env.NO_PROXY ?? "",
+    };
+    const tlsVars = {
+        NODE_EXTRA_CA_CERTS: process.env.NODE_EXTRA_CA_CERTS ?? "",
+        NODE_TLS_REJECT_UNAUTHORIZED: process.env.NODE_TLS_REJECT_UNAUTHORIZED ?? "",
+    };
+    console.log(`[tg-agent] modelProvider=${config.modelProvider} modelRef=${config.modelRef} sessionDir=${config.sessionDir} maxConcurrent=${config.maxConcurrent}`);
+    console.log(`[tg-agent] agentDir=${config.agentDir} workspaceDir=${config.workspaceDir}`);
+    const mcpServers = loadMcpServersSync(config.agentDir);
+    const mcpStatus = mcpServers.length > 0 ? `on (${mcpServers.length})` : "off";
+    console.log(`[tg-agent] tools fetchMaxBytes=${config.fetchMaxBytes} fetchTimeoutMs=${config.fetchTimeoutMs} mcp=${mcpStatus}`);
+    console.log(`[tg-agent] proxy https=${proxyVars.https_proxy || "(empty)"} http=${proxyVars.http_proxy || "(empty)"} all=${proxyVars.all_proxy || "(empty)"} no=${proxyVars.no_proxy || "(empty)"}`);
+    console.log(`[tg-agent] tls extra_ca=${tlsVars.NODE_EXTRA_CA_CERTS || "(empty)"} reject_unauthorized=${tlsVars.NODE_TLS_REJECT_UNAUTHORIZED || "(empty)"}`);
+    try {
+        const { source } = resolveApiKeyForProvider(config.modelProvider);
+        console.log(`[tg-agent] authSource=${source}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[tg-agent] authSource=missing (${message})`);
+    }
+    const proxyInfo = resolveProxyInfo();
+    if (proxyInfo) {
+        console.log(`[tg-agent] proxyUrl=${proxyInfo.url} kind=${proxyInfo.kind} source=${proxyInfo.source}`);
+    }
+    else {
+        console.log("[tg-agent] proxyUrl=(none)");
+    }
+}
+logStartupInfo();
+void ensureDir(config.agentDir).catch((error) => {
+    console.warn(`[tg-agent] ensure agentDir failed: ${error instanceof Error ? error.message : String(error)}`);
+});
+const appliedProxy = applyFetchProxy();
+if (appliedProxy) {
+    console.log(`[tg-agent] fetchProxy=${appliedProxy.url} kind=${appliedProxy.kind} source=${appliedProxy.source}`);
+}
+else {
+    console.log("[tg-agent] fetchProxy=(none)");
+}
+function parseCommand(text) {
+    if (!text.startsWith("/")) {
+        return null;
+    }
+    const trimmed = text.trim();
+    const [rawCommand, ...rest] = trimmed.split(" ");
+    const command = rawCommand.split("@")[0].slice(1).toLowerCase();
+    return { command, args: rest.join(" ").trim() };
+}
+async function ensureActiveSessionForCommand(state, chatId) {
+    let session = getActiveSession(state);
+    if (!session) {
+        session = createSession(state, "");
+        await saveUserState(state);
+        await sendLongMessage(chatId, `Created session ${session.id}.`);
+    }
+    return session;
+}
+function formatProviders(modelRegistry, authStorage) {
+    const models = modelRegistry.getAll();
+    const providerStats = new Map();
+    for (const model of models) {
+        const entry = providerStats.get(model.provider) ?? { count: 0, auth: authStorage.hasAuth(model.provider) };
+        entry.count += 1;
+        providerStats.set(model.provider, entry);
+    }
+    if (providerStats.size === 0) {
+        return "No providers found.";
+    }
+    const lines = Array.from(providerStats.entries())
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([provider, info]) => `- ${provider} (models: ${info.count}, auth: ${info.auth ? "ok" : "missing"})`);
+    return ["Providers:", ...lines, "", "Use /models <provider> to list models."].join("\n");
+}
+function formatModelsForProvider(modelRegistry, provider, authOk) {
+    const models = modelRegistry.getAll().filter((model) => model.provider === provider);
+    if (models.length === 0) {
+        return `No models found for provider ${provider}.`;
+    }
+    const lines = models.map((model) => `- ${model.id} | ${model.name}`);
+    return [`Models for ${provider} (auth: ${authOk ? "ok" : "missing"}):`, ...lines].join("\n");
+}
+function parseModelSelector(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.includes("/")) {
+        const [provider, modelId] = trimmed.split("/", 2);
+        if (!provider || !modelId)
+            return null;
+        return { provider: normalizeProviderId(provider), modelId: modelId.trim() };
+    }
+    return { modelId: trimmed };
+}
+const unauthorizedLogWindowMs = 60_000;
+const unauthorizedLogState = new Map();
+function logUnauthorizedUser(userId, chatId) {
+    const now = Date.now();
+    const lastLoggedAt = unauthorizedLogState.get(userId) ?? 0;
+    if (now - lastLoggedAt < unauthorizedLogWindowMs) {
+        return;
+    }
+    unauthorizedLogState.set(userId, now);
+    console.warn(`[tg-agent] unauthorized user=${userId} chat=${chatId}`);
+}
+function isUserAllowed(userId) {
+    const allowed = config.telegramAllowedUsers;
+    if (!allowed || allowed.size === 0) {
+        return true;
+    }
+    return allowed.has(userId);
+}
+function formatSessions(stateSessions) {
+    if (stateSessions.length === 0) {
+        return "No sessions found.";
+    }
+    const lines = stateSessions.map((session) => {
+        const updated = new Date(session.updatedAt).toISOString();
+        return `- ${session.id} | ${session.title} | updated ${updated}`;
+    });
+    return ["Sessions:", ...lines].join("\n");
+}
+async function sendTelegramMessage(chatId, text, parseMode) {
+    if (parseMode) {
+        return await bot.sendMessage(chatId, text, { parse_mode: parseMode });
+    }
+    return await bot.sendMessage(chatId, text);
+}
+async function editTelegramMessage(chatId, messageId, text, parseMode) {
+    if (parseMode) {
+        await bot.editMessageText(text, { chat_id: chatId, message_id: messageId, parse_mode: parseMode });
+        return;
+    }
+    await bot.editMessageText(text, { chat_id: chatId, message_id: messageId });
+}
+async function sendWithParseModes(attempt, parseModes) {
+    let lastError;
+    for (const mode of parseModes) {
+        try {
+            return await attempt(mode);
+        }
+        catch (error) {
+            lastError = error;
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[tg-agent] parse_mode ${mode} failed, trying fallback: ${message}`);
+        }
+    }
+    try {
+        return await attempt(undefined);
+    }
+    catch (error) {
+        if (lastError) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[tg-agent] parse_mode fallback to plain failed: ${message}`);
+        }
+        throw error;
+    }
+}
+async function sendTelegramMessageBest(chatId, text) {
+    return await sendWithParseModes((parseMode) => sendTelegramMessage(chatId, text, parseMode), resolveBestParseModes(text));
+}
+async function editTelegramMessageBest(chatId, messageId, text) {
+    await sendWithParseModes((parseMode) => editTelegramMessage(chatId, messageId, text, parseMode), resolveBestParseModes(text));
+}
+async function sendLongMessage(chatId, text) {
+    const chunks = chunkText(text, 3900);
+    for (const chunk of chunks) {
+        await sendTelegramMessageBest(chatId, chunk);
+    }
+}
+const TELEGRAM_MAX_LEN = 3900;
+const STATUS_UPDATE_MIN_MS = 1200;
+function truncateForTelegram(text, maxLen = TELEGRAM_MAX_LEN) {
+    if (text.length <= maxLen) {
+        return { text, truncated: false };
+    }
+    const slice = text.slice(0, Math.max(0, maxLen - 15));
+    return { text: `${slice}...\n\n[truncated]`, truncated: true };
+}
+async function createStatusReporter(chatId) {
+    const initial = "Working...";
+    const sent = await sendTelegramMessage(chatId, initial);
+    const messageId = sent.message_id;
+    let lastText = initial;
+    let lastSentAt = 0;
+    let chain = Promise.resolve();
+    const enqueueEdit = (text, force = false) => {
+        const now = Date.now();
+        if (!force && now - lastSentAt < STATUS_UPDATE_MIN_MS)
+            return;
+        if (text === lastText)
+            return;
+        lastText = text;
+        lastSentAt = now;
+        chain = chain
+            .then(async () => {
+            await editTelegramMessage(chatId, messageId, text);
+        })
+            .catch((error) => {
+            console.warn("[tg-agent] status edit failed", error);
+        });
+    };
+    const enqueueEditBest = (text) => {
+        lastText = text;
+        lastSentAt = Date.now();
+        chain = chain
+            .then(async () => {
+            await editTelegramMessageBest(chatId, messageId, text);
+        })
+            .catch((error) => {
+            console.warn("[tg-agent] status edit failed", error);
+        });
+    };
+    return {
+        update: (text, force = false) => {
+            const trimmed = truncateForTelegram(text).text;
+            enqueueEdit(trimmed, force);
+        },
+        finalize: async (text) => {
+            const trimmed = truncateForTelegram(text).text;
+            enqueueEditBest(trimmed);
+            await chain;
+        },
+        fail: async (text) => {
+            const trimmed = truncateForTelegram(text).text;
+            enqueueEditBest(trimmed);
+            await chain;
+        },
+    };
+}
+function formatStatusEvent(event) {
+    switch (event.type) {
+        case "agent_start":
+            return "Working...";
+        case "tool_start":
+            return `Running tool: ${event.name}\nargs: ${summarizeArgs(event.args)}`;
+        case "tool_end":
+            return event.ok
+                ? `Tool finished: ${event.name} (${event.durationMs}ms)`
+                : `Tool failed: ${event.name} (${event.durationMs}ms)`;
+        case "message_start":
+            return event.role === "assistant" ? "Generating reply..." : null;
+        case "message_end":
+            return event.role === "assistant" ? "Finalizing reply..." : null;
+        case "heartbeat": {
+            const seconds = Math.max(1, Math.round(event.elapsedMs / 1000));
+            return `Working... ${seconds}s`;
+        }
+        default:
+            return null;
+    }
+}
+function summarizeArgs(args) {
+    try {
+        const seen = new WeakSet();
+        const maxString = 200;
+        const maxKeys = 12;
+        const maxArray = 12;
+        const maxDepth = 3;
+        const normalize = (value, depth) => {
+            if (value === null || value === undefined)
+                return value;
+            if (typeof value === "string") {
+                return value.length > maxString ? `${value.slice(0, maxString)}...` : value;
+            }
+            if (typeof value === "number" || typeof value === "boolean")
+                return value;
+            if (typeof value === "bigint")
+                return value.toString();
+            if (typeof value === "function")
+                return "[function]";
+            if (typeof value !== "object")
+                return String(value);
+            if (seen.has(value))
+                return "[circular]";
+            if (depth >= maxDepth)
+                return "[truncated]";
+            seen.add(value);
+            if (Array.isArray(value)) {
+                const items = value.slice(0, maxArray).map((item) => normalize(item, depth + 1));
+                if (value.length > maxArray)
+                    items.push("[truncated]");
+                return items;
+            }
+            const entries = Object.entries(value);
+            const result = {};
+            for (const [key, val] of entries.slice(0, maxKeys)) {
+                result[key] = normalize(val, depth + 1);
+            }
+            if (entries.length > maxKeys) {
+                result._truncated = true;
+            }
+            return result;
+        };
+        const normalized = normalize(args, 0);
+        const json = JSON.stringify(normalized);
+        if (!json)
+            return "null";
+        if (json.length > 700) {
+            return `${json.slice(0, 700)}...`;
+        }
+        return json;
+    }
+    catch (error) {
+        return "[unavailable]";
+    }
+}
+function formatErrorMessage(error) {
+    const base = error instanceof Error ? error.message : String(error);
+    const cause = error?.cause;
+    if (cause instanceof Error) {
+        return `${base} (${cause.message})`;
+    }
+    if (cause) {
+        return `${base} (${String(cause)})`;
+    }
+    return base;
+}
+function truncateLine(text, maxLen = 140) {
+    if (text.length <= maxLen) {
+        return text;
+    }
+    return `${text.slice(0, maxLen - 3)}...`;
+}
+async function formatMcpStatus() {
+    const servers = await loadMcpServers(config.agentDir);
+    if (servers.length === 0) {
+        return "No MCP servers configured. Add [mcp_servers.*] to ~/.tg-agent/config.toml.";
+    }
+    const probes = await Promise.all(servers.map((server) => probeMcpServer(server)));
+    const lines = ["MCP servers:"];
+    for (let i = 0; i < servers.length; i += 1) {
+        const server = servers[i];
+        const probe = probes[i];
+        const status = probe.ok ? "ok" : `error: ${truncateLine(probe.error ?? "unknown")}`;
+        lines.push(`- ${server.name} (${server.type}) ${formatMcpTarget(server)} status=${status} (${probe.durationMs}ms)`);
+    }
+    return lines.join("\n");
+}
+async function handleCommand(chatId, userId, command, args) {
+    const state = await loadUserState(userId);
+    const removed = pruneExpiredSessions(state);
+    if (removed.length > 0) {
+        await saveUserState(state);
+        await Promise.all(removed.map((sessionId) => deleteSessionFile(userId, sessionId).catch((error) => {
+            console.warn(`[tg-agent] cleanup session file failed id=${sessionId}`, error);
+        })));
+    }
+    switch (command) {
+        case "start":
+        case "help": {
+            const helpText = [
+                "Commands:",
+                "/new [title] - create a new session",
+                "/list - list sessions",
+                "/use <id> - switch active session",
+                "/close [id] - close a session (default: active)",
+                "/reset - clear active session history",
+                "/providers - list available providers",
+                "/models [provider] - list models for provider",
+                "/provider <name> - set provider for current session",
+                "/model <provider>/<model> - set model for current session",
+                "/mcp - list configured MCP servers",
+                "/status - show session model settings",
+                "/login <provider> - login to OAuth provider",
+                "/logout <provider> - logout from provider",
+                "/stop - stop the current running request",
+            ].join("\n");
+            await sendLongMessage(chatId, helpText);
+            return;
+        }
+        case "new": {
+            try {
+                const title = args || "";
+                const session = createSession(state, title);
+                await saveUserState(state);
+                await sendLongMessage(chatId, `Created session ${session.id} (${session.title}).`);
+            }
+            catch (error) {
+                await sendLongMessage(chatId, error.message);
+            }
+            return;
+        }
+        case "list": {
+            await saveUserState(state);
+            await sendLongMessage(chatId, formatSessions(listSessions(state)));
+            return;
+        }
+        case "use": {
+            if (!args) {
+                await sendLongMessage(chatId, "Usage: /use <id>");
+                return;
+            }
+            const ok = setActiveSession(state, args);
+            if (!ok) {
+                await sendLongMessage(chatId, `Session not found: ${args}`);
+                return;
+            }
+            await saveUserState(state);
+            await sendLongMessage(chatId, `Active session set to ${args}.`);
+            return;
+        }
+        case "close": {
+            const target = args || state.activeSessionId;
+            if (!target) {
+                await sendLongMessage(chatId, "No active session to close.");
+                return;
+            }
+            const ok = closeSession(state, target);
+            if (!ok) {
+                await sendLongMessage(chatId, `Session not found: ${target}`);
+                return;
+            }
+            await saveUserState(state);
+            await deleteSessionFile(userId, target).catch((error) => {
+                console.warn(`[tg-agent] delete session file failed id=${target}`, error);
+            });
+            await sendLongMessage(chatId, `Closed session ${target}.`);
+            return;
+        }
+        case "reset": {
+            const active = getActiveSession(state);
+            if (!active) {
+                await sendLongMessage(chatId, "No active session.");
+                return;
+            }
+            resetSession(active);
+            await saveUserState(state);
+            await deleteSessionFile(userId, active.id).catch((error) => {
+                console.warn(`[tg-agent] reset session file failed id=${active.id}`, error);
+            });
+            await sendLongMessage(chatId, `Reset session ${active.id}.`);
+            return;
+        }
+        case "providers": {
+            const { authStorage, modelRegistry } = await loadModelRegistry();
+            const error = modelRegistry.getError();
+            const text = formatProviders(modelRegistry, authStorage);
+            const message = error ? `Warning: ${error}\n\n${text}` : text;
+            await sendLongMessage(chatId, message);
+            return;
+        }
+        case "models": {
+            const { authStorage, modelRegistry } = await loadModelRegistry();
+            let provider = args ? normalizeProviderId(args) : "";
+            if (!provider) {
+                const active = getActiveSession(state);
+                if (!active?.modelProvider) {
+                    await sendLongMessage(chatId, "Usage: /models <provider>");
+                    return;
+                }
+                provider = active.modelProvider;
+            }
+            const authOk = authStorage.hasAuth(provider);
+            await sendLongMessage(chatId, formatModelsForProvider(modelRegistry, provider, authOk));
+            return;
+        }
+        case "provider": {
+            if (!args) {
+                await sendLongMessage(chatId, "Usage: /provider <name>");
+                return;
+            }
+            const provider = normalizeProviderId(args);
+            const { modelRegistry } = await loadModelRegistry();
+            const exists = modelRegistry.getAll().some((model) => model.provider === provider);
+            if (!exists) {
+                await sendLongMessage(chatId, `Unknown provider: ${provider}`);
+                return;
+            }
+            const session = await ensureActiveSessionForCommand(state, chatId);
+            session.modelProvider = provider;
+            session.modelId = undefined;
+            session.updatedAt = nowMs();
+            await saveUserState(state);
+            await sendLongMessage(chatId, `Session ${session.id} provider set to ${provider}.`);
+            return;
+        }
+        case "model": {
+            const selector = parseModelSelector(args);
+            if (!selector) {
+                await sendLongMessage(chatId, "Usage: /model <provider>/<model>");
+                return;
+            }
+            const session = await ensureActiveSessionForCommand(state, chatId);
+            const provider = normalizeProviderId(selector.provider ?? session.modelProvider ?? "");
+            if (!provider) {
+                await sendLongMessage(chatId, "Usage: /model <provider>/<model>");
+                return;
+            }
+            const { modelRegistry } = await loadModelRegistry();
+            const normalizedModelId = normalizeModelId(provider, selector.modelId);
+            const model = modelRegistry.find(provider, normalizedModelId);
+            if (!model) {
+                await sendLongMessage(chatId, `Model not found: ${provider}/${normalizedModelId}`);
+                return;
+            }
+            session.modelProvider = provider;
+            session.modelId = normalizedModelId;
+            session.updatedAt = nowMs();
+            await saveUserState(state);
+            await sendLongMessage(chatId, `Session ${session.id} model set to ${provider}/${normalizedModelId}.`);
+            return;
+        }
+        case "status": {
+            const active = getActiveSession(state);
+            if (!active) {
+                await sendLongMessage(chatId, "No active session.");
+                return;
+            }
+            const defaultModel = config.modelRef.includes("/")
+                ? config.modelRef
+                : `${config.modelProvider}/${config.modelRef}`;
+            const overrides = active.modelProvider || active.modelId
+                ? `Session model: ${active.modelProvider ?? "?"}/${active.modelId ?? "?"}`
+                : `Default model: ${defaultModel}`;
+            const message = [
+                `Session: ${active.id} (${active.title})`,
+                overrides,
+            ].join("\n");
+            await sendLongMessage(chatId, message);
+            return;
+        }
+        case "mcp": {
+            const message = await formatMcpStatus();
+            await sendLongMessage(chatId, message);
+            return;
+        }
+        case "login": {
+            const providers = getOAuthProviders();
+            if (!args) {
+                const lines = providers.map((p) => `- ${p.id} (${p.name})`);
+                await sendLongMessage(chatId, ["OAuth providers:", ...lines].join("\n"));
+                return;
+            }
+            const provider = normalizeProviderId(args);
+            if (authInFlight.has(userId)) {
+                await sendLongMessage(chatId, "Login already in progress.");
+                return;
+            }
+            const providerInfo = providers.find((p) => p.id === provider);
+            if (!providerInfo) {
+                await sendLongMessage(chatId, `Unknown OAuth provider: ${provider}`);
+                return;
+            }
+            authInFlight.add(userId);
+            try {
+                const { authStorage } = await loadModelRegistry();
+                await sendLongMessage(chatId, `Starting login for ${providerInfo.id}...`);
+                await authStorage.login(providerInfo.id, {
+                    onAuth: ({ url, instructions }) => {
+                        const lines = [
+                            "Open this URL in your browser:",
+                            url,
+                        ];
+                        if (instructions) {
+                            lines.push("", instructions);
+                        }
+                        void sendLongMessage(chatId, lines.join("\n"));
+                    },
+                    onPrompt: (prompt) => promptForAuthInput(userId, chatId, prompt),
+                    onProgress: (message) => {
+                        void sendLongMessage(chatId, message);
+                    },
+                    onManualCodeInput: () => promptForAuthInput(userId, chatId, { message: "Paste the authorization code:" }),
+                });
+                await sendLongMessage(chatId, `Login completed for ${providerInfo.id}.`);
+            }
+            catch (error) {
+                const message = formatErrorMessage(error);
+                await sendLongMessage(chatId, `Login failed: ${message}`);
+            }
+            finally {
+                authInFlight.delete(userId);
+                clearAuthPrompt(userId);
+            }
+            return;
+        }
+        case "logout": {
+            if (!args) {
+                await sendLongMessage(chatId, "Usage: /logout <provider>");
+                return;
+            }
+            const provider = normalizeProviderId(args);
+            const { authStorage } = await loadModelRegistry();
+            authStorage.logout(provider);
+            await sendLongMessage(chatId, `Logged out from ${provider}.`);
+            return;
+        }
+        default: {
+            await sendLongMessage(chatId, `Unknown command: ${command}`);
+        }
+    }
+}
+async function handleMessage(chatId, userId, text) {
+    const command = parseCommand(text);
+    if (command) {
+        await handleCommand(chatId, userId, command.command, command.args);
+        return;
+    }
+    const state = await loadUserState(userId);
+    const expired = pruneExpiredSessions(state);
+    if (expired.length > 0) {
+        await saveUserState(state);
+        await Promise.all(expired.map((sessionId) => deleteSessionFile(userId, sessionId).catch((error) => {
+            console.warn(`[tg-agent] cleanup session file failed id=${sessionId}`, error);
+        })));
+    }
+    let session = getActiveSession(state);
+    if (!session) {
+        try {
+            session = createSession(state, "");
+            await saveUserState(state);
+            await sendLongMessage(chatId, `Created session ${session.id}.`);
+        }
+        catch (error) {
+            await sendLongMessage(chatId, error.message);
+            return;
+        }
+    }
+    const userMessage = {
+        role: "user",
+        content: text,
+        ts: nowMs(),
+    };
+    appendMessage(session, userMessage, config.maxHistoryMessages);
+    await saveUserState(state);
+    console.log(`[tg-agent] request user=${userId} session=${session.id} messages=${session.messages.length} textLen=${text.length} provider=${session.modelProvider ?? "-"} model=${session.modelId ?? "-"}`);
+    let statusReporter = null;
+    try {
+        statusReporter = await createStatusReporter(chatId);
+    }
+    catch (error) {
+        console.warn("[tg-agent] status message failed", error);
+    }
+    const activeRun = {
+        sessionId: session.id,
+        chatId,
+        status: statusReporter,
+        abortRequested: false,
+        cancelRequested: false,
+    };
+    registerActiveRun(userId, activeRun);
+    try {
+        const assistantText = await withSemaphore(async () => {
+            const result = await runPiAgentPrompt({
+                userId,
+                sessionId: session.id,
+                prompt: text,
+                systemPrompt: config.systemPrompt,
+                modelProvider: session.modelProvider,
+                modelId: session.modelId,
+                onAbortReady: (abort) => {
+                    activeRun.abort = abort;
+                    if (activeRun.abortRequested) {
+                        abort();
+                    }
+                },
+                onStatus: statusReporter
+                    ? (event) => {
+                        const statusText = formatStatusEvent(event);
+                        if (statusText) {
+                            statusReporter?.update(statusText);
+                        }
+                    }
+                    : undefined,
+            });
+            console.log(`[tg-agent] response session=${session.id} model=${result.modelProvider}/${result.modelId} file=${result.sessionFile}`);
+            return result.text;
+        });
+        if (activeRun.cancelRequested) {
+            if (statusReporter) {
+                await statusReporter.finalize("Cancelled by user.");
+            }
+            else {
+                await sendLongMessage(chatId, "Cancelled by user.");
+            }
+            return;
+        }
+        const assistantMessage = {
+            role: "assistant",
+            content: assistantText,
+            ts: nowMs(),
+        };
+        appendMessage(session, assistantMessage, config.maxHistoryMessages);
+        await saveUserState(state);
+        if (statusReporter) {
+            await statusReporter.finalize(assistantText);
+        }
+        else {
+            await sendLongMessage(chatId, assistantText);
+        }
+    }
+    catch (error) {
+        console.error("[tg-agent] runModel error", error);
+        if (activeRun.cancelRequested) {
+            if (statusReporter) {
+                await statusReporter.fail("Cancelled by user.");
+            }
+            else {
+                await sendLongMessage(chatId, "Cancelled by user.");
+            }
+            return;
+        }
+        const message = formatErrorMessage(error);
+        if (statusReporter) {
+            await statusReporter.fail(`Error: ${message}`);
+        }
+        else {
+            await sendLongMessage(chatId, `Error: ${message}`);
+        }
+    }
+    finally {
+        clearActiveRun(userId);
+    }
+}
+bot.on("message", (msg) => {
+    if (!msg.text) {
+        return;
+    }
+    if (msg.chat.type !== "private") {
+        void bot.sendMessage(msg.chat.id, "This bot only supports direct messages.");
+        return;
+    }
+    if (!msg.from?.id) {
+        return;
+    }
+    const userId = String(msg.from.id);
+    const chatId = msg.chat.id;
+    if (!isUserAllowed(userId)) {
+        logUnauthorizedUser(userId, chatId);
+        return;
+    }
+    const text = msg.text.trim();
+    const pendingAuth = authPromptState.get(userId);
+    if (pendingAuth) {
+        if (text === "/stop" || text === "/cancel") {
+            cancelAuthPrompt(userId, "Login cancelled by user.");
+            void sendLongMessage(chatId, "Login cancelled.");
+            return;
+        }
+        clearAuthPrompt(userId);
+        pendingAuth.resolve(text);
+        return;
+    }
+    const command = parseCommand(text);
+    if (command?.command === "stop") {
+        void handleStopCommand(chatId, userId);
+        return;
+    }
+    enqueueUser(userId, () => handleMessage(chatId, userId, text)).catch(async (error) => {
+        console.error("[tg-agent] runModel error", error);
+        const message = formatErrorMessage(error);
+        await sendLongMessage(chatId, `Error: ${message}`);
+    });
+});
+bot.on("polling_error", (error) => {
+    console.error("Polling error", error);
+});
+console.log("tg-agent started");