camelagi 0.5.0

package/dist/telegram-admin.js

@@ -0,0 +1,800 @@
+// Admin bot: BotFather-style Telegram control plane for OpenCamel
+// Conversational wizards + admin commands — all managed from Telegram.
+import { Bot, InlineKeyboard } from "grammy";
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig, saveConfig } from "./core/config.js";
+import { seedAgentWorkspace, agentMemoryDir } from "./workspace.js";
+import { listSessions, deleteSession, loadMessages } from "./session.js";
+import { getActiveBotIds, startBot, stopBot } from "./telegram.js";
+// ─── Presets (shared with setup.ts) ──────────────────────────────────
+const PRESETS = {
+    anthropic: {
+        provider: "anthropic",
+        models: ["claude-sonnet-4-20250514", "claude-opus-4-20250514", "claude-haiku-4-20250506"],
+    },
+    openai: {
+        provider: "openai",
+        models: ["gpt-4o", "gpt-4o-mini", "o3", "o4-mini"],
+    },
+    openrouter: {
+        provider: "openai",
+        baseUrl: "https://openrouter.ai/api/v1",
+        models: [
+            "anthropic/claude-sonnet-4-20250514",
+            "anthropic/claude-opus-4-20250514",
+            "openai/gpt-4o",
+            "google/gemini-2.5-pro",
+            "deepseek/deepseek-r1",
+            "deepseek/deepseek-chat",
+        ],
+    },
+    ollama: {
+        provider: "openai",
+        baseUrl: "http://localhost:11434/v1",
+        models: ["llama3.3", "qwen3", "deepseek-r1", "gemma3"],
+    },
+};
+const WIZARD_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+const activeWizards = new Map();
+function cancelWizard(chatId) {
+    const w = activeWizards.get(chatId);
+    if (!w)
+        return false;
+    clearTimeout(w.timer);
+    activeWizards.delete(chatId);
+    return true;
+}
+async function startWizard(chatId, def, bot) {
+    cancelWizard(chatId); // cancel any existing
+    const timer = setTimeout(() => {
+        activeWizards.delete(chatId);
+        bot.api.sendMessage(chatId, "Wizard timed out. Run the command again.").catch(() => { });
+    }, WIZARD_TIMEOUT_MS);
+    const wizard = { def, stepIndex: 0, data: {}, chatId, timer };
+    activeWizards.set(chatId, wizard);
+    await sendCurrentStep(wizard, bot);
+}
+async function sendCurrentStep(wizard, bot) {
+    // Skip steps that have a skip condition
+    while (wizard.stepIndex < wizard.def.steps.length) {
+        const step = wizard.def.steps[wizard.stepIndex];
+        if (step.skip?.(wizard.data)) {
+            wizard.stepIndex++;
+            continue;
+        }
+        break;
+    }
+    if (wizard.stepIndex >= wizard.def.steps.length) {
+        // All steps done
+        await completeWizard(wizard, bot);
+        return;
+    }
+    const step = wizard.def.steps[wizard.stepIndex];
+    if (step.options) {
+        const kb = new InlineKeyboard();
+        for (const opt of step.options) {
+            kb.text(opt.label, `wizard:${step.id}:${opt.value}`);
+        }
+        // Split into rows of 3
+        await bot.api.sendMessage(wizard.chatId, step.prompt, { reply_markup: kb });
+    }
+    else {
+        await bot.api.sendMessage(wizard.chatId, step.prompt);
+    }
+}
+async function advanceWizard(chatId, input, bot) {
+    const wizard = activeWizards.get(chatId);
+    if (!wizard)
+        return false;
+    const step = wizard.def.steps[wizard.stepIndex];
+    const value = step.transform ? step.transform(input) : input.trim();
+    if (step.validate) {
+        const error = step.validate(value, wizard.data);
+        if (error) {
+            await bot.api.sendMessage(chatId, `${error}\n\nTry again or /cancel:`);
+            return true;
+        }
+    }
+    wizard.data[step.id] = value;
+    wizard.stepIndex++;
+    // Reset timeout
+    clearTimeout(wizard.timer);
+    wizard.timer = setTimeout(() => {
+        activeWizards.delete(chatId);
+        bot.api.sendMessage(chatId, "Wizard timed out. Run the command again.").catch(() => { });
+    }, WIZARD_TIMEOUT_MS);
+    await sendCurrentStep(wizard, bot);
+    return true;
+}
+async function completeWizard(wizard, bot) {
+    cancelWizard(wizard.chatId);
+    try {
+        const message = await wizard.def.onComplete(wizard.data, wizard.chatId, bot);
+        await bot.api.sendMessage(wizard.chatId, message);
+    }
+    catch (err) {
+        await bot.api.sendMessage(wizard.chatId, `Error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function hasActiveWizard(chatId) {
+    return activeWizards.has(chatId);
+}
+// ─── Telegram Token Validation ───────────────────────────────────────
+async function validateBotToken(token) {
+    try {
+        const resp = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+        const data = await resp.json();
+        if (data.ok && data.result) {
+            return { ok: true, username: data.result.username, name: data.result.first_name };
+        }
+        return { ok: false, error: data.description ?? "Invalid token" };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+// ─── Wizard Definitions ─────────────────────────────────────────────
+function createSetupWizard(getConfig) {
+    return {
+        id: "setup",
+        steps: [
+            {
+                id: "service",
+                prompt: "Which AI provider?",
+                options: [
+                    { label: "Anthropic", value: "anthropic" },
+                    { label: "OpenAI", value: "openai" },
+                    { label: "OpenRouter", value: "openrouter" },
+                    { label: "Ollama", value: "ollama" },
+                    { label: "Custom", value: "custom" },
+                ],
+            },
+            {
+                id: "apiKey",
+                prompt: "Enter your API key:",
+                skip: (data) => data.service === "ollama",
+            },
+            {
+                id: "baseUrl",
+                prompt: "Enter the base URL (e.g. http://localhost:8080/v1):",
+                skip: (data) => data.service !== "custom",
+            },
+            {
+                id: "model",
+                prompt: "Which model? (type a name or pick below)",
+                // Options are set dynamically via a workaround — we pre-populate common choices
+                // The user can also type a custom model name
+            },
+        ],
+        onComplete: async (data) => {
+            const preset = PRESETS[data.service];
+            const values = {
+                provider: preset?.provider ?? "openai",
+                model: data.model,
+            };
+            if (data.apiKey)
+                values.apiKey = data.apiKey;
+            if (data.service === "custom" && data.baseUrl) {
+                values.baseUrl = data.baseUrl;
+            }
+            else if (preset?.baseUrl) {
+                values.baseUrl = preset.baseUrl;
+            }
+            saveConfig(values);
+            const maskedKey = data.apiKey ? `***${data.apiKey.slice(-4)}` : "not set";
+            return [
+                "✅ Setup complete!\n",
+                `Provider: ${values.provider}`,
+                `Model: ${data.model}`,
+                values.baseUrl ? `Base URL: ${values.baseUrl}` : null,
+                `API Key: ${maskedKey}`,
+                "",
+                "Create your first agent with /newagent",
+            ].filter(Boolean).join("\n");
+        },
+    };
+}
+/** Generate a unique slug ID from a display name */
+function nameToId(name, existingIds) {
+    // "Personal Finance" → "personalfinance"
+    let base = name.replace(/[^a-z0-9]/gi, "").toLowerCase();
+    if (!base)
+        base = "agent";
+    let id = base;
+    let counter = 1;
+    while (existingIds.includes(id)) {
+        counter++;
+        id = `${base}${counter}`;
+    }
+    return id;
+}
+function createNewAgentWizard(getConfig, getSystemPrompt) {
+    return {
+        id: "newagent",
+        steps: [
+            {
+                id: "name",
+                prompt: "Agent name (e.g. \"Personal Finance\", \"Coder\", \"Journal\"):",
+                validate: (value) => value ? null : "Name cannot be empty.",
+            },
+            {
+                id: "description",
+                prompt: "What does this agent do? (one line, goes into SOUL.md):",
+            },
+            {
+                id: "model",
+                prompt: "Model:",
+                options: [
+                    { label: "Use default", value: "__default__" },
+                    { label: "Change", value: "__custom__" },
+                ],
+            },
+            {
+                id: "modelCustom",
+                prompt: "Enter model name:",
+                skip: (data) => data.model !== "__custom__",
+            },
+            {
+                id: "token",
+                prompt: "Telegram bot token (create one in @BotFather):",
+                options: [
+                    { label: "Skip Telegram", value: "__skip__" },
+                ],
+            },
+        ],
+        onComplete: async (data, _chatId, _bot) => {
+            const config = getConfig();
+            // Auto-generate unique ID from name
+            const existingIds = Object.keys(config.agents);
+            const id = nameToId(data.name, existingIds);
+            // Resolve model
+            const model = data.model === "__custom__" ? data.modelCustom : undefined;
+            // Validate telegram token if provided
+            let tokenInfo = "";
+            if (data.token && data.token !== "__skip__") {
+                const result = await validateBotToken(data.token);
+                if (!result.ok) {
+                    return `Token validation failed: ${result.error}\n\nRun /newagent again.`;
+                }
+                tokenInfo = `\nTelegram: @${result.username}`;
+            }
+            // Seed workspace
+            seedAgentWorkspace(id, data.name, data.description);
+            // Save config
+            const agentConfig = { name: data.name };
+            if (model)
+                agentConfig.model = model;
+            if (data.token && data.token !== "__skip__") {
+                agentConfig.telegram = {
+                    botToken: data.token,
+                    allowedUsers: config.agents.admin?.telegram?.allowedUsers ?? [],
+                };
+            }
+            const agents = { ...config.agents, [id]: agentConfig };
+            saveConfig({ agents });
+            // Hot-start the bot if it has a telegram token
+            if (data.token && data.token !== "__skip__") {
+                try {
+                    const freshConfig = loadConfig();
+                    const sysPrompt = getSystemPrompt();
+                    await startBot(id, data.token, () => freshConfig, () => sysPrompt);
+                }
+                catch (err) {
+                    tokenInfo += `\n⚠️ Bot start failed: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            }
+            const dir = agentMemoryDir(id);
+            return [
+                `✅ Agent created!\n`,
+                `Name: ${data.name}`,
+                `ID: ${id}`,
+                `Model: ${model ?? config.model} (default)`,
+                tokenInfo,
+                `\n📁 ${dir}`,
+            ].filter(Boolean).join("\n");
+        },
+    };
+}
+// ─── Setup Admin Bot ─────────────────────────────────────────────────
+export async function setupAdminBot(agentId, botToken, getConfig, getSystemPrompt) {
+    const b = new Bot(botToken);
+    // Register admin commands with Telegram menu
+    await b.api.setMyCommands([
+        { command: "help", description: "List all commands" },
+        { command: "setup", description: "Configure API provider, key, model" },
+        { command: "newagent", description: "Create a new agent" },
+        { command: "agents", description: "List all agents" },
+        { command: "deleteagent", description: "Delete an agent" },
+        { command: "soul", description: "View/edit agent SOUL.md" },
+        { command: "config", description: "View/update configuration" },
+        { command: "sessions", description: "Manage sessions" },
+        { command: "status", description: "System health and stats" },
+        { command: "restart", description: "Restart agent bots" },
+        { command: "cancel", description: "Cancel active wizard" },
+    ]).catch(() => { });
+    // Access control
+    b.use(async (ctx, next) => {
+        const config = getConfig();
+        const agent = config.agents[agentId];
+        const allowedUsers = agent?.telegram?.allowedUsers ?? [];
+        if (allowedUsers.length === 0) {
+            await next();
+            return;
+        }
+        const userId = ctx.from?.id;
+        if (!userId || !allowedUsers.includes(userId)) {
+            if (ctx.chat?.type === "group" || ctx.chat?.type === "supergroup")
+                return;
+            await ctx.reply("Access denied.");
+            return;
+        }
+        await next();
+    });
+    // ─── Wizard callback queries ─────────────────────────────────────
+    b.callbackQuery(/^wizard:(.+):(.+)$/, async (ctx) => {
+        const match = ctx.callbackQuery.data.match(/^wizard:(.+):(.+)$/);
+        if (!match)
+            return;
+        const [, stepId, value] = match;
+        const chatId = ctx.chat?.id;
+        if (!chatId)
+            return;
+        // Edit the message to show the selection
+        try {
+            await ctx.editMessageText(`${ctx.callbackQuery.message?.text ?? ""}\n\n→ ${value}`);
+        }
+        catch { /* ignore */ }
+        await ctx.answerCallbackQuery();
+        await advanceWizard(chatId, value, b);
+    });
+    // Pick agent for SOUL.md view/edit
+    b.callbackQuery(/^picksoul:(.+):(.+)$/, async (ctx) => {
+        const match = ctx.callbackQuery.data.match(/^picksoul:(.+):(.+)$/);
+        if (!match)
+            return;
+        const [, action, id] = match;
+        await ctx.answerCallbackQuery();
+        try {
+            await ctx.editMessageText(`→ ${id}`);
+        }
+        catch { }
+        await showSoul(ctx.chat.id, id, action === "edit", b);
+    });
+    // Pick agent to delete → show confirmation
+    b.callbackQuery(/^pickdelete:(.+)$/, async (ctx) => {
+        const match = ctx.callbackQuery.data.match(/^pickdelete:(.+)$/);
+        if (!match)
+            return;
+        const id = match[1];
+        await ctx.answerCallbackQuery();
+        const config = getConfig();
+        if (!config.agents[id]) {
+            try {
+                await ctx.editMessageText("Agent not found.");
+            }
+            catch { }
+            return;
+        }
+        const kb = new InlineKeyboard()
+            .text("🗑 Yes, delete", `confirm:delete:${id}`)
+            .text("Cancel", `confirm:cancel:${id}`);
+        try {
+            await ctx.editMessageText(`Delete "${config.agents[id].name}" (${id})?\n\nBot will be stopped. Workspace files are preserved.`, { reply_markup: kb });
+        }
+        catch { }
+    });
+    // Confirmation callback queries (deleteagent, sessions clear)
+    b.callbackQuery(/^confirm:(.+):(.+)$/, async (ctx) => {
+        const match = ctx.callbackQuery.data.match(/^confirm:(.+):(.+)$/);
+        if (!match)
+            return;
+        const [, action, param] = match;
+        try {
+            await ctx.editMessageText(`${ctx.callbackQuery.message?.text ?? ""}\n\n→ ${action === "delete" ? "Deleting..." : "Cancelled"}`);
+        }
+        catch { /* ignore */ }
+        await ctx.answerCallbackQuery();
+        if (action === "delete") {
+            const config = getConfig();
+            if (config.agents[param]) {
+                // Stop the bot if running
+                stopBot(param);
+                // Remove from config
+                const agents = { ...config.agents };
+                delete agents[param];
+                saveConfig({ agents });
+                await ctx.reply(`✅ Agent "${param}" deleted.\nWorkspace files preserved at ${agentMemoryDir(param)}`);
+            }
+        }
+    });
+    b.callbackQuery(/^clearsessions:(.+)$/, async (ctx) => {
+        const match = ctx.callbackQuery.data.match(/^clearsessions:(.+)$/);
+        if (!match)
+            return;
+        const [, period] = match;
+        const cutoff = { "1d": 86400000, "1w": 604800000, "1m": 2592000000 }[period] ?? 604800000;
+        const now = Date.now();
+        const sessions = listSessions();
+        let deleted = 0;
+        for (const s of sessions) {
+            if (now - s.createdAt > cutoff) {
+                deleteSession(s.id);
+                deleted++;
+            }
+        }
+        try {
+            await ctx.editMessageText(`${ctx.callbackQuery.message?.text ?? ""}\n\n→ Deleted ${deleted} sessions`);
+        }
+        catch { /* ignore */ }
+        await ctx.answerCallbackQuery();
+    });
+    // ─── Commands ─────────────────────────────────────────────────────
+    b.command("start", async (ctx) => {
+        const config = getConfig();
+        const agent = config.agents[agentId];
+        const allowedUsers = agent?.telegram?.allowedUsers ?? [];
+        // Auto-lock: if no allowed users yet, lock to the first person who sends /start
+        if (allowedUsers.length === 0 && ctx.from?.id) {
+            const agents = { ...config.agents };
+            const adminAgent = { ...agents[agentId] };
+            const tg = { ...adminAgent.telegram, allowedUsers: [ctx.from.id] };
+            adminAgent.telegram = tg;
+            agents[agentId] = adminAgent;
+            saveConfig({ agents });
+            await ctx.reply(`🔒 Locked to your account (${ctx.from.id}).`);
+        }
+        const hasApiKey = !!config.apiKey;
+        const agentCount = Object.keys(config.agents).length;
+        const lines = [
+            "🐪 OpenCamel Admin\n",
+            "I manage your AI agents from here.",
+            "",
+            hasApiKey ? `✅ API configured (${config.provider}, ${config.model})` : "⚠️ No API key — run /setup first",
+            `${agentCount} agent(s) configured`,
+            "",
+            "Commands:",
+            "/setup — configure API provider & key",
+            "/newagent — create an agent",
+            "/agents — list agents",
+            "/help — all commands",
+        ];
+        await ctx.reply(lines.join("\n"));
+    });
+    b.command("help", async (ctx) => {
+        await ctx.reply([
+            "🐪 OpenCamel Admin Commands\n",
+            "Setup & Config:",
+            "  /setup — configure API provider, key, model",
+            "  /config — view current config",
+            "  /config <key> <value> — update config",
+            "",
+            "Agents:",
+            "  /newagent — create a new agent",
+            "  /agents — list all agents",
+            "  /deleteagent — pick & delete an agent",
+            "  /soul — view/edit agent personality",
+            "",
+            "Sessions & Status:",
+            "  /sessions — list sessions",
+            "  /status — system health",
+            "  /restart — restart all bots",
+            "",
+            "  /cancel — cancel active wizard",
+        ].join("\n"));
+    });
+    b.command("cancel", async (ctx) => {
+        if (cancelWizard(ctx.chat.id)) {
+            await ctx.reply("Wizard cancelled.");
+        }
+        else {
+            await ctx.reply("No active wizard.");
+        }
+    });
+    b.command("setup", async (ctx) => {
+        await startWizard(ctx.chat.id, createSetupWizard(getConfig), b);
+    });
+    b.command("newagent", async (ctx) => {
+        const config = getConfig();
+        if (!config.apiKey) {
+            await ctx.reply("⚠️ No API key configured. Run /setup first.");
+            return;
+        }
+        await startWizard(ctx.chat.id, createNewAgentWizard(getConfig, getSystemPrompt), b);
+    });
+    b.command("agents", async (ctx) => {
+        const config = getConfig();
+        const entries = Object.entries(config.agents);
+        if (entries.length === 0) {
+            await ctx.reply("No agents configured.\n\nUse /newagent to create one.");
+            return;
+        }
+        const runningBots = getActiveBotIds();
+        const lines = ["Your agents:\n"];
+        for (const [id, a] of entries) {
+            const running = runningBots.includes(id);
+            const status = running ? "🟢 running" : "⚫ stopped";
+            lines.push(`${a.admin ? "👑" : "🤖"} ${a.name} (${id}) — ${status}`);
+            lines.push(`   Model: ${a.model ?? config.model}`);
+            if (a.telegram)
+                lines.push(`   Telegram: configured`);
+            lines.push("");
+        }
+        lines.push("/soul <id> — edit personality");
+        lines.push("/deleteagent <id> — delete");
+        await ctx.reply(lines.join("\n"));
+    });
+    b.command("deleteagent", async (ctx) => {
+        const config = getConfig();
+        // Get non-admin agents
+        const deletable = Object.entries(config.agents).filter(([, a]) => !a.admin);
+        if (deletable.length === 0) {
+            await ctx.reply("No agents to delete.");
+            return;
+        }
+        const kb = new InlineKeyboard();
+        for (const [id, a] of deletable) {
+            kb.text(`🗑 ${a.name}`, `pickdelete:${id}`).row();
+        }
+        await ctx.reply("Which agent do you want to delete?", { reply_markup: kb });
+    });
+    b.command("soul", async (ctx) => {
+        const args = (ctx.match ?? "").trim().split(/\s+/);
+        const targetId = args[0];
+        const action = args[1];
+        if (!targetId) {
+            // Show inline buttons to pick an agent
+            const config = getConfig();
+            const entries = Object.entries(config.agents);
+            if (entries.length === 0) {
+                await ctx.reply("No agents. Use /newagent first.");
+                return;
+            }
+            const kb = new InlineKeyboard();
+            for (const [id, a] of entries) {
+                kb.text(`📝 ${a.name}`, `picksoul:view:${id}`).row();
+            }
+            await ctx.reply("Which agent's SOUL.md?", { reply_markup: kb });
+            return;
+        }
+        const config = getConfig();
+        if (!config.agents[targetId]) {
+            await ctx.reply(`Agent "${targetId}" not found.`);
+            return;
+        }
+        await showSoul(ctx.chat.id, targetId, action === "edit", b);
+    });
+    b.command("config", async (ctx) => {
+        const args = (ctx.match ?? "").trim();
+        if (!args) {
+            // View all
+            const config = getConfig();
+            const lines = [
+                "Current configuration:\n",
+                `Provider: ${config.provider}`,
+                `Model: ${config.model}`,
+                config.baseUrl ? `Base URL: ${config.baseUrl}` : null,
+                `API Key: ${config.apiKey ? "***" + config.apiKey.slice(-4) : "not set"}`,
+                `Thinking: ${config.thinking}`,
+                `Effort: ${config.effort}`,
+                `Max Turns: ${config.maxTurns}`,
+                `Timeout: ${config.timeoutSeconds}s`,
+                `Approvals: ${config.approvals.mode}`,
+                "",
+                "Use /config <key> <value> to change",
+                "Examples:",
+                "  /config model gpt-4o",
+                "  /config thinking high",
+                "  /config approvals.mode smart",
+            ];
+            await ctx.reply(lines.filter(Boolean).join("\n"));
+            return;
+        }
+        // Set mode: /config key value
+        const spaceIdx = args.indexOf(" ");
+        if (spaceIdx === -1) {
+            await ctx.reply(`Usage: /config <key> <value>\n\nExample: /config model gpt-4o`);
+            return;
+        }
+        const key = args.slice(0, spaceIdx).trim();
+        const value = args.slice(spaceIdx + 1).trim();
+        // Handle dot-notation for nested keys
+        const parts = key.split(".");
+        let update;
+        if (parts.length === 1) {
+            // Top-level key
+            let parsed = value;
+            if (value === "true")
+                parsed = true;
+            else if (value === "false")
+                parsed = false;
+            else if (/^\d+$/.test(value))
+                parsed = parseInt(value, 10);
+            update = { [key]: parsed };
+        }
+        else {
+            // Nested: e.g. approvals.mode → { approvals: { ...existing, mode: value } }
+            const config = getConfig();
+            const topKey = parts[0];
+            const subKey = parts.slice(1).join(".");
+            const existing = config[topKey];
+            if (typeof existing === "object" && existing !== null) {
+                let parsed = value;
+                if (value === "true")
+                    parsed = true;
+                else if (value === "false")
+                    parsed = false;
+                else if (/^\d+$/.test(value))
+                    parsed = parseInt(value, 10);
+                update = { [topKey]: { ...existing, [subKey]: parsed } };
+            }
+            else {
+                await ctx.reply(`Unknown config section: ${topKey}`);
+                return;
+            }
+        }
+        try {
+            saveConfig(update);
+            await ctx.reply(`✅ ${key} = ${value}`);
+        }
+        catch (err) {
+            await ctx.reply(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    b.command("sessions", async (ctx) => {
+        const sessions = listSessions();
+        if (sessions.length === 0) {
+            await ctx.reply("No sessions.");
+            return;
+        }
+        const recent = sessions.slice(0, 15);
+        const lines = [`Sessions (${sessions.length} total):\n`];
+        for (const s of recent) {
+            const age = formatAge(s.createdAt);
+            const msgs = loadMessages(s.id).length;
+            const label = s.label ? ` (${s.label})` : "";
+            lines.push(`${s.id}${label}`);
+            lines.push(`  ${s.model} · ${msgs} msgs · ${age}`);
+        }
+        if (sessions.length > 15) {
+            lines.push(`\n... and ${sessions.length - 15} more`);
+        }
+        const kb = new InlineKeyboard()
+            .text("Clear > 1 day", "clearsessions:1d")
+            .text("Clear > 1 week", "clearsessions:1w")
+            .text("Clear > 1 month", "clearsessions:1m");
+        await ctx.reply(lines.join("\n"), { reply_markup: kb });
+    });
+    b.command("status", async (ctx) => {
+        const config = getConfig();
+        const runningBots = getActiveBotIds();
+        const sessions = listSessions();
+        const lines = [
+            "🐪 OpenCamel Status\n",
+            `Provider: ${config.provider}`,
+            `Model: ${config.model}`,
+            `API Key: ${config.apiKey ? "✅" : "❌ not set"}`,
+            "",
+            `Bots: ${runningBots.length} running`,
+        ];
+        for (const id of runningBots) {
+            lines.push(`  🟢 ${id}`);
+        }
+        // Show stopped bots
+        const allIds = Object.keys(config.agents);
+        const stoppedIds = allIds.filter((id) => !runningBots.includes(id));
+        for (const id of stoppedIds) {
+            lines.push(`  ⚫ ${id}`);
+        }
+        lines.push("");
+        lines.push(`Sessions: ${sessions.length}`);
+        lines.push(`Approvals: ${config.approvals.mode}`);
+        await ctx.reply(lines.join("\n"));
+    });
+    b.command("restart", async (ctx) => {
+        const targetId = (ctx.match ?? "").trim();
+        const config = getConfig();
+        if (targetId) {
+            // Restart specific agent
+            if (!config.agents[targetId]) {
+                await ctx.reply(`Agent "${targetId}" not found.`);
+                return;
+            }
+            const token = config.agents[targetId].telegram?.botToken;
+            if (!token) {
+                await ctx.reply(`Agent "${targetId}" has no Telegram bot.`);
+                return;
+            }
+            stopBot(targetId);
+            try {
+                const sysPrompt = getSystemPrompt();
+                await startBot(targetId, token, getConfig, () => sysPrompt);
+                await ctx.reply(`✅ Restarted ${targetId}`);
+            }
+            catch (err) {
+                await ctx.reply(`Error restarting: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return;
+        }
+        // Restart all non-admin bots
+        const restarted = [];
+        for (const [id, a] of Object.entries(config.agents)) {
+            if (a.admin)
+                continue; // Don't restart ourselves
+            if (!a.telegram?.botToken)
+                continue;
+            stopBot(id);
+            try {
+                const sysPrompt = getSystemPrompt();
+                await startBot(id, a.telegram.botToken, getConfig, () => sysPrompt);
+                restarted.push(id);
+            }
+            catch { /* skip */ }
+        }
+        await ctx.reply(restarted.length > 0
+            ? `✅ Restarted: ${restarted.join(", ")}`
+            : "No bots to restart.");
+    });
+    // ─── Message handler: wizard intercept, then echo ──────────────────
+    b.on("message:text", async (ctx) => {
+        const chatId = ctx.chat.id;
+        const text = ctx.message.text;
+        // If wizard is active, route to it
+        if (hasActiveWizard(chatId)) {
+            if (text === "/cancel") {
+                cancelWizard(chatId);
+                await ctx.reply("Wizard cancelled.");
+                return;
+            }
+            const handled = await advanceWizard(chatId, text, b);
+            if (handled)
+                return;
+        }
+        // Not a wizard message — for now, echo or ignore
+        // In the future, this falls through to the AI agent
+    });
+    return b;
+}
+// ─── Helpers ─────────────────────────────────────────────────────────
+async function showSoul(chatId, targetId, edit, bot) {
+    const soulPath = path.join(agentMemoryDir(targetId), "SOUL.md");
+    if (edit) {
+        const editWizard = {
+            id: "soul-edit",
+            steps: [{
+                    id: "content",
+                    prompt: `Send the new SOUL.md content for "${targetId}".\nCurrent content will be replaced. /cancel to abort.`,
+                }],
+            onComplete: async (data) => {
+                const dir = agentMemoryDir(targetId);
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(soulPath, data.content);
+                return `✅ SOUL.md updated for "${targetId}".\n\n${data.content.slice(0, 200)}${data.content.length > 200 ? "..." : ""}`;
+            },
+        };
+        await startWizard(chatId, editWizard, bot);
+        return;
+    }
+    // View mode
+    if (!fs.existsSync(soulPath)) {
+        await bot.api.sendMessage(chatId, `No SOUL.md for "${targetId}" yet.`);
+        return;
+    }
+    const content = fs.readFileSync(soulPath, "utf-8").trim();
+    const preview = content.length > 3800 ? content.slice(0, 3800) + "\n\n[truncated]" : content;
+    const kb = new InlineKeyboard()
+        .text("✏️ Edit", `picksoul:edit:${targetId}`);
+    await bot.api.sendMessage(chatId, `📝 SOUL.md (${targetId}):\n\n${preview}`, { reply_markup: kb });
+}
+function formatAge(timestamp) {
+    const diff = Date.now() - timestamp;
+    const minutes = Math.floor(diff / 60000);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+//# sourceMappingURL=telegram-admin.js.map