@tspappsen/elamax 1.2.3

package/dist/setup.js

@@ -0,0 +1,476 @@
+import * as readline from "readline";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { CopilotClient } from "@github/copilot-sdk";
+import { ensureMaxHome, ENV_PATH, IS_WATCHDOG, MAX_HOME, MAX_PROFILE } from "./paths.js";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const RESET = "\x1b[0m";
+const FALLBACK_MODELS = [
+    { id: "claude-sonnet-4.6", label: "Claude Sonnet 4.6", desc: "Fast, great for most tasks" },
+    { id: "gpt-5.1", label: "GPT-5.1", desc: "OpenAI's fast model" },
+    { id: "gpt-4.1", label: "GPT-4.1", desc: "Free included model" },
+];
+async function fetchModels() {
+    let client;
+    try {
+        client = new CopilotClient({ autoStart: true });
+        await client.start();
+        const models = await client.listModels();
+        return models
+            .filter((m) => m.policy?.state === "enabled" && !m.name.includes("(Internal only)"))
+            .map((m) => {
+            const mult = m.billing?.multiplier;
+            const desc = mult === 0 || mult === undefined ? "Included with Copilot" : `Premium (${mult}x)`;
+            return { id: m.id, label: m.name, desc };
+        });
+    }
+    catch {
+        return [];
+    }
+    finally {
+        try {
+            await client?.stop();
+        }
+        catch { /* best-effort */ }
+    }
+}
+function ask(rl, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+async function askRequired(rl, prompt) {
+    while (true) {
+        const answer = (await ask(rl, prompt)).trim();
+        if (answer)
+            return answer;
+        console.log(`${YELLOW}  This field is required. Please enter a value.${RESET}`);
+    }
+}
+async function askYesNo(rl, question, defaultYes = false) {
+    const hint = defaultYes ? "(Y/n)" : "(y/N)";
+    const answer = (await ask(rl, `${question} ${hint} `)).trim().toLowerCase();
+    if (answer === "")
+        return defaultYes;
+    return answer === "y" || answer === "yes";
+}
+async function askPicker(rl, label, options, defaultId) {
+    console.log(`${BOLD}${label}${RESET}\n`);
+    const defaultIdx = Math.max(0, options.findIndex((o) => o.id === defaultId));
+    for (let i = 0; i < options.length; i++) {
+        const marker = i === defaultIdx ? `${GREEN}▸${RESET}` : " ";
+        const tag = i === defaultIdx ? ` ${DIM}(default)${RESET}` : "";
+        console.log(`  ${marker} ${CYAN}${i + 1}${RESET}  ${options[i].label}${tag}`);
+        console.log(`       ${DIM}${options[i].desc}${RESET}`);
+    }
+    console.log();
+    const input = await ask(rl, `  Pick a number ${DIM}(1-${options.length}, Enter for default)${RESET}: `);
+    const num = parseInt(input.trim(), 10);
+    if (num >= 1 && num <= options.length)
+        return options[num - 1].id;
+    return options[defaultIdx].id;
+}
+async function runWatchdogSetup(rl) {
+    console.log(`
+${BOLD}╔══════════════════════════════════════════╗
+║        🛡️  Max Watchdog Setup           ║
+╚══════════════════════════════════════════╝${RESET}
+`);
+    console.log(`${DIM}Config directory: ${MAX_HOME}${RESET}\n`);
+    ensureMaxHome();
+    const existing = {};
+    if (existsSync(ENV_PATH)) {
+        for (const line of readFileSync(ENV_PATH, "utf-8").split("\n")) {
+            const match = line.match(/^([A-Z_]+)=(.*)$/);
+            if (match)
+                existing[match[1]] = match[2];
+        }
+    }
+    console.log(`${BOLD}Watchdog basics${RESET}`);
+    console.log(`This profile runs a separate Max instance that watches your main Max`);
+    console.log(`process, alerts you when something breaks, and can help restart it.`);
+    console.log();
+    console.log(`${DIM}Use a separate Telegram bot token for the watchdog so its alerts stay distinct.${RESET}`);
+    console.log();
+    let telegramToken = existing.TELEGRAM_BOT_TOKEN || "";
+    while (true) {
+        const tokenInput = (await ask(rl, `Telegram bot token${telegramToken ? ` ${DIM}(Enter to keep current: ${telegramToken.slice(0, 12)}...)${RESET}` : ""}: `)).trim();
+        if (tokenInput) {
+            telegramToken = tokenInput;
+            break;
+        }
+        if (telegramToken)
+            break;
+        console.log(`${YELLOW}  This field is required. Please enter a value.${RESET}`);
+    }
+    let userId = existing.AUTHORIZED_USER_ID || "";
+    while (true) {
+        const userIdInput = (await ask(rl, `Authorized user ID${userId ? ` ${DIM}(current: ${userId})${RESET}` : ""}: `)).trim();
+        const nextUserId = userIdInput || userId;
+        const parsed = parseInt(nextUserId, 10);
+        if (nextUserId && !Number.isNaN(parsed) && parsed > 0) {
+            userId = nextUserId;
+            break;
+        }
+        console.log(`${YELLOW}  That doesn't look like a valid user ID. It should be a positive number.${RESET}`);
+    }
+    let apiPort = existing.API_PORT || "7778";
+    while (true) {
+        const apiPortInput = (await ask(rl, `API port ${DIM}(default: ${apiPort})${RESET}: `)).trim();
+        const nextPort = apiPortInput || apiPort;
+        const parsed = parseInt(nextPort, 10);
+        if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 65535) {
+            apiPort = nextPort;
+            break;
+        }
+        console.log(`${YELLOW}  Please enter a valid port between 1 and 65535.${RESET}`);
+    }
+    let mainMaxPm2Name = existing.MAIN_MAX_PM2_NAME || "max";
+    while (true) {
+        const pm2NameInput = (await ask(rl, `Main Max pm2 process name ${DIM}(default: ${mainMaxPm2Name})${RESET}: `)).trim();
+        const nextPm2Name = pm2NameInput || mainMaxPm2Name;
+        if (nextPm2Name) {
+            mainMaxPm2Name = nextPm2Name;
+            break;
+        }
+        console.log(`${YELLOW}  Please enter a process name.${RESET}`);
+    }
+    let discordToken = existing.DISCORD_BOT_TOKEN || "";
+    let discordChannelIds = existing.DISCORD_ALLOWED_CHANNEL_IDS || "";
+    const setupDiscord = await askYesNo(rl, "Would you like watchdog alerts in Discord too?", !!discordToken || !!discordChannelIds);
+    if (setupDiscord) {
+        while (true) {
+            const tokenInput = (await ask(rl, `Discord bot token${discordToken ? ` ${DIM}(Enter to keep current: ${discordToken.slice(0, 12)}...)${RESET}` : ""}: `)).trim();
+            if (tokenInput) {
+                discordToken = tokenInput;
+                break;
+            }
+            if (discordToken)
+                break;
+            console.log(`${YELLOW}  This field is required when Discord is enabled.${RESET}`);
+        }
+        while (true) {
+            const channelIdsInput = (await ask(rl, `Discord allowed channel IDs ${DIM}(comma-separated)${RESET}${discordChannelIds ? ` ${DIM}(current: ${discordChannelIds})${RESET}` : ""}: `)).trim();
+            if (channelIdsInput) {
+                discordChannelIds = channelIdsInput;
+                break;
+            }
+            if (discordChannelIds)
+                break;
+            console.log(`${YELLOW}  Please enter at least one channel ID when Discord is enabled.${RESET}`);
+        }
+    }
+    console.log(`\n${BOLD}━━━ Default Model ━━━${RESET}\n`);
+    console.log(`${DIM}Fetching available models from Copilot...${RESET}`);
+    let models = await fetchModels();
+    if (models.length === 0) {
+        console.log(`${YELLOW}  Could not fetch models (Copilot CLI may not be authenticated yet).${RESET}`);
+        console.log(`${DIM}  Showing a curated list — you can switch anytime after setup.${RESET}\n`);
+        models = FALLBACK_MODELS;
+    }
+    else {
+        console.log(`${GREEN}  ✓ Found ${models.length} models${RESET}\n`);
+    }
+    const currentModel = existing.COPILOT_MODEL || "claude-sonnet-4.6";
+    const model = await askPicker(rl, "Choose a default model:", models, currentModel);
+    const modelLabel = models.find((m) => m.id === model)?.label || model;
+    const lines = [
+        "# Max Watchdog Configuration",
+        "MAX_PROFILE=watchdog",
+        `TELEGRAM_BOT_TOKEN=${telegramToken}`,
+        `AUTHORIZED_USER_ID=${userId}`,
+        `API_PORT=${apiPort}`,
+        `MAIN_MAX_PM2_NAME=${mainMaxPm2Name}`,
+        `COPILOT_MODEL=${model}`,
+        "# Optional Discord",
+    ];
+    if (discordToken) {
+        lines.push(`DISCORD_BOT_TOKEN=${discordToken}`);
+    }
+    else {
+        lines.push("# DISCORD_BOT_TOKEN=<token>");
+    }
+    if (discordChannelIds) {
+        lines.push(`DISCORD_ALLOWED_CHANNEL_IDS=${discordChannelIds}`);
+    }
+    else {
+        lines.push("# DISCORD_ALLOWED_CHANNEL_IDS=<ids>");
+    }
+    writeFileSync(ENV_PATH, lines.join("\n") + "\n");
+    console.log(`
+${GREEN}${BOLD}✅ Max Watchdog is ready!${RESET}
+${DIM}Config saved to ${ENV_PATH}${RESET}
+
+${BOLD}Next steps:${RESET}
+
+  ${CYAN}•${RESET} Start the watchdog:
+    ${BOLD}MAX_PROFILE=watchdog max start${RESET}
+    ${BOLD}max start --profile watchdog${RESET}
+
+  ${CYAN}•${RESET} Register it with pm2:
+    ${BOLD}pm2 start "max start --profile watchdog" --name max-watchdog${RESET}
+
+  ${CYAN}•${RESET} Main Max pm2 process name:
+    ${BOLD}${mainMaxPm2Name}${RESET}
+
+  ${CYAN}•${RESET} Reminder:
+    Create a separate Telegram bot for the watchdog via ${BOLD}@BotFather${RESET}
+
+${GREEN}  ✓ Using ${modelLabel}${RESET}
+`);
+}
+async function main() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    if (MAX_PROFILE && IS_WATCHDOG) {
+        await runWatchdogSetup(rl);
+        rl.close();
+        return;
+    }
+    console.log(`
+${BOLD}╔══════════════════════════════════════════╗
+║           🤖  Max Setup                  ║
+╚══════════════════════════════════════════╝${RESET}
+`);
+    console.log(`${DIM}Config directory: ${MAX_HOME}${RESET}\n`);
+    ensureMaxHome();
+    // Load existing values if any
+    const existing = {};
+    if (existsSync(ENV_PATH)) {
+        for (const line of readFileSync(ENV_PATH, "utf-8").split("\n")) {
+            const match = line.match(/^([A-Z_]+)=(.*)$/);
+            if (match)
+                existing[match[1]] = match[2];
+        }
+    }
+    // ── What is Max ──────────────────────────────────────────
+    console.log(`${BOLD}Meet Max${RESET}`);
+    console.log(`Max is your personal AI assistant — an always-on daemon that runs on`);
+    console.log(`your machine. Talk to him in plain English and he'll handle the rest.`);
+    console.log();
+    console.log(`${CYAN}What Max can do out of the box:${RESET}`);
+    console.log(`  • Have conversations and answer questions`);
+    console.log(`  • Spin up Copilot CLI sessions to code, debug, and run commands`);
+    console.log(`  • Manage multiple background tasks simultaneously`);
+    console.log(`  • See and attach to any Copilot session on your machine`);
+    console.log();
+    console.log(`${CYAN}Skills — teach Max anything:${RESET}`);
+    console.log(`  Max has a skill system that lets him learn new capabilities. There's`);
+    console.log(`  an open source library of community skills he can install, or he can`);
+    console.log(`  write his own from scratch. Just ask him:`);
+    console.log();
+    console.log(`  ${DIM}"Check my email"${RESET}        → Max researches how, writes a skill, does it`);
+    console.log(`  ${DIM}"Turn off the lights"${RESET}   → Max finds the right CLI tool, learns it`);
+    console.log(`  ${DIM}"Find me a skill for"${RESET}   → Max searches community skills and installs one`);
+    console.log(`  ${DIM}"Learn how to use X"${RESET}    → Max proactively learns before you need it`);
+    console.log();
+    console.log(`  Skills are saved permanently — Max only needs to learn once.`);
+    console.log();
+    console.log(`${CYAN}How to talk to Max:${RESET}`);
+    console.log(`  • ${BOLD}Terminal${RESET}  — ${CYAN}max tui${RESET} — always available, no setup needed`);
+    console.log(`  • ${BOLD}Telegram${RESET} — control Max from your phone (optional, set up next)`);
+    console.log(`  • ${BOLD}Discord${RESET}  — control Max from Discord (optional, set up next)`);
+    console.log();
+    await ask(rl, `${DIM}Press Enter to continue...${RESET}`);
+    console.log();
+    // ── Telegram Setup ───────────────────────────────────────
+    console.log(`${BOLD}━━━ Telegram Setup (optional) ━━━${RESET}\n`);
+    console.log(`Telegram lets you talk to Max from your phone — send messages,`);
+    console.log(`dispatch coding tasks, and get notified when background work finishes.`);
+    console.log();
+    let telegramToken = existing.TELEGRAM_BOT_TOKEN || "";
+    let userId = existing.AUTHORIZED_USER_ID || "";
+    const setupTelegram = await askYesNo(rl, "Would you like to set up Telegram?");
+    if (setupTelegram) {
+        // ── Step 1: Create bot ──
+        console.log(`\n${BOLD}Step 1: Create a Telegram bot${RESET}\n`);
+        console.log(`  1. Open Telegram and search for ${BOLD}@BotFather${RESET}`);
+        console.log(`  2. Send ${CYAN}/newbot${RESET} and follow the prompts`);
+        console.log(`  3. Copy the bot token (looks like ${DIM}123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11${RESET})`);
+        console.log();
+        const tokenInput = await askRequired(rl, `  Bot token${telegramToken ? ` ${DIM}(current: ${telegramToken.slice(0, 12)}...)${RESET}` : ""}: `);
+        telegramToken = tokenInput;
+        // ── Step 2: Lock it down ──
+        console.log(`\n${BOLD}Step 2: Lock down your bot${RESET}\n`);
+        console.log(`${YELLOW}  ⚠  IMPORTANT: Your bot is currently open to anyone on Telegram.${RESET}`);
+        console.log(`  Max uses your Telegram user ID to ensure only YOU can control it.`);
+        console.log(`  Without this, anyone who finds your bot could send it commands.`);
+        console.log();
+        console.log(`  To get your user ID:`);
+        console.log(`  1. Search for ${BOLD}@userinfobot${RESET} on Telegram`);
+        console.log(`  2. Send it any message`);
+        console.log(`  3. It will reply with your user ID (a number like ${DIM}123456789${RESET})`);
+        console.log();
+        // Require user ID — cannot proceed without it
+        while (true) {
+            const userIdInput = await askRequired(rl, `  Your user ID${userId ? ` ${DIM}(current: ${userId})${RESET}` : ""}: `);
+            const parsed = parseInt(userIdInput, 10);
+            if (!Number.isNaN(parsed) && parsed > 0) {
+                userId = userIdInput;
+                break;
+            }
+            console.log(`${YELLOW}  That doesn't look like a valid user ID. It should be a positive number.${RESET}`);
+        }
+        console.log(`\n${GREEN}  ✓ Telegram locked down — only user ${userId} can control Max.${RESET}`);
+        // ── Step 3: Disable group joins ──
+        console.log(`\n${BOLD}Step 3: Disable group joins (recommended)${RESET}\n`);
+        console.log(`  For extra security, prevent your bot from being added to groups:`);
+        console.log(`  1. Go back to ${BOLD}@BotFather${RESET}`);
+        console.log(`  2. Send ${CYAN}/mybots${RESET} → select your bot → ${CYAN}Bot Settings${RESET} → ${CYAN}Allow Groups?${RESET}`);
+        console.log(`  3. Set to ${BOLD}Disable${RESET}`);
+        console.log();
+        await ask(rl, `  ${DIM}Press Enter when done (or skip)...${RESET}`);
+    }
+    else {
+        console.log(`\n${DIM}  Skipping Telegram. You can always set it up later with: max setup${RESET}\n`);
+    }
+    // ── Discord Setup ────────────────────────────────────────
+    console.log(`${BOLD}━━━ Discord Setup (optional) ━━━${RESET}\n`);
+    console.log(`Discord lets you talk to Max from any Discord server — send messages,`);
+    console.log(`dispatch coding tasks, and get notified when background work finishes.`);
+    console.log();
+    let discordToken = existing.DISCORD_BOT_TOKEN || "";
+    let discordChannelIds = existing.DISCORD_ALLOWED_CHANNEL_IDS || "";
+    const setupDiscord = await askYesNo(rl, "Would you like to set up Discord?");
+    if (setupDiscord) {
+        // ── Step 1: Create bot ──
+        console.log(`\n${BOLD}Step 1: Create a Discord bot${RESET}\n`);
+        console.log(`  1. Go to ${CYAN}https://discord.com/developers/applications${RESET}`);
+        console.log(`  2. Click ${BOLD}New Application${RESET}, give it a name`);
+        console.log(`  3. Go to ${BOLD}Bot${RESET} → click ${BOLD}Reset Token${RESET} → copy the token`);
+        console.log(`  4. Under ${BOLD}Privileged Gateway Intents${RESET}, enable ${BOLD}Message Content Intent${RESET}`);
+        console.log();
+        const tokenInput = await askRequired(rl, `  Bot token${discordToken ? ` ${DIM}(current: ${discordToken.slice(0, 12)}...)${RESET}` : ""}: `);
+        discordToken = tokenInput;
+        // ── Step 2: Invite bot to server ──
+        console.log(`\n${BOLD}Step 2: Invite the bot to your server${RESET}\n`);
+        console.log(`  1. In the Developer Portal, go to ${BOLD}OAuth2${RESET}`);
+        console.log(`  2. Under ${BOLD}OAuth2 URL Generator${RESET}:`);
+        console.log(`     - Scopes: ${CYAN}bot${RESET}, ${CYAN}applications.commands${RESET}`);
+        console.log(`     - Bot Permissions: ${CYAN}Send Messages${RESET}, ${CYAN}Read Message History${RESET}, ${CYAN}Attach Files${RESET}, ${CYAN}Use Slash Commands${RESET}`);
+        console.log(`  3. Copy the generated URL and open it in your browser`);
+        console.log(`  4. Select your server and authorize`);
+        console.log();
+        await ask(rl, `  ${DIM}Press Enter when done...${RESET}`);
+        // ── Step 3: Lock down to specific channels ──
+        console.log(`\n${BOLD}Step 3: Restrict Max to specific channels${RESET}\n`);
+        console.log(`${YELLOW}  ⚠  IMPORTANT: Max will only respond in channels you allow.${RESET}`);
+        console.log(`  This is how you control who can talk to Max.`);
+        console.log();
+        console.log(`  To get a channel ID:`);
+        console.log(`  1. Enable Developer Mode in Discord (Settings → Advanced → Developer Mode)`);
+        console.log(`  2. Right-click a text channel → ${BOLD}Copy Channel ID${RESET}`);
+        console.log();
+        const channelIdsInput = await askRequired(rl, `  Allowed channel IDs ${DIM}(comma-separated)${RESET}${discordChannelIds ? ` ${DIM}(current: ${discordChannelIds})${RESET}` : ""}: `);
+        discordChannelIds = channelIdsInput;
+        console.log(`\n${GREEN}  ✓ Discord configured — Max will only respond in the specified channels.${RESET}`);
+    }
+    else {
+        console.log(`\n${DIM}  Skipping Discord. You can always set it up later with: max setup${RESET}\n`);
+    }
+    // ── Google (gogcli) Setup ─────────────────────────────────
+    console.log(`${BOLD}━━━ Google / Gmail Setup (optional) ━━━${RESET}\n`);
+    console.log(`Max includes a Google skill that lets him read your email, manage`);
+    console.log(`your calendar, access Drive, and more — using the ${BOLD}gog${RESET} CLI.`);
+    console.log();
+    const setupGoogle = await askYesNo(rl, "Would you like to set up Google services?");
+    if (setupGoogle) {
+        // ── Step 1: Install gog CLI ──
+        console.log(`\n${BOLD}Step 1: Install the gog CLI${RESET}\n`);
+        console.log(`  ${CYAN}brew install steipete/tap/gogcli${RESET}     ${DIM}(macOS/Linux with Homebrew)${RESET}`);
+        console.log();
+        await ask(rl, `  ${DIM}Press Enter when installed (or to skip)...${RESET}`);
+        // ── Step 2: Create OAuth credentials ──
+        console.log(`\n${BOLD}Step 2: Create OAuth credentials${RESET}\n`);
+        console.log(`  You need a Google Cloud OAuth client to authenticate:`);
+        console.log(`  1. Go to ${CYAN}https://console.cloud.google.com/apis/credentials${RESET}`);
+        console.log(`  2. Create a project (if you don't have one)`);
+        console.log(`  3. Enable the APIs you want (Gmail, Calendar, Drive, etc.)`);
+        console.log(`  4. Configure the OAuth consent screen`);
+        console.log(`  5. Create an OAuth client (type: ${BOLD}Desktop app${RESET})`);
+        console.log(`  6. Download the JSON credentials file`);
+        console.log();
+        console.log(`  Then store the credentials:`);
+        console.log(`  ${CYAN}gog auth credentials ~/Downloads/client_secret_....json${RESET}`);
+        console.log();
+        await ask(rl, `  ${DIM}Press Enter when done (or to skip)...${RESET}`);
+        // ── Step 3: Authenticate ──
+        console.log(`\n${BOLD}Step 3: Authenticate with your Google account${RESET}\n`);
+        console.log(`  Run this command to authorize:`);
+        console.log(`  ${CYAN}gog auth add your-email@gmail.com${RESET}`);
+        console.log();
+        console.log(`  This opens a browser for OAuth authorization. Once done, Max can`);
+        console.log(`  access your Google services on your behalf.`);
+        console.log();
+        const googleEmail = await ask(rl, `  Google email ${DIM}(Enter to skip)${RESET}: `);
+        if (googleEmail.trim()) {
+            console.log(`\n  ${DIM}Run this now or later:${RESET}  ${CYAN}gog auth add ${googleEmail.trim()}${RESET}`);
+            console.log(`  ${DIM}Check status anytime:${RESET}   ${CYAN}gog auth status${RESET}`);
+        }
+        console.log(`\n${GREEN}  ✓ Google skill is ready — authenticate with gog auth add when you're set.${RESET}\n`);
+    }
+    else {
+        console.log(`\n${DIM}  Skipping Google. You can always set it up later with: max setup${RESET}\n`);
+    }
+    // ── Model picker ─────────────────────────────────────────
+    console.log(`\n${BOLD}━━━ Default Model ━━━${RESET}\n`);
+    console.log(`${DIM}Fetching available models from Copilot...${RESET}`);
+    let models = await fetchModels();
+    if (models.length === 0) {
+        console.log(`${YELLOW}  Could not fetch models (Copilot CLI may not be authenticated yet).${RESET}`);
+        console.log(`${DIM}  Showing a curated list — you can switch anytime after setup.${RESET}\n`);
+        models = FALLBACK_MODELS;
+    }
+    else {
+        console.log(`${GREEN}  ✓ Found ${models.length} models${RESET}\n`);
+    }
+    console.log(`${DIM}You can switch models anytime by telling Max "switch to gpt-4.1"${RESET}\n`);
+    const currentModel = existing.COPILOT_MODEL || "claude-sonnet-4.6";
+    const model = await askPicker(rl, "Choose a default model:", models, currentModel);
+    const modelLabel = models.find((m) => m.id === model)?.label || model;
+    console.log(`\n${GREEN}  ✓ Using ${modelLabel}${RESET}\n`);
+    // ── Write config ─────────────────────────────────────────
+    const apiPort = existing.API_PORT || "7777";
+    const lines = [];
+    if (telegramToken)
+        lines.push(`TELEGRAM_BOT_TOKEN=${telegramToken}`);
+    if (userId)
+        lines.push(`AUTHORIZED_USER_ID=${userId}`);
+    if (discordToken)
+        lines.push(`DISCORD_BOT_TOKEN=${discordToken}`);
+    if (discordChannelIds)
+        lines.push(`DISCORD_ALLOWED_CHANNEL_IDS=${discordChannelIds}`);
+    lines.push(`API_PORT=${apiPort}`);
+    lines.push(`COPILOT_MODEL=${model}`);
+    writeFileSync(ENV_PATH, lines.join("\n") + "\n");
+    // ── Done ─────────────────────────────────────────────────
+    console.log(`
+${GREEN}${BOLD}✅ Max is ready!${RESET}
+${DIM}Config saved to ${ENV_PATH}${RESET}
+
+${BOLD}Get started:${RESET}
+
+  ${CYAN}1.${RESET} Make sure Copilot CLI is authenticated:
+     ${BOLD}copilot login${RESET}
+
+  ${CYAN}2.${RESET} Start Max:
+     ${BOLD}max start${RESET}
+
+  ${CYAN}3.${RESET} ${setupTelegram ? "Open Telegram and message your bot!" : "Connect via terminal:"}
+     ${BOLD}${setupTelegram ? "(message your bot on Telegram)" : "max tui"}${RESET}
+
+${BOLD}Things to try:${RESET}
+
+  ${DIM}"Start working on the auth bug in ~/dev/myapp"${RESET}
+  ${DIM}"What sessions are running?"${RESET}
+  ${DIM}"Find me a skill for checking Gmail"${RESET}
+  ${DIM}"Learn how to control my smart lights"${RESET}
+  ${DIM}"Switch to gpt-4.1"${RESET}
+`);
+    rl.close();
+}
+main().catch((err) => {
+    console.error("Setup failed:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=setup.js.map

package/dist/store/db.js

@@ -0,0 +1,173 @@
+import Database from "better-sqlite3";
+import { DB_PATH, ensureMaxHome } from "../paths.js";
+let db;
+let logInsertCount = 0;
+export function getDb() {
+    if (!db) {
+        ensureMaxHome();
+        db = new Database(DB_PATH);
+        db.pragma("journal_mode = WAL");
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS worker_sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT UNIQUE NOT NULL,
+        copilot_session_id TEXT,
+        working_dir TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'idle',
+        last_output TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS max_state (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS conversation_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+        content TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'unknown',
+        ts DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        category TEXT NOT NULL CHECK(category IN ('preference', 'fact', 'project', 'person', 'routine')),
+        content TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'user',
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        last_accessed DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        // Migrate: if the table already existed with a stricter CHECK, recreate it
+        try {
+            db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES ('system', '__migration_test__', 'test')`).run();
+            db.prepare(`DELETE FROM conversation_log WHERE content = '__migration_test__'`).run();
+        }
+        catch {
+            // CHECK constraint doesn't allow 'system' — recreate table preserving data
+            db.exec(`ALTER TABLE conversation_log RENAME TO conversation_log_old`);
+            db.exec(`
+        CREATE TABLE conversation_log (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+          content TEXT NOT NULL,
+          source TEXT NOT NULL DEFAULT 'unknown',
+          ts DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            db.exec(`INSERT INTO conversation_log (role, content, source, ts) SELECT role, content, source, ts FROM conversation_log_old`);
+            db.exec(`DROP TABLE conversation_log_old`);
+        }
+        // Prune conversation log at startup
+        db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 200)`).run();
+    }
+    return db;
+}
+export function getState(key) {
+    const db = getDb();
+    const row = db.prepare(`SELECT value FROM max_state WHERE key = ?`).get(key);
+    return row?.value;
+}
+export function setState(key, value) {
+    const db = getDb();
+    db.prepare(`INSERT OR REPLACE INTO max_state (key, value) VALUES (?, ?)`).run(key, value);
+}
+/** Remove a key from persistent state. */
+export function deleteState(key) {
+    const db = getDb();
+    db.prepare(`DELETE FROM max_state WHERE key = ?`).run(key);
+}
+/** Log a conversation turn (user, assistant, or system). */
+export function logConversation(role, content, source) {
+    const db = getDb();
+    db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES (?, ?, ?)`).run(role, content, source);
+    // Keep last 200 entries to support context recovery after session loss
+    logInsertCount++;
+    if (logInsertCount % 50 === 0) {
+        db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 200)`).run();
+    }
+}
+/** Get recent conversation history formatted for injection into system message. */
+export function getRecentConversation(limit = 20) {
+    const db = getDb();
+    const rows = db.prepare(`SELECT role, content, source, ts FROM conversation_log ORDER BY id DESC LIMIT ?`).all(limit);
+    if (rows.length === 0)
+        return "";
+    // Reverse so oldest is first (chronological order)
+    rows.reverse();
+    return rows.map((r) => {
+        const tag = r.role === "user" ? `[${r.source}] User`
+            : r.role === "system" ? `[${r.source}] System`
+                : "Max";
+        // Truncate long messages to keep context manageable
+        const content = r.content.length > 500 ? r.content.slice(0, 500) + "…" : r.content;
+        return `${tag}: ${content}`;
+    }).join("\n\n");
+}
+/** Add a memory to long-term storage. */
+export function addMemory(category, content, source = "user") {
+    const db = getDb();
+    const result = db.prepare(`INSERT INTO memories (category, content, source) VALUES (?, ?, ?)`).run(category, content, source);
+    return result.lastInsertRowid;
+}
+/** Search memories by keyword and/or category. */
+export function searchMemories(keyword, category, limit = 20) {
+    const db = getDb();
+    const conditions = [];
+    const params = [];
+    if (keyword) {
+        conditions.push(`content LIKE ?`);
+        params.push(`%${keyword}%`);
+    }
+    if (category) {
+        conditions.push(`category = ?`);
+        params.push(category);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    params.push(limit);
+    const rows = db.prepare(`SELECT id, category, content, source, created_at FROM memories ${where} ORDER BY last_accessed DESC LIMIT ?`).all(...params);
+    // Update last_accessed for returned memories
+    if (rows.length > 0) {
+        const placeholders = rows.map(() => "?").join(",");
+        db.prepare(`UPDATE memories SET last_accessed = CURRENT_TIMESTAMP WHERE id IN (${placeholders})`).run(...rows.map((r) => r.id));
+    }
+    return rows;
+}
+/** Remove a memory by ID. */
+export function removeMemory(id) {
+    const db = getDb();
+    const result = db.prepare(`DELETE FROM memories WHERE id = ?`).run(id);
+    return result.changes > 0;
+}
+/** Get a compact summary of all memories for injection into system message. */
+export function getMemorySummary() {
+    const db = getDb();
+    const rows = db.prepare(`SELECT id, category, content FROM memories ORDER BY category, last_accessed DESC`).all();
+    if (rows.length === 0)
+        return "";
+    // Group by category
+    const grouped = {};
+    for (const r of rows) {
+        if (!grouped[r.category])
+            grouped[r.category] = [];
+        grouped[r.category].push({ id: r.id, content: r.content });
+    }
+    const sections = Object.entries(grouped).map(([cat, items]) => {
+        const lines = items.map((i) => `  - [#${i.id}] ${i.content}`).join("\n");
+        return `**${cat}**:\n${lines}`;
+    });
+    return sections.join("\n");
+}
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = undefined;
+    }
+}
+//# sourceMappingURL=db.js.map