@tspappsen/elamax 1.2.3

package/dist/cli.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+// IMPORTANT: Do not add static imports of paths.ts, config.ts, or daemon.ts.
+// MAX_PROFILE must be set in process.env BEFORE these modules are imported.
+// The dynamic import() calls below ensure correct sequencing.
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+        return pkg.version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function printHelp() {
+    const version = getVersion();
+    console.log(`
+max v${version} — AI orchestrator powered by Copilot SDK
+
+Usage:
+  max <command>
+
+Commands:
+  start       Start the Max daemon (Telegram bot + HTTP API)
+  tui         Connect to the daemon via terminal UI
+  setup       Interactive first-run configuration
+  update      Check for updates and install the latest version
+  help        Show this help message
+
+Flags:
+  --profile <name>  Run as a named profile (e.g. --profile watchdog)
+  --self-edit       Allow Max to modify his own source code (off by default)
+
+Examples:
+  max start           Start the daemon
+  max start --self-edit  Start with self-edit enabled
+  max start --profile watchdog   Start the watchdog instance
+  max tui             Open the terminal client
+  max setup           Configure Telegram token and settings
+  max setup --profile watchdog   Configure watchdog instance
+`.trim());
+}
+const args = process.argv.slice(2);
+const profileIdx = args.indexOf("--profile");
+if (profileIdx !== -1 && args[profileIdx + 1]) {
+    process.env.MAX_PROFILE = args[profileIdx + 1];
+}
+const command = args[0] || "help";
+switch (command) {
+    case "start": {
+        // Parse flags for start command
+        const startFlags = args.slice(1);
+        if (startFlags.includes("--self-edit")) {
+            process.env.MAX_SELF_EDIT = "1";
+        }
+        await import("./daemon.js");
+        break;
+    }
+    case "tui":
+        await import("./tui/index.js");
+        break;
+    case "setup":
+        await import("./setup.js");
+        break;
+    case "update": {
+        const { checkForUpdate, performUpdate } = await import("./update.js");
+        const check = await checkForUpdate();
+        if (!check.checkSucceeded) {
+            console.error("⚠ Could not reach the npm registry. Check your network and try again.");
+            process.exit(1);
+        }
+        if (!check.updateAvailable) {
+            console.log(`max v${check.current} is already the latest version.`);
+            break;
+        }
+        console.log(`Update available: v${check.current} → v${check.latest}`);
+        console.log("Installing...");
+        const result = await performUpdate();
+        if (result.ok) {
+            console.log(`✅ Updated to v${check.latest}`);
+        }
+        else {
+            console.error(`❌ Update failed: ${result.output}`);
+            process.exit(1);
+        }
+        break;
+    }
+    case "help":
+    case "--help":
+    case "-h":
+        printHelp();
+        break;
+    case "--version":
+    case "-v":
+        console.log(getVersion());
+        break;
+    default:
+        console.error(`Unknown command: ${command}\n`);
+        printHelp();
+        process.exit(1);
+}
+//# sourceMappingURL=cli.js.map

package/dist/config.js

@@ -0,0 +1,96 @@
+import { config as loadEnv } from "dotenv";
+import { z } from "zod";
+import { readFileSync, writeFileSync } from "fs";
+import { ENV_PATH, ensureMaxHome } from "./paths.js";
+import { IS_WATCHDOG, MAIN_MAX_HOME } from "./paths.js";
+// Load from ~/.max/.env, fall back to cwd .env for dev
+loadEnv({ path: ENV_PATH });
+loadEnv(); // also check cwd for backwards compat
+const configSchema = z.object({
+    TELEGRAM_BOT_TOKEN: z.string().min(1).optional(),
+    DISCORD_BOT_TOKEN: z.string().min(1).optional(),
+    DISCORD_ALLOWED_CHANNEL_IDS: z.string().min(1).optional(),
+    AUTHORIZED_USER_ID: z.string().min(1).optional(),
+    API_PORT: z.string().optional(),
+    MAIN_MAX_PM2_NAME: z.string().optional(),
+    COPILOT_MODEL: z.string().optional(),
+    WORKER_TIMEOUT: z.string().optional(),
+});
+const raw = configSchema.parse(process.env);
+const parsedUserId = raw.AUTHORIZED_USER_ID
+    ? parseInt(raw.AUTHORIZED_USER_ID, 10)
+    : undefined;
+const parsedChannelIds = raw.DISCORD_ALLOWED_CHANNEL_IDS
+    ? raw.DISCORD_ALLOWED_CHANNEL_IDS.split(",").map((id) => id.trim()).filter(Boolean)
+    : [];
+const defaultApiPort = IS_WATCHDOG ? "7778" : "7777";
+const parsedPort = parseInt(raw.API_PORT || defaultApiPort, 10);
+if (parsedUserId !== undefined && (Number.isNaN(parsedUserId) || parsedUserId <= 0)) {
+    throw new Error(`AUTHORIZED_USER_ID must be a positive integer, got: "${raw.AUTHORIZED_USER_ID}"`);
+}
+if (Number.isNaN(parsedPort) || parsedPort < 1 || parsedPort > 65535) {
+    throw new Error(`API_PORT must be 1-65535, got: "${raw.API_PORT}"`);
+}
+const DEFAULT_WORKER_TIMEOUT_MS = 600_000; // 10 minutes
+const parsedWorkerTimeout = raw.WORKER_TIMEOUT
+    ? Number(raw.WORKER_TIMEOUT)
+    : DEFAULT_WORKER_TIMEOUT_MS;
+if (!Number.isInteger(parsedWorkerTimeout) || parsedWorkerTimeout <= 0) {
+    throw new Error(`WORKER_TIMEOUT must be a positive integer (ms), got: "${raw.WORKER_TIMEOUT}"`);
+}
+export const DEFAULT_MODEL = "claude-sonnet-4.6";
+let _copilotModel = raw.COPILOT_MODEL || DEFAULT_MODEL;
+export const config = {
+    telegramBotToken: raw.TELEGRAM_BOT_TOKEN,
+    discordBotToken: raw.DISCORD_BOT_TOKEN,
+    discordAllowedChannelIds: parsedChannelIds,
+    authorizedUserId: parsedUserId,
+    apiPort: parsedPort,
+    isWatchdog: IS_WATCHDOG,
+    mainMaxHome: MAIN_MAX_HOME,
+    mainMaxPm2Name: raw.MAIN_MAX_PM2_NAME || "max",
+    workerTimeoutMs: parsedWorkerTimeout,
+    get copilotModel() {
+        return _copilotModel;
+    },
+    set copilotModel(model) {
+        _copilotModel = model;
+    },
+    get telegramEnabled() {
+        return !!this.telegramBotToken && this.authorizedUserId !== undefined;
+    },
+    get discordEnabled() {
+        return !!this.discordBotToken && this.discordAllowedChannelIds.length > 0;
+    },
+    get selfEditEnabled() {
+        return process.env.MAX_SELF_EDIT === "1";
+    },
+};
+/** Update or append an env var in ~/.max/.env */
+function persistEnvVar(key, value) {
+    ensureMaxHome();
+    try {
+        const content = readFileSync(ENV_PATH, "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}`);
+        writeFileSync(ENV_PATH, updated.join("\n"));
+    }
+    catch {
+        // File doesn't exist — create it
+        writeFileSync(ENV_PATH, `${key}=${value}\n`);
+    }
+}
+/** Persist the current model choice to ~/.max/.env */
+export function persistModel(model) {
+    persistEnvVar("COPILOT_MODEL", model);
+}
+//# sourceMappingURL=config.js.map

package/dist/copilot/classifier.js

@@ -0,0 +1,72 @@
+import { approveAll } from "@github/copilot-sdk";
+// ---------------------------------------------------------------------------
+// Persistent GPT-4.1 classifier session
+// ---------------------------------------------------------------------------
+const CLASSIFIER_MODEL = "gpt-4.1";
+const CLASSIFY_TIMEOUT_MS = 8_000;
+const SYSTEM_PROMPT = `You are a message complexity classifier for an AI assistant called Max. Your ONLY job is to classify incoming user messages into one of three tiers. Respond with ONLY the tier name — nothing else.
+
+Tiers:
+- FAST: Greetings, thanks, acknowledgments, simple yes/no, trivial factual questions ("what time is it?", "hello", "thanks"), casual chat with no technical depth.
+- STANDARD: Coding tasks, file operations, tool usage requests, moderate reasoning, questions about technical topics, requests to create/check/manage things, anything involving code or development workflow.
+- PREMIUM: Complex architecture decisions, deep analysis, multi-step reasoning, comparing trade-offs, detailed explanations of complex topics, debugging intricate issues, designing systems, strategic planning.
+
+Rules:
+- If unsure, respond STANDARD (it's the safe default).
+- Respond with exactly one word: FAST, STANDARD, or PREMIUM.`;
+let classifierSession;
+let sessionClient;
+async function ensureSession(client) {
+    // Recreate if the client changed (e.g. after a reset)
+    if (classifierSession && sessionClient === client) {
+        return classifierSession;
+    }
+    // Destroy stale session
+    if (classifierSession) {
+        classifierSession.destroy().catch(() => { });
+        classifierSession = undefined;
+    }
+    classifierSession = await client.createSession({
+        model: CLASSIFIER_MODEL,
+        streaming: false,
+        systemMessage: { content: SYSTEM_PROMPT },
+        onPermissionRequest: approveAll,
+    });
+    sessionClient = client;
+    return classifierSession;
+}
+const TIER_MAP = {
+    FAST: "fast",
+    STANDARD: "standard",
+    PREMIUM: "premium",
+};
+/**
+ * Classify a message using GPT-4.1.
+ * Returns the tier, or null if the classifier is unavailable / times out.
+ */
+export async function classifyWithLLM(client, message) {
+    try {
+        const session = await ensureSession(client);
+        const result = await session.sendAndWait({ prompt: message }, CLASSIFY_TIMEOUT_MS);
+        const raw = (result?.data?.content || "").trim().toUpperCase();
+        return TIER_MAP[raw] ?? "standard";
+    }
+    catch (err) {
+        console.log(`[max] Classifier error (falling back to heuristics): ${err instanceof Error ? err.message : err}`);
+        // Destroy broken session so it's recreated next time
+        if (classifierSession) {
+            classifierSession.destroy().catch(() => { });
+            classifierSession = undefined;
+        }
+        return null;
+    }
+}
+/** Tear down the classifier session (e.g. on shutdown). */
+export function stopClassifier() {
+    if (classifierSession) {
+        classifierSession.destroy().catch(() => { });
+        classifierSession = undefined;
+        sessionClient = undefined;
+    }
+}
+//# sourceMappingURL=classifier.js.map

package/dist/copilot/client.js

@@ -0,0 +1,30 @@
+import { CopilotClient } from "@github/copilot-sdk";
+let client;
+export async function getClient() {
+    if (!client) {
+        client = new CopilotClient({
+            autoStart: true,
+            autoRestart: true,
+        });
+        await client.start();
+    }
+    return client;
+}
+/** Tear down the existing client and create a fresh one. */
+export async function resetClient() {
+    if (client) {
+        try {
+            await client.stop();
+        }
+        catch { /* best-effort */ }
+        client = undefined;
+    }
+    return getClient();
+}
+export async function stopClient() {
+    if (client) {
+        await client.stop();
+        client = undefined;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/copilot/mcp-config.js

@@ -0,0 +1,22 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+/**
+ * Load MCP server configs from ~/.copilot/mcp-config.json.
+ * Returns an empty record if the file doesn't exist or is invalid.
+ */
+export function loadMcpConfig() {
+    const configPath = join(homedir(), ".copilot", "mcp-config.json");
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
+            return parsed.mcpServers;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=mcp-config.js.map