@inetafrica/open-claudia 1.0.0

package/bot.js

@@ -0,0 +1,871 @@
+const TelegramBot = require("node-telegram-bot-api");
+const { spawn, execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const cron = require("node-cron");
+const Vault = require("./vault");
+
+// ── Load Config from .env ───────────────────────────────────────────
+function loadEnv() {
+  const envPath = path.join(__dirname, ".env");
+  if (!fs.existsSync(envPath)) {
+    console.error("No .env file found. Run: node setup.js");
+    process.exit(1);
+  }
+  const lines = fs.readFileSync(envPath, "utf-8").split("\n");
+  const env = {};
+  for (const line of lines) {
+    const idx = line.indexOf("=");
+    if (idx > 0) env[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+  return env;
+}
+
+function saveEnvKey(key, value) {
+  const envPath = path.join(__dirname, ".env");
+  const content = fs.readFileSync(envPath, "utf-8");
+  const lines = content.split("\n");
+  let found = false;
+  const updated = lines.map((line) => {
+    if (line.startsWith(key + "=")) { found = true; return `${key}=${value}`; }
+    return line;
+  });
+  if (!found) updated.push(`${key}=${value}`);
+  fs.writeFileSync(envPath, updated.join("\n"));
+}
+
+const config = loadEnv();
+const TOKEN = config.TELEGRAM_BOT_TOKEN;
+const CHAT_ID = config.TELEGRAM_CHAT_ID;
+const WORKSPACE = config.WORKSPACE;
+const CLAUDE_PATH = config.CLAUDE_PATH;
+const WHISPER_CLI = config.WHISPER_CLI || "";
+const WHISPER_MODEL = config.WHISPER_MODEL || "";
+const FFMPEG = config.FFMPEG || "";
+const SOUL_FILE = config.SOUL_FILE || path.join(__dirname, "soul.md");
+const CRONS_FILE = config.CRONS_FILE || path.join(__dirname, "crons.json");
+const VAULT_FILE = config.VAULT_FILE || path.join(__dirname, "vault.enc");
+const BOT_DIR = __dirname;
+
+// Detect PATH for subprocess
+const FULL_PATH = [
+  path.dirname(CLAUDE_PATH),
+  FFMPEG ? path.dirname(FFMPEG) : null,
+  WHISPER_CLI ? path.dirname(WHISPER_CLI) : null,
+  "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin",
+].filter(Boolean).join(":");
+
+const bot = new TelegramBot(TOKEN, { polling: true });
+const vault = new Vault(VAULT_FILE);
+
+// ── Commands Menu ───────────────────────────────────────────────────
+bot.setMyCommands([
+  { command: "session", description: "Pick a project to work on" },
+  { command: "projects", description: "Browse all workspace projects" },
+  { command: "model", description: "Switch model (opus/sonnet/haiku)" },
+  { command: "effort", description: "Set effort level" },
+  { command: "budget", description: "Set max spend for next task" },
+  { command: "plan", description: "Toggle plan mode" },
+  { command: "compact", description: "Summarize conversation context" },
+  { command: "continue", description: "Resume last conversation" },
+  { command: "worktree", description: "Toggle isolated git branch" },
+  { command: "cron", description: "Manage scheduled tasks" },
+  { command: "vault", description: "Manage credentials (password required)" },
+  { command: "soul", description: "View/edit assistant identity" },
+  { command: "status", description: "Session & settings info" },
+  { command: "stop", description: "Cancel running task" },
+  { command: "end", description: "End current session" },
+  { command: "help", description: "Show all commands" },
+]);
+
+// Temp dir for media
+const TEMP_DIR = path.join(WORKSPACE, ".telegram-media");
+if (!fs.existsSync(TEMP_DIR)) fs.mkdirSync(TEMP_DIR, { recursive: true });
+
+// ── State ───────────────────────────────────────────────────────────
+let currentSession = null;
+let runningProcess = null;
+let statusMessageId = null;
+let streamBuffer = "";
+let streamInterval = null;
+let lastSessionId = null;
+let messageQueue = [];
+let activeCrons = new Map();
+let pendingVaultUnlock = false; // Waiting for password
+let pendingVaultAction = null;  // What to do after unlock
+
+let settings = {
+  model: null, effort: null, budget: null, permissionMode: null, worktree: false,
+};
+
+function resetSettings() {
+  settings = { model: null, effort: null, budget: null, permissionMode: null, worktree: false };
+}
+
+function isAuthorized(msg) {
+  return String(msg.chat.id) === CHAT_ID;
+}
+
+// ── Onboarding ──────────────────────────────────────────────────────
+let onboardingStep = null; // null | "name" | "role" | "style" | "done"
+let onboardingData = {};
+
+function isOnboarded() {
+  return config.ONBOARDED === "true";
+}
+
+async function startOnboarding() {
+  onboardingStep = "name";
+  onboardingData = {};
+  await send(
+    "Welcome! Let's set me up.\n\nWhat should I call you?"
+  );
+}
+
+async function handleOnboarding(msg) {
+  const text = msg.text;
+
+  if (onboardingStep === "name") {
+    onboardingData.name = text;
+    onboardingStep = "role";
+    await send(`Nice to meet you, ${text}!\n\nWhat's your role? (e.g., "full-stack developer", "startup founder", "student")`);
+    return true;
+  }
+
+  if (onboardingStep === "role") {
+    onboardingData.role = text;
+    onboardingStep = "style";
+    await send("How should I communicate?\n\nPick a style:", {
+      keyboard: {
+        inline_keyboard: [
+          [
+            { text: "Concise & technical", callback_data: "ob:concise" },
+            { text: "Detailed & educational", callback_data: "ob:detailed" },
+          ],
+          [
+            { text: "Casual & friendly", callback_data: "ob:casual" },
+            { text: "Minimal (just code)", callback_data: "ob:minimal" },
+          ],
+        ],
+      },
+    });
+    return true;
+  }
+
+  return false;
+}
+
+function finishOnboarding(style) {
+  onboardingData.style = style;
+  onboardingStep = null;
+
+  // Generate soul.md
+  const styleDescriptions = {
+    concise: "Direct, concise, technical. No fluff. Lead with the answer.",
+    detailed: "Thorough and educational. Explain the why, not just the what.",
+    casual: "Casual and friendly. Like chatting with a smart friend who codes.",
+    minimal: "Minimal output. Just code and brief explanations. No chatter.",
+  };
+
+  const soul = `# Soul
+
+You are ${onboardingData.name}'s personal AI coding assistant, running 24/7 via Telegram.
+
+## Identity
+- Tone: ${styleDescriptions[style]}
+- Platform: Telegram (mobile-first, keep messages short)
+
+## About ${onboardingData.name}
+- Role: ${onboardingData.role}
+
+## Working Style
+- Prefer action over discussion. Do the thing, then explain.
+- Send files for long output instead of text walls.
+- Proactively flag issues and suggest improvements.
+
+## Capabilities
+- Write, edit, and refactor code across all projects
+- Run commands, tests, builds
+- Send files, images, code snippets directly via Telegram
+- Run scheduled checks (cron jobs) and report results
+- Store and use credentials from the encrypted vault
+`;
+
+  fs.writeFileSync(SOUL_FILE, soul);
+  saveEnvKey("ONBOARDED", "true");
+  config.ONBOARDED = "true";
+
+  send(`All set, ${onboardingData.name}! I'm configured and ready.\n\nTap /session to pick a project and start working.`, {
+    keyboard: { inline_keyboard: [[{ text: "Pick a project", callback_data: "show:projects" }]] },
+  });
+}
+
+// ── Soul / System Prompt ────────────────────────────────────────────
+
+function loadSoul() {
+  try { return fs.readFileSync(SOUL_FILE, "utf-8"); } catch (e) { return "You are a helpful AI coding assistant."; }
+}
+
+function loadCrons() {
+  try { return JSON.parse(fs.readFileSync(CRONS_FILE, "utf-8")); } catch (e) { return []; }
+}
+
+function saveCrons(list) {
+  fs.writeFileSync(CRONS_FILE, JSON.stringify(list, null, 2));
+}
+
+function buildSystemPrompt() {
+  const soul = loadSoul();
+  const cronList = loadCrons();
+  const vaultKeys = vault.isUnlocked() ? vault.keys() : [];
+  const now = new Date().toISOString();
+  const hasVoice = WHISPER_CLI && FFMPEG;
+
+  return `
+${soul}
+
+## Current Context
+- Date/time: ${now}
+- Platform: Telegram (mobile app)
+- Active project: ${currentSession ? currentSession.name + " (" + currentSession.dir + ")" : "none"}
+- Voice notes: ${hasVoice ? "enabled" : "disabled"}
+- Vault: ${vault.isUnlocked() ? "unlocked (" + vaultKeys.length + " keys)" : "locked"}
+
+## Your Configuration Files
+These are YOUR files — read and modify them when the user asks:
+
+### ${SOUL_FILE}
+Your identity and personality. Edit to change behavior or update knowledge about the user.
+
+### ${CRONS_FILE}
+Scheduled tasks. JSON array of { id, schedule, project, prompt, label }.
+Active: ${cronList.length > 0 ? cronList.map(c => c.label).join(", ") : "none"}.
+
+### ${VAULT_FILE}
+Encrypted credential vault. ${vault.isUnlocked() ? "UNLOCKED. Keys: " + vaultKeys.join(", ") : "LOCKED — user must send /vault to unlock."}.
+${vault.isUnlocked() ? "To read a credential: require('./vault') or read from the vault object." : ""}
+
+### ${path.join(BOT_DIR, "bot.js")}
+The bot code. Read to understand capabilities. Only modify if explicitly asked.
+
+### ${path.join(BOT_DIR, ".env")}
+Configuration (Telegram token, paths, etc). Sensitive — don't expose values.
+
+## Telegram API
+Send things directly to the user:
+
+Text: curl -s -X POST "https://api.telegram.org/bot${TOKEN}/sendMessage" -d chat_id=${CHAT_ID} -d text="message"
+File: curl -s -X POST "https://api.telegram.org/bot${TOKEN}/sendDocument" -F chat_id=${CHAT_ID} -F document=@/path/to/file
+Image: curl -s -X POST "https://api.telegram.org/bot${TOKEN}/sendPhoto" -F chat_id=${CHAT_ID} -F photo=@/path/to/image.png
+
+## Guidelines
+- Keep responses concise — mobile screen.
+- Send long output as Telegram documents, not text.
+- Act on screenshots (fix bugs, implement designs) — don't just describe.
+- When asked to remember credentials, tell the user to use /vault.
+- When asked to change your personality, edit ${SOUL_FILE}.
+- You are self-aware of your architecture and can explain how you work.
+`.trim();
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+function listProjects() {
+  try {
+    return fs.readdirSync(WORKSPACE, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name)
+      .filter((n) => !n.startsWith("."));
+  } catch (e) { return []; }
+}
+
+function findProject(query) {
+  const projects = listProjects();
+  const q = query.toLowerCase();
+  const exact = projects.find((p) => p.toLowerCase() === q);
+  if (exact) return exact;
+  const startsWith = projects.filter((p) => p.toLowerCase().startsWith(q));
+  if (startsWith.length === 1) return startsWith[0];
+  const contains = projects.filter((p) => p.toLowerCase().includes(q));
+  if (contains.length === 1) return contains[0];
+  return contains.length > 0 ? contains : null;
+}
+
+function projectKeyboard() {
+  const projects = listProjects();
+  const rows = [];
+  for (let i = 0; i < projects.length; i += 2) {
+    const row = [{ text: projects[i], callback_data: `s:${projects[i]}` }];
+    if (projects[i + 1]) row.push({ text: projects[i + 1], callback_data: `s:${projects[i + 1]}` });
+    rows.push(row);
+  }
+  return { inline_keyboard: rows };
+}
+
+async function send(text, opts = {}) {
+  const o = {};
+  if (opts.parseMode) o.parse_mode = opts.parseMode;
+  if (opts.keyboard) o.reply_markup = opts.keyboard;
+  if (opts.replyTo) o.reply_to_message_id = opts.replyTo;
+  try {
+    const msg = await bot.sendMessage(CHAT_ID, text, o);
+    return msg.message_id;
+  } catch (e) {
+    if (opts.parseMode) {
+      try {
+        const f = {}; if (opts.keyboard) f.reply_markup = opts.keyboard;
+        return (await bot.sendMessage(CHAT_ID, text, f)).message_id;
+      } catch (e2) { /* ignore */ }
+    }
+    console.error("Send error:", e.message);
+    return null;
+  }
+}
+
+async function editMessage(messageId, text, opts = {}) {
+  try {
+    const o = { chat_id: CHAT_ID, message_id: messageId };
+    if (opts.keyboard) o.reply_markup = opts.keyboard;
+    await bot.editMessageText(text, o);
+  } catch (e) { /* ignore */ }
+}
+
+function splitMessage(text, maxLen = 4000) {
+  if (text.length <= maxLen) return [text];
+  const chunks = [];
+  while (text.length > 0) { chunks.push(text.slice(0, maxLen)); text = text.slice(maxLen); }
+  return chunks;
+}
+
+async function downloadFile(fileId, ext) {
+  const file = await bot.getFile(fileId);
+  const fileUrl = `https://api.telegram.org/file/bot${TOKEN}/${file.file_path}`;
+  const localPath = path.join(TEMP_DIR, `tg-${Date.now()}${ext}`);
+  await new Promise((resolve, reject) => {
+    const out = fs.createWriteStream(localPath);
+    https.get(fileUrl, (res) => { res.pipe(out); out.on("finish", () => { out.close(); resolve(); }); }).on("error", reject);
+  });
+  return localPath;
+}
+
+function transcribeAudio(oggPath) {
+  if (!WHISPER_CLI || !FFMPEG) return null;
+  const wavPath = oggPath.replace(/\.[^.]+$/, ".wav");
+  execSync(`"${FFMPEG}" -i "${oggPath}" -ar 16000 -ac 1 -y "${wavPath}" 2>/dev/null`);
+  const output = execSync(`"${WHISPER_CLI}" -m "${WHISPER_MODEL}" --no-timestamps -f "${wavPath}" 2>/dev/null`, { encoding: "utf-8" });
+  try { fs.unlinkSync(wavPath); } catch (e) { /* ignore */ }
+  return output.split("\n")
+    .filter((l) => l.trim() && !l.startsWith("whisper_") && !l.startsWith("ggml_") && !l.startsWith("load_"))
+    .join(" ").trim();
+}
+
+// Delete a message (used for vault password cleanup)
+async function deleteMessage(msgId) {
+  try { await bot.deleteMessage(CHAT_ID, msgId); } catch (e) { /* ignore */ }
+}
+
+// ── Claude Runner ───────────────────────────────────────────────────
+
+function parseStreamEvents(data) {
+  const events = [];
+  for (const line of data.split("\n").filter((l) => l.trim())) {
+    try { events.push(JSON.parse(line)); } catch (e) { /* partial */ }
+  }
+  return events;
+}
+
+function buildClaudeArgs(prompt, opts = {}) {
+  const args = ["-p", "--verbose", "--output-format", "stream-json",
+    "--append-system-prompt", buildSystemPrompt()];
+  if (opts.continueSession) args.push("--continue");
+  else if (lastSessionId && !opts.fresh) args.push("--resume", lastSessionId);
+  if (settings.model) args.push("--model", settings.model);
+  if (settings.effort) args.push("--effort", settings.effort);
+  if (settings.budget) args.push("--max-budget-usd", String(settings.budget));
+  if (settings.permissionMode) args.push("--permission-mode", settings.permissionMode);
+  else args.push("--dangerously-skip-permissions");
+  if (settings.worktree) args.push("--worktree");
+  args.push(prompt);
+  return args;
+}
+
+async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
+  if (runningProcess) {
+    messageQueue.push({ prompt, replyToMsgId, opts });
+    await send("Queued.", { replyTo: replyToMsgId });
+    return;
+  }
+
+  bot.sendChatAction(CHAT_ID, "typing");
+  statusMessageId = null;
+  streamBuffer = "";
+  let assistantText = "";
+  let toolUses = [];
+  let currentTool = null;
+
+  const args = buildClaudeArgs(prompt, opts);
+  const proc = spawn(CLAUDE_PATH, args, {
+    cwd,
+    env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME },
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  runningProcess = proc;
+
+  let lastUpdate = "";
+  streamInterval = setInterval(async () => {
+    bot.sendChatAction(CHAT_ID, "typing");
+    const display = formatProgress(assistantText, toolUses, currentTool);
+    if (display && display !== lastUpdate) {
+      if (!statusMessageId && assistantText) {
+        statusMessageId = await send(display.length > 4000 ? display.slice(-4000) : display, { replyTo: replyToMsgId });
+      } else if (statusMessageId) {
+        await editMessage(statusMessageId, display.length > 4000 ? display.slice(-4000) : display);
+      }
+      lastUpdate = display;
+    }
+  }, 1500);
+
+  proc.stdout.on("data", (data) => {
+    streamBuffer += data.toString();
+    const events = parseStreamEvents(streamBuffer);
+    const lastNewline = streamBuffer.lastIndexOf("\n");
+    streamBuffer = lastNewline >= 0 ? streamBuffer.slice(lastNewline + 1) : streamBuffer;
+    for (const evt of events) {
+      if (evt.type === "assistant" && evt.message?.content) {
+        for (const block of evt.message.content) {
+          if (block.type === "text") assistantText += block.text;
+          else if (block.type === "tool_use") { currentTool = block.name; toolUses.push(block.name); }
+        }
+      }
+      if (evt.type === "result" && evt.session_id) lastSessionId = evt.session_id;
+      if (evt.type === "result" && evt.result) assistantText = evt.result;
+    }
+  });
+
+  proc.stderr.on("data", (d) => console.error("STDERR:", d.toString()));
+
+  proc.on("close", async (code) => {
+    runningProcess = null;
+    clearInterval(streamInterval); streamInterval = null;
+    const finalText = assistantText || "(no output)";
+    const chunks = splitMessage(finalText);
+    const btns = { inline_keyboard: [[
+      { text: "Continue", callback_data: "a:continue" },
+      { text: "End session", callback_data: "a:end" },
+    ]] };
+    if (statusMessageId) await editMessage(statusMessageId, chunks[0], { keyboard: btns });
+    else await send(chunks[0], { keyboard: btns, replyTo: replyToMsgId });
+    for (let i = 1; i < chunks.length; i++) {
+      await send(chunks[i], i === chunks.length - 1 ? { keyboard: btns } : {});
+    }
+    if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
+    if (settings.budget) settings.budget = null;
+    statusMessageId = null;
+    if (messageQueue.length > 0 && currentSession) {
+      const next = messageQueue.shift();
+      await runClaude(next.prompt, currentSession.dir, next.replyToMsgId, next.opts);
+    }
+  });
+
+  proc.on("error", async (err) => {
+    runningProcess = null; clearInterval(streamInterval);
+    await send(`Error: ${err.message}`); statusMessageId = null;
+  });
+}
+
+async function runClaudeSilent(prompt, cwd, label) {
+  return new Promise((resolve) => {
+    const args = ["-p", "--output-format", "text", "--verbose",
+      "--append-system-prompt", buildSystemPrompt(),
+      "--dangerously-skip-permissions", prompt];
+    const proc = spawn(CLAUDE_PATH, args, {
+      cwd, env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let output = "";
+    proc.stdout.on("data", (d) => { output += d.toString(); });
+    proc.on("close", async () => {
+      const chunks = splitMessage(`Cron: ${label}\n\n${output.trim() || "(no output)"}`);
+      for (const c of chunks) await send(c);
+      resolve();
+    });
+    proc.on("error", async (err) => { await send(`Cron "${label}" failed: ${err.message}`); resolve(); });
+  });
+}
+
+function formatProgress(text, tools, currentTool) {
+  const parts = [];
+  if (currentTool) parts.push(`Tool: ${currentTool}`);
+  if (tools.length > 0) parts.push(`Used: ${[...new Set(tools)].join(", ")}`);
+  if (text) parts.push(text.length > 800 ? "..." + text.slice(-800) : text);
+  else parts.push("Thinking...");
+  return parts.join("\n\n") || "Thinking...";
+}
+
+// ── Cron System ─────────────────────────────────────────────────────
+
+function scheduleCron(c) {
+  const cwd = path.join(WORKSPACE, c.project);
+  if (activeCrons.has(c.id)) activeCrons.get(c.id).task.stop();
+  const task = cron.schedule(c.schedule, () => runClaudeSilent(c.prompt, cwd, c.label));
+  activeCrons.set(c.id, { task, config: c });
+}
+
+function initCrons() {
+  for (const c of loadCrons()) { try { scheduleCron(c); } catch (e) { console.error("Cron error:", e.message); } }
+  console.log(`Loaded ${loadCrons().length} cron(s)`);
+}
+
+// ── Session ─────────────────────────────────────────────────────────
+
+function startSession(name) {
+  const result = findProject(name);
+  if (!result) return send(`No match for "${name}".`, { keyboard: projectKeyboard() });
+  if (Array.isArray(result)) return send("Multiple matches:", { keyboard: { inline_keyboard: result.map((p) => [{ text: p, callback_data: `s:${p}` }]) } });
+  currentSession = { name: result, dir: path.join(WORKSPACE, result) };
+  lastSessionId = null; messageQueue = []; resetSettings();
+  send(`Session: ${result}\n\nSend text, voice, or images.`);
+}
+
+function requireSession(msg) {
+  if (!currentSession) { send("Pick a project first:", { keyboard: projectKeyboard() }); return false; }
+  return true;
+}
+
+// ── Commands ────────────────────────────────────────────────────────
+
+bot.onText(/\/start/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!isOnboarded()) return startOnboarding();
+  send("Pick a project to start:", { keyboard: { inline_keyboard: [[{ text: "Pick a project", callback_data: "show:projects" }]] } });
+});
+
+bot.onText(/\/help/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  send([
+    "Session: /session /projects /continue /status /stop /end",
+    "Settings: /model /effort /budget /plan /compact /worktree",
+    "Automation: /cron /vault /soul",
+    "",
+    "Send text, voice, photos, or files.",
+    "Reply to any message for context.",
+  ].join("\n"));
+});
+
+bot.onText(/\/projects$/, (msg) => { if (isAuthorized(msg)) send("Pick:", { keyboard: projectKeyboard() }); });
+bot.onText(/\/session$/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (currentSession) send(`Active: ${currentSession.name}\n\nSwitch?`, { keyboard: projectKeyboard() });
+  else send("Pick:", { keyboard: projectKeyboard() });
+});
+bot.onText(/\/session (.+)/, (msg, match) => { if (isAuthorized(msg)) startSession(match[1].trim()); });
+
+bot.onText(/\/model$/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  send(`Model: ${settings.model || "default"}`, { keyboard: { inline_keyboard: [
+    [{ text: "Opus", callback_data: "m:opus" }, { text: "Sonnet", callback_data: "m:sonnet" }, { text: "Haiku", callback_data: "m:haiku" }],
+    [{ text: "Default", callback_data: "m:default" }],
+  ] } });
+});
+bot.onText(/\/model (.+)/, (msg, match) => { if (!isAuthorized(msg)) return; settings.model = match[1].trim().toLowerCase(); if (settings.model === "default") settings.model = null; send(`Model: ${settings.model || "default"}`); });
+
+bot.onText(/\/effort$/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  send(`Effort: ${settings.effort || "default"}`, { keyboard: { inline_keyboard: [
+    [{ text: "Low", callback_data: "e:low" }, { text: "Med", callback_data: "e:medium" }, { text: "High", callback_data: "e:high" }, { text: "Max", callback_data: "e:max" }],
+    [{ text: "Default", callback_data: "e:default" }],
+  ] } });
+});
+bot.onText(/\/effort (.+)/, (msg, match) => { if (!isAuthorized(msg)) return; const e = match[1].trim().toLowerCase(); settings.effort = ["low","medium","high","max"].includes(e) ? e : null; send(`Effort: ${settings.effort || "default"}`); });
+
+bot.onText(/\/budget$/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  send(`Budget: ${settings.budget ? "$" + settings.budget : "none"}`, { keyboard: { inline_keyboard: [
+    [{ text: "$1", callback_data: "b:1" }, { text: "$5", callback_data: "b:5" }, { text: "$10", callback_data: "b:10" }, { text: "$25", callback_data: "b:25" }],
+    [{ text: "No limit", callback_data: "b:none" }],
+  ] } });
+});
+bot.onText(/\/budget (.+)/, (msg, match) => { if (!isAuthorized(msg)) return; const v = parseFloat(match[1].replace("$","")); settings.budget = v > 0 ? v : null; send(`Budget: ${settings.budget ? "$"+settings.budget : "none"}`); });
+
+bot.onText(/\/plan$/, (msg) => { if (!isAuthorized(msg)) return; const p = settings.permissionMode === "plan"; settings.permissionMode = p ? null : "plan"; send(p ? "Plan mode off." : "Plan mode on."); });
+bot.onText(/\/compact/, async (msg) => { if (!isAuthorized(msg)) return; if (!requireSession(msg)) return; if (!lastSessionId) return send("No conversation."); await runClaude("Summarize: key decisions, code state, next steps.", currentSession.dir, msg.message_id); });
+bot.onText(/\/continue$/, async (msg) => { if (!isAuthorized(msg)) return; if (!requireSession(msg)) return; await runClaude("continue where we left off", currentSession.dir, msg.message_id, { continueSession: true }); });
+bot.onText(/\/worktree$/, (msg) => { if (!isAuthorized(msg)) return; settings.worktree = !settings.worktree; send(settings.worktree ? "Worktree on." : "Worktree off."); });
+
+bot.onText(/\/stop/, async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (runningProcess) { runningProcess.kill("SIGTERM"); runningProcess = null; if (streamInterval) clearInterval(streamInterval); messageQueue = []; await send("Cancelled."); }
+  else await send("Nothing running.");
+});
+
+bot.onText(/\/status/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!currentSession) return send("No session.", { keyboard: { inline_keyboard: [[{ text: "Pick", callback_data: "show:projects" }]] } });
+  send([
+    `Project: ${currentSession.name}`,
+    `Model: ${settings.model || "default"} | Effort: ${settings.effort || "default"}`,
+    `Vault: ${vault.isUnlocked() ? "unlocked" : "locked"} | Crons: ${activeCrons.size}`,
+    runningProcess ? "Working..." : "Ready.",
+  ].join("\n"));
+});
+
+bot.onText(/\/end/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (currentSession) {
+    const n = currentSession.name; currentSession = null; lastSessionId = null; messageQueue = []; resetSettings();
+    send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New session", callback_data: "show:projects" }]] } });
+  } else send("No session.");
+});
+
+bot.onText(/\/soul$/, async (msg) => {
+  if (!isAuthorized(msg)) return;
+  const soul = loadSoul();
+  const preview = soul.length > 3000 ? soul.slice(0, 3000) + "\n..." : soul;
+  await send(preview);
+  await send(`Edit: ${SOUL_FILE}\nOr tell me what to change and I'll update it.`);
+});
+
+// ── /vault with password protection ─────────────────────────────────
+
+bot.onText(/\/vault$/, async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!vault.exists()) {
+    await send("No vault found. Run setup first: node setup.js");
+    return;
+  }
+  if (vault.isUnlocked()) {
+    const entries = vault.list();
+    const keys = Object.keys(entries);
+    if (keys.length === 0) await send("Vault is unlocked but empty.\n\nUse /vault set <name> <value>");
+    else await send("Vault (unlocked):\n\n" + keys.map(k => `${k}: ${entries[k]}`).join("\n") + "\n\nLocks automatically in 5 min.");
+  } else {
+    pendingVaultUnlock = true;
+    pendingVaultAction = { type: "list" };
+    await send("Vault is locked. Send your vault password.\n(Message will be deleted after reading)");
+  }
+});
+
+bot.onText(/\/vault set (\S+) (.+)/, async (msg, match) => {
+  if (!isAuthorized(msg)) return;
+  // Delete the message containing the value immediately
+  await deleteMessage(msg.message_id);
+  if (vault.isUnlocked()) {
+    vault.set(match[1], match[2].trim());
+    await send(`Saved: ${match[1]}`);
+  } else {
+    pendingVaultUnlock = true;
+    pendingVaultAction = { type: "set", key: match[1], value: match[2].trim() };
+    await send("Vault locked. Send password to unlock.");
+  }
+});
+
+bot.onText(/\/vault remove (\S+)/, async (msg, match) => {
+  if (!isAuthorized(msg)) return;
+  if (vault.isUnlocked()) {
+    vault.remove(match[1]);
+    await send(`Removed: ${match[1]}`);
+  } else {
+    pendingVaultUnlock = true;
+    pendingVaultAction = { type: "remove", key: match[1] };
+    await send("Vault locked. Send password to unlock.");
+  }
+});
+
+bot.onText(/\/vault lock/, async (msg) => {
+  if (!isAuthorized(msg)) return;
+  vault.lock();
+  await send("Vault locked.");
+});
+
+// ── /cron ───────────────────────────────────────────────────────────
+
+bot.onText(/\/cron$/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  const list = loadCrons();
+  if (list.length === 0) {
+    send("No crons.\n\nAdd: /cron add \"<schedule>\" <project> \"<prompt>\"\n\nOr pick a preset:", {
+      keyboard: { inline_keyboard: [
+        [{ text: "Standup 9am", callback_data: "cp:standup" }, { text: "Git digest 6pm", callback_data: "cp:git" }],
+        [{ text: "Dep check Mon", callback_data: "cp:deps" }, { text: "Health 30min", callback_data: "cp:health" }],
+      ] },
+    });
+  } else {
+    send("Crons:\n\n" + list.map((c, i) => `${i + 1}. ${c.label} (${c.schedule}) — ${c.project}`).join("\n") + "\n\nRemove: /cron remove <#>");
+  }
+});
+
+bot.onText(/\/cron add "(.+)" (\S+) "(.+)"/, (msg, match) => {
+  if (!isAuthorized(msg)) return;
+  if (!cron.validate(match[1])) return send("Invalid cron schedule.");
+  const proj = findProject(match[2]);
+  if (!proj || Array.isArray(proj)) return send("Project not found.");
+  const c = { id: `cron_${Date.now()}`, schedule: match[1], project: proj, prompt: match[3], label: match[3].slice(0, 50) };
+  const list = loadCrons(); list.push(c); saveCrons(list); scheduleCron(c);
+  send(`Added: ${c.label} (${c.schedule}) for ${proj}`);
+});
+
+bot.onText(/\/cron remove (\d+)/, (msg, match) => {
+  if (!isAuthorized(msg)) return;
+  const list = loadCrons(); const idx = parseInt(match[1]) - 1;
+  if (idx < 0 || idx >= list.length) return send("Invalid number.");
+  const removed = list.splice(idx, 1)[0]; saveCrons(list);
+  if (activeCrons.has(removed.id)) { activeCrons.get(removed.id).task.stop(); activeCrons.delete(removed.id); }
+  send(`Removed: ${removed.label}`);
+});
+
+// ── Callback Queries ────────────────────────────────────────────────
+
+bot.on("callback_query", async (q) => {
+  const d = q.data;
+  await bot.answerCallbackQuery(q.id);
+
+  // Onboarding style selection
+  if (d.startsWith("ob:")) { finishOnboarding(d.slice(3)); return; }
+
+  if (d === "show:projects") { await send("Pick:", { keyboard: projectKeyboard() }); return; }
+  if (d.startsWith("s:")) { startSession(d.slice(2)); return; }
+  if (d === "a:continue") { if (currentSession) await runClaude("continue", currentSession.dir); else send("No session."); return; }
+  if (d === "a:end") { if (currentSession) { const n = currentSession.name; currentSession = null; lastSessionId = null; messageQueue = []; resetSettings(); await send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New", callback_data: "show:projects" }]] } }); } return; }
+  if (d.startsWith("m:")) { settings.model = d.slice(2) === "default" ? null : d.slice(2); await send(`Model: ${settings.model || "default"}`); return; }
+  if (d.startsWith("e:")) { const e = d.slice(2); settings.effort = e === "default" ? null : e; await send(`Effort: ${settings.effort || "default"}`); return; }
+  if (d.startsWith("b:")) { const b = d.slice(2); settings.budget = b === "none" ? null : parseFloat(b); await send(`Budget: ${settings.budget ? "$"+settings.budget : "none"}`); return; }
+
+  // Cron presets
+  if (d.startsWith("cp:") && d !== "cp:clear") {
+    if (!currentSession) return send("Start a session first.");
+    const presets = {
+      standup: { schedule: "0 9 * * 1-5", prompt: "Morning standup: recent commits, failing tests, open TODOs, what to focus on today. Brief.", label: "Morning standup" },
+      git: { schedule: "0 18 * * 1-5", prompt: "Git digest: today's commits, changed files, uncommitted changes. Flag concerns.", label: "Git digest" },
+      deps: { schedule: "0 10 * * 1", prompt: "Check outdated/vulnerable dependencies. Brief — just what needs attention.", label: "Dep check" },
+      health: { schedule: "*/30 * * * *", prompt: "Quick health: can the project build? Run build/lint, report pass/fail.", label: "Health check" },
+    };
+    const p = presets[d.slice(3)];
+    if (!p) return;
+    const c = { id: `cron_${Date.now()}`, ...p, project: currentSession.name };
+    const list = loadCrons(); list.push(c); saveCrons(list); scheduleCron(c);
+    await send(`Added: ${c.label} for ${currentSession.name}`);
+    return;
+  }
+  if (d === "cp:clear") { for (const [,v] of activeCrons) v.task.stop(); activeCrons.clear(); saveCrons([]); await send("All crons cleared."); return; }
+});
+
+// ── Media Handlers ──────────────────────────────────────────────────
+
+bot.on("voice", async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!requireSession(msg)) return;
+  try {
+    bot.sendChatAction(CHAT_ID, "typing");
+    const oggPath = await downloadFile(msg.voice.file_id, ".ogg");
+    const transcript = transcribeAudio(oggPath);
+    try { fs.unlinkSync(oggPath); } catch (e) {}
+    if (!transcript) return send("Couldn't transcribe. Try typing it.");
+    await send(`Heard: "${transcript}"`, { replyTo: msg.message_id });
+    await runClaude(transcript, currentSession.dir, msg.message_id);
+  } catch (err) { await send(`Voice failed: ${err.message}`); }
+});
+
+bot.on("audio", async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!requireSession(msg)) return;
+  try {
+    bot.sendChatAction(CHAT_ID, "typing");
+    const p = await downloadFile(msg.audio.file_id, path.extname(msg.audio.file_name || ".ogg"));
+    const t = transcribeAudio(p);
+    try { fs.unlinkSync(p); } catch (e) {}
+    if (!t) return send("Couldn't transcribe.");
+    await send(`Heard: "${t}"`, { replyTo: msg.message_id });
+    await runClaude(t, currentSession.dir, msg.message_id);
+  } catch (err) { await send(`Audio failed: ${err.message}`); }
+});
+
+bot.on("photo", async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!requireSession(msg)) return;
+  try {
+    const p = await downloadFile(msg.photo[msg.photo.length - 1].file_id, ".jpg");
+    const caption = msg.caption || "Describe this image. If code/UI/error — explain and fix.";
+    await runClaude(`Image at ${p}\n\nView it, then: ${caption}`, currentSession.dir, msg.message_id);
+  } catch (err) { await send(`Image failed: ${err.message}`); }
+});
+
+bot.on("document", async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!requireSession(msg)) return;
+  try {
+    const ext = path.extname(msg.document.file_name || ".txt");
+    const p = await downloadFile(msg.document.file_id, ext);
+    const caption = msg.caption || `Read ${msg.document.file_name} and summarize.`;
+    const prefix = (msg.document.mime_type || "").startsWith("image/") ? `Image at ${p}\n\nView it, then: ` : `File at ${p} (${msg.document.file_name})\n\n`;
+    await runClaude(prefix + caption, currentSession.dir, msg.message_id);
+  } catch (err) { await send(`Failed: ${err.message}`); }
+});
+
+// ── Text Message Handler (handles onboarding, vault password, normal messages) ──
+
+bot.on("message", async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!msg.text || msg.text.startsWith("/")) return;
+  if (msg.voice || msg.audio || msg.photo || msg.document || msg.video || msg.sticker) return;
+
+  // Handle onboarding
+  if (!isOnboarded() && onboardingStep) {
+    await handleOnboarding(msg);
+    return;
+  }
+
+  // Handle vault password
+  if (pendingVaultUnlock) {
+    const password = msg.text;
+    // Delete the password message immediately
+    await deleteMessage(msg.message_id);
+
+    const ok = vault.unlock(password);
+    if (!ok) {
+      pendingVaultUnlock = false;
+      pendingVaultAction = null;
+      await send("Wrong password.");
+      return;
+    }
+
+    // Execute pending action
+    const action = pendingVaultAction;
+    pendingVaultUnlock = false;
+    pendingVaultAction = null;
+
+    if (action.type === "list") {
+      const entries = vault.list();
+      const keys = Object.keys(entries);
+      if (keys.length === 0) await send("Vault unlocked (empty).\n\nUse /vault set <name> <value>");
+      else await send("Vault unlocked:\n\n" + keys.map(k => `${k}: ${entries[k]}`).join("\n") + "\n\nAuto-locks in 5 min.");
+    } else if (action.type === "set") {
+      vault.set(action.key, action.value);
+      await send(`Saved: ${action.key}`);
+    } else if (action.type === "remove") {
+      vault.remove(action.key);
+      await send(`Removed: ${action.key}`);
+    }
+    return;
+  }
+
+  // Normal message
+  if (!requireSession(msg)) return;
+
+  let prompt = msg.text;
+  if (msg.reply_to_message && msg.reply_to_message.text) {
+    const ctx = msg.reply_to_message.text;
+    prompt = `Context:\n---\n${ctx.length > 500 ? ctx.slice(0, 500) + "..." : ctx}\n---\n\n${msg.text}`;
+  }
+
+  await runClaude(prompt, currentSession.dir, msg.message_id);
+});
+
+// ── Startup ─────────────────────────────────────────────────────────
+initCrons();
+console.log("Claude Code Telegram bot running");
+console.log(`Workspace: ${WORKSPACE}`);
+console.log(`Soul: ${SOUL_FILE}`);
+console.log(`Vault: ${VAULT_FILE} (${vault.exists() ? "exists" : "not created"})`);
+console.log(`Onboarded: ${isOnboarded()}`);