@rubytech/create-realagent 1.0.406

package/payload/platform/plugins/admin/mcp/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/payload/platform/plugins/admin/mcp/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/payload/platform/plugins/admin/mcp/dist/index.js

@@ -0,0 +1,616 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve, join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { createConnection } from "node:net";
+import { homedir } from "node:os";
+import QRCode from "qrcode";
+import { getSession, closeDriver } from "./lib/neo4j.js";
+import { getOnboardingState, completeOnboardingStep } from "./lib/onboarding.js";
+const server = new McpServer({
+    name: "admin",
+    version: "0.1.0",
+});
+const PLATFORM_ROOT = process.env.PLATFORM_ROOT ?? resolve(import.meta.dirname, "../../../..");
+const ACCOUNT_ID = process.env.ACCOUNT_ID;
+if (!ACCOUNT_ID) {
+    throw new Error("ACCOUNT_ID environment variable is required");
+}
+// Resolve account directory
+function getAccountDir() {
+    const dir = resolve(PLATFORM_ROOT, "config/accounts", ACCOUNT_ID);
+    if (!existsSync(dir)) {
+        throw new Error(`Account directory not found: ${dir}`);
+    }
+    return dir;
+}
+async function readAccountConfig() {
+    const configPath = join(getAccountDir(), "account.json");
+    const content = await readFile(configPath, "utf-8");
+    return JSON.parse(content);
+}
+// ===================================================================
+// System tools
+// ===================================================================
+function checkPort(port, timeoutMs = 1000) {
+    return new Promise((res) => {
+        const socket = createConnection(port, "127.0.0.1");
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => { socket.destroy(); res(true); });
+        socket.once("error", () => { socket.destroy(); res(false); });
+        socket.once("timeout", () => { socket.destroy(); res(false); });
+    });
+}
+server.tool("system-status", "Check health of all Maxy platform services: Neo4j, Ollama, Cloudflare tunnel, crontab (Maxy cron entries), VNC, Chrome (CDP), specialist agents, and deployed brand identity.", {}, async () => {
+    const checks = {};
+    try {
+        const neo4jUri = process.env.NEO4J_URI ?? "bolt://localhost:7687";
+        const res = await fetch(neo4jUri.replace("bolt://", "http://").replace("7687", "7474"), { signal: AbortSignal.timeout(3000) });
+        checks.neo4j = res.ok ? "healthy" : `unhealthy (${res.status})`;
+    }
+    catch (err) {
+        checks.neo4j = `unreachable: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    try {
+        const ollamaUrl = process.env.OLLAMA_URL ?? "http://localhost:11434";
+        const res = await fetch(`${ollamaUrl}/api/tags`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (res.ok) {
+            const data = (await res.json());
+            const models = data.models?.map((m) => m.name).join(", ") ?? "none";
+            checks.ollama = `healthy (models: ${models})`;
+        }
+        else {
+            checks.ollama = `unhealthy (${res.status})`;
+        }
+    }
+    catch (err) {
+        checks.ollama = `unreachable: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    // Cloudflare tunnel: lightweight process check (full status via tunnel-status in cloudflare plugin)
+    try {
+        execFileSync("pgrep", ["-x", "cloudflared"], { timeout: 2000 });
+        checks.cloudflare = "running";
+    }
+    catch {
+        // pgrep exits non-zero if no process found
+        try {
+            execFileSync("which", ["cloudflared"], { encoding: "utf-8", timeout: 3000 });
+            checks.cloudflare = "installed but not running";
+        }
+        catch {
+            checks.cloudflare = "not installed";
+        }
+    }
+    // Crontab — Maxy cron entries registered by the installer
+    try {
+        const crontabOutput = execFileSync("crontab", ["-l"], {
+            encoding: "utf-8",
+            timeout: 3000,
+        });
+        const beginIdx = crontabOutput.indexOf("# BEGIN MAXY CRONS");
+        const endIdx = crontabOutput.indexOf("# END MAXY CRONS");
+        if (beginIdx === -1 || endIdx === -1) {
+            checks.crontab = "no Maxy crons registered — run the installer to register them";
+        }
+        else {
+            const block = crontabOutput.slice(beginIdx, endIdx);
+            const entries = block
+                .split("\n")
+                .filter((line) => line.trim() && !line.startsWith("#"));
+            if (entries.length === 0) {
+                checks.crontab = "Maxy cron block present but empty";
+            }
+            else {
+                const names = entries.map((line) => {
+                    const commentMatch = line.match(/#\s*(.+)$/);
+                    return commentMatch ? commentMatch[1].trim() : line.trim().split(/\s+/).slice(-1)[0];
+                });
+                checks.crontab = `${entries.length} registered: ${names.join(", ")}`;
+            }
+        }
+    }
+    catch {
+        checks.crontab = "no crontab configured for this user";
+    }
+    // VNC display server
+    checks.vnc = (await checkPort(5900)) ? "running" : "not running";
+    // Chrome CDP — browser-specialist depends on this
+    const chromeUp = await checkPort(9222);
+    checks.chrome = chromeUp
+        ? "running"
+        : "not running — browser-specialist degraded (CDP port 9222 not listening)";
+    // Specialist agents — read AGENTS.md registry, verify files exist
+    try {
+        const accountDir = getAccountDir();
+        const agentsMdPath = join(accountDir, "agents/admin/AGENTS.md");
+        const specialistsAgentsDir = join(accountDir, "specialists/agents");
+        if (!existsSync(agentsMdPath)) {
+            checks.specialists = "not configured (AGENTS.md missing)";
+        }
+        else {
+            const content = readFileSync(agentsMdPath, "utf-8");
+            const entries = content.match(/^- \*\*specialists:([^*]+)\*\*/gm);
+            if (!entries || entries.length === 0) {
+                checks.specialists = "not configured (AGENTS.md empty)";
+            }
+            else {
+                const lines = [];
+                for (const entry of entries) {
+                    const nameMatch = entry.match(/specialists:([^*]+)/);
+                    if (!nameMatch)
+                        continue;
+                    const name = nameMatch[1];
+                    const fileExists = existsSync(join(specialistsAgentsDir, `${name}.md`));
+                    let status = fileExists ? "ok" : "missing file";
+                    if (name === "browser-specialist" && !chromeUp) {
+                        status = "degraded — chrome not running";
+                    }
+                    lines.push(`  ${name}: ${status}`);
+                }
+                checks.specialists = `${entries.length} registered\n${lines.join("\n")}`;
+            }
+        }
+    }
+    catch {
+        checks.specialists = "error reading specialist registry";
+    }
+    // Brand identity — read build-time manifest stamped by the bundler
+    try {
+        const brandPath = resolve(PLATFORM_ROOT, "config/brand.json");
+        if (!existsSync(brandPath)) {
+            checks.brand = "not configured (dev environment)";
+        }
+        else {
+            const brand = JSON.parse(readFileSync(brandPath, "utf-8"));
+            checks.brand = `${brand.productName ?? "unknown"} (hostname: ${brand.hostname ?? "unknown"})`;
+        }
+    }
+    catch (err) {
+        checks.brand = `error reading brand config: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    const formatted = Object.entries(checks)
+        .map(([service, status]) => `${service}: ${status}`)
+        .join("\n");
+    return { content: [{ type: "text", text: formatted }] };
+});
+server.tool("brand-settings", "Read the brand/styling configuration for the current account.", {}, async () => {
+    try {
+        const config = await readAccountConfig();
+        return {
+            content: [{ type: "text", text: JSON.stringify(config.brand, null, 2) }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+server.tool("account-manage", "Read the account configuration (tier, domains, settings).", {}, async () => {
+    try {
+        const config = await readAccountConfig();
+        return {
+            content: [{ type: "text", text: JSON.stringify(config, null, 2) }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+server.tool("account-update", "Update a user-configurable setting in account.json. Valid fields: outputStyle (default|explanatory), thinkingView (default|expanded|collapsed), effort (low|medium|high|max|auto), contextMode (managed|claude-code), adminModel (any Anthropic model ID), publicModel (any Anthropic model ID), defaultAgent (slug of an existing public agent). Changes take effect on the next session.", {
+    field: z.enum(["outputStyle", "thinkingView", "effort", "contextMode", "adminModel", "publicModel", "defaultAgent"]),
+    value: z.string(),
+}, async ({ field, value }) => {
+    const VALID = {
+        outputStyle: ["default", "explanatory"],
+        thinkingView: ["default", "expanded", "collapsed"],
+        effort: ["low", "medium", "high", "max", "auto"],
+        contextMode: ["managed", "claude-code"],
+    };
+    // defaultAgent: must be a non-empty slug with an existing agent directory containing config.json
+    if (field === "defaultAgent") {
+        const slug = value.trim();
+        if (!slug) {
+            return {
+                content: [{ type: "text", text: `Invalid value for defaultAgent. Must be a non-empty agent slug.` }],
+                isError: true,
+            };
+        }
+        const agentConfigPath = join(getAccountDir(), "agents", slug, "config.json");
+        if (!existsSync(agentConfigPath)) {
+            return {
+                content: [{ type: "text", text: `Agent '${slug}' not found — no config.json in agents/${slug}/` }],
+                isError: true,
+            };
+        }
+    }
+    // Model fields accept any non-empty string (model IDs change frequently)
+    const FREE_FORM_FIELDS = ["adminModel", "publicModel"];
+    if (FREE_FORM_FIELDS.includes(field)) {
+        if (!value.trim()) {
+            return {
+                content: [{ type: "text", text: `Invalid value for ${field}. Must be a non-empty model ID.` }],
+                isError: true,
+            };
+        }
+    }
+    else if (field !== "defaultAgent" && !VALID[field].includes(value)) {
+        return {
+            content: [{ type: "text", text: `Invalid value "${value}" for ${field}. Valid values: ${VALID[field].join(", ")}` }],
+            isError: true,
+        };
+    }
+    try {
+        const configPath = join(getAccountDir(), "account.json");
+        const config = await readAccountConfig();
+        const oldDefault = field === "defaultAgent" ? config.defaultAgent ?? "(none)" : undefined;
+        config[field] = value;
+        await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        if (field === "defaultAgent") {
+            return {
+                content: [{ type: "text", text: `Default agent changed from "${oldDefault}" to "${value}". Takes effect on next page load.` }],
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Updated ${field} to "${value}". Takes effect on next session.` }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+server.tool("logs-read", "Read recent logs. type=system: raw Claude stream-json. type=session: SSE events sent to client. type=error: Claude subprocess stderr. type=heartbeat: platform event dispatcher (check-due-events cron). type=public: public agent diagnostic log (user messages, knowledge source, memory context, component events, responses). When sessionKey is provided, greps all log files (or just the specified type) for lines containing that session key and returns a unified timeline.", {
+    type: z.enum(["system", "session", "error", "heartbeat", "public"]).optional(),
+    lines: z.number().optional(),
+    sessionKey: z.string().optional(),
+}, async ({ type, lines = 50, sessionKey }) => {
+    try {
+        const LOG_DIR = resolve(homedir(), ".maxy/logs");
+        if (!existsSync(LOG_DIR)) {
+            return { content: [{ type: "text", text: `Log directory does not exist: ${LOG_DIR}` }] };
+        }
+        // --- Session-key filtered mode: grep across log files ---
+        if (sessionKey) {
+            const prefixes = {
+                system: "claude-agent-stream-",
+                error: "claude-agent-stderr-",
+                session: "sse-events-",
+                public: "public-agent-stream-",
+            };
+            // When a type is explicitly provided, search only that type's files.
+            // When type is omitted, search all prefix-based log types (excludes heartbeat — no session context).
+            const searchPrefixes = type && type !== "heartbeat" && prefixes[type]
+                ? { [type]: prefixes[type] }
+                : prefixes;
+            const allFiles = readdirSync(LOG_DIR).filter(f => f.endsWith(".log"));
+            const sections = [];
+            for (const [logType, prefix] of Object.entries(searchPrefixes)) {
+                const typeFiles = allFiles
+                    .filter(f => f.startsWith(prefix))
+                    .sort(); // chronological by date suffix
+                for (const file of typeFiles) {
+                    const filePath = resolve(LOG_DIR, file);
+                    try {
+                        const result = execFileSync("grep", ["-F", sessionKey, filePath], { timeout: 5000 }).toString().trim();
+                        if (result) {
+                            sections.push(`## ${file} (${logType})\n${result}`);
+                        }
+                    }
+                    catch (grepErr) {
+                        // grep exits 1 when no lines match — that's not an error
+                        const exitCode = grepErr.status;
+                        if (exitCode !== 1)
+                            throw grepErr;
+                    }
+                }
+            }
+            if (sections.length === 0) {
+                return { content: [{ type: "text", text: `No log lines found for session key "${sessionKey}".` }] };
+            }
+            return { content: [{ type: "text", text: `# Session timeline: ${sessionKey}\n\n${sections.join("\n\n")}` }] };
+        }
+        // --- Standard mode: tail most recent file of the requested type ---
+        const resolvedType = type ?? "system";
+        // Heartbeat log is a single fixed file, not prefix-based
+        if (resolvedType === "heartbeat") {
+            const logFile = resolve(LOG_DIR, "check-due-events.log");
+            if (!existsSync(logFile)) {
+                return { content: [{ type: "text", text: "No heartbeat log found yet. The platform cron may not have run." }] };
+            }
+            const result = execFileSync("tail", ["-n", String(lines), logFile], {
+                timeout: 5000,
+            }).toString();
+            return { content: [{ type: "text", text: `# check-due-events.log\n\n${result}` }] };
+        }
+        const prefix = resolvedType === "error" ? "claude-agent-stderr-"
+            : resolvedType === "session" ? "sse-events-"
+                : resolvedType === "public" ? "public-agent-stream-"
+                    : "claude-agent-stream-";
+        // Find the most recently modified file with the matching prefix
+        const match = readdirSync(LOG_DIR)
+            .filter(f => f.startsWith(prefix) && f.endsWith(".log"))
+            .map(f => ({ file: f, mtime: statSync(resolve(LOG_DIR, f)).mtimeMs }))
+            .sort((a, b) => b.mtime - a.mtime)[0];
+        if (!match) {
+            return { content: [{ type: "text", text: `No log file found for type '${resolvedType}' in ${LOG_DIR}` }] };
+        }
+        const logFile = resolve(LOG_DIR, match.file);
+        const result = execFileSync("tail", ["-n", String(lines), logFile], {
+            timeout: 5000,
+        }).toString();
+        return { content: [{ type: "text", text: `# ${match.file}\n\n${result}` }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to read logs: ${err instanceof Error ? err.message : String(err)}` }] };
+    }
+});
+server.tool("plugin-read", "Read a plugin definition (PLUGIN.md) or one of its reference files.", {
+    pluginName: z.string().describe("Name of the plugin directory (e.g. 'sales', 'business-assistant')"),
+    file: z.string().optional().describe("Specific file to read (e.g. 'references/pricing.md'). Defaults to PLUGIN.md."),
+}, async ({ pluginName, file }) => {
+    try {
+        const pluginPath = resolve(PLATFORM_ROOT, "plugins", pluginName, file ?? "PLUGIN.md");
+        if (!existsSync(pluginPath)) {
+            return {
+                content: [{ type: "text", text: `Plugin file not found: ${pluginPath}` }],
+                isError: true,
+            };
+        }
+        const content = await readFile(pluginPath, "utf-8");
+        return { content: [{ type: "text", text: content }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+server.tool("render-component", "Render a pre-built UI component inline in the conversation. " +
+    "Call this instead of describing a UI — the component handles input collection. " +
+    "Wait for the user's response before continuing.", {
+    name: z.string().describe("Component name from the UI suite (e.g. single-select, confirm, info-card, form, progress)"),
+    data: z.record(z.string(), z.unknown()),
+}, async () => ({ content: [{ type: "text", text: "rendered" }] }));
+server.tool("session-reset", "Reset the current session. Compacts conversation history to memory, clears the visible conversation, " +
+    "and starts a fresh session with a new greeting. Call when the user asks to start a new session, " +
+    "clear the conversation, or start fresh.", {}, async () => ({ content: [{ type: "text", text: "reset" }] }));
+server.tool("session-resume", "Resume a previous session. Loads the selected session's message history into the chat timeline " +
+    "and routes new messages to that conversation. Call after the user selects a session from the " +
+    "session-list results. Pass the conversationId from the selected session.", { conversationId: z.string().uuid().describe("The conversationId of the session to resume") }, async () => ({ content: [{ type: "text", text: "resumed" }] }));
+server.tool("remote-auth-set-password", "NEVER collect a password in chat — passwords must not appear in conversation history. " +
+    "Direct the user to set their remote access password in the browser at /__remote-auth/setup. " +
+    "This tool exists only for admin recovery when the browser setup is unavailable. " +
+    "Hashes with scrypt and writes to ~/.maxy/.remote-password. " +
+    "Must be called before tunnel-enable — the tunnel refuses to start without a configured password.", { password: z.string() }, async ({ password }) => {
+    const trimmed = password.trim();
+    // Validate strength — same rules as the web server's validatePasswordStrength
+    const checks = [
+        { label: "at least 8 characters", met: trimmed.length >= 8 },
+        { label: "contains a number", met: /\d/.test(trimmed) },
+        { label: "contains a special character", met: /[^A-Za-z0-9]/.test(trimmed) },
+        { label: "no leading or trailing spaces", met: trimmed.length > 0 && trimmed === password.trim() },
+    ];
+    const failed = checks.filter((c) => !c.met);
+    if (failed.length > 0) {
+        return {
+            content: [{ type: "text", text: `Password requirements not met: ${failed.map((c) => c.label).join(", ")}` }],
+            isError: true,
+        };
+    }
+    try {
+        const { scrypt, randomBytes } = await import("node:crypto");
+        const salt = randomBytes(32);
+        const hash = await new Promise((res, rej) => {
+            scrypt(trimmed, salt, 64, { N: 16384, r: 8, p: 1 }, (err, key) => {
+                if (err)
+                    rej(err);
+                else
+                    res(key);
+            });
+        });
+        const stored = `${salt.toString("hex")}:${hash.toString("hex")}`;
+        const pwPath = resolve(homedir(), ".maxy", ".remote-password");
+        await writeFile(pwPath, stored, { mode: 0o600 });
+        return { content: [{ type: "text", text: "Remote access password set." }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed to set password: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+server.tool("api-key-store", "Validate and store an Anthropic API key. Key must start with sk-ant- and be at least 90 characters. " +
+    "Writes to ~/.maxy/.anthropic-api-key. Takes effect immediately for the public agent.", { apiKey: z.string() }, async ({ apiKey }) => {
+    const trimmed = apiKey.trim();
+    if (!trimmed.startsWith("sk-ant-") || trimmed.length < 90) {
+        return {
+            content: [{ type: "text", text: "Invalid key format. Must start with sk-ant- and be at least 90 characters." }],
+            isError: true,
+        };
+    }
+    try {
+        const keyPath = resolve(homedir(), ".maxy", ".anthropic-api-key");
+        await writeFile(keyPath, trimmed, { mode: 0o600 });
+        return { content: [{ type: "text", text: "API key stored." }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed to store key: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+server.tool("api-key-verify", "Verify the stored Anthropic API key works by making a minimal probe call. " +
+    "Returns one of: valid (key works, credits available), billing (key valid but credit balance too low — " +
+    "user must add credits at console.anthropic.com/settings/billing), auth_error (key rejected — invalid or revoked), " +
+    "missing (no key file found), error (could not verify — network issue or Anthropic outage). " +
+    "Call this on greeting, during system checks, or after storing a new key.", {}, async () => {
+    const keyPath = resolve(homedir(), ".maxy", ".anthropic-api-key");
+    let apiKey;
+    try {
+        apiKey = (await readFile(keyPath, "utf-8")).trim();
+    }
+    catch {
+        return { content: [{ type: "text", text: "Status: missing\nNo API key file found at ~/.maxy/.anthropic-api-key. Run the get-api-key skill to obtain one." }] };
+    }
+    if (!apiKey) {
+        return { content: [{ type: "text", text: "Status: missing\nAPI key file exists but is empty." }] };
+    }
+    try {
+        const res = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 1,
+                messages: [{ role: "user", content: "hi" }],
+            }),
+            signal: AbortSignal.timeout(10000),
+        });
+        if (res.ok || res.status === 429) {
+            // 429 = rate limited, but the key was accepted — treat as valid
+            return { content: [{ type: "text", text: "Status: valid\nAPI key is working. Credits available." }] };
+        }
+        const body = await res.text();
+        if (/credit balance|billing|purchase credits/i.test(body)) {
+            return { content: [{ type: "text", text: "Status: billing\nAPI key is valid but credit balance is too low. The user must add credits at console.anthropic.com under Plans & Billing, or enable auto-top-up." }] };
+        }
+        if (res.status === 401 || res.status === 403 || /authentication_error|permission_error/i.test(body)) {
+            return { content: [{ type: "text", text: "Status: auth_error\nAPI key was rejected. It may be invalid, revoked, or expired. The user should create a new key at console.anthropic.com/settings/keys." }] };
+        }
+        return { content: [{ type: "text", text: `Status: error\nCould not verify API key. Anthropic returned ${res.status}. This may be a temporary outage — try again later.` }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Status: error\nCould not reach the Anthropic API: ${err instanceof Error ? err.message : String(err)}. Check network connectivity.` }] };
+    }
+});
+// ===================================================================
+// Onboarding tools
+// ===================================================================
+server.tool("onboarding-get", "Read the current onboarding state from the graph. Returns which setup steps " +
+    "have been completed and their timestamps. On first call for an account, " +
+    "migrates any existing onboardingStep from account.json to the graph and " +
+    "removes it from the file. If Neo4j is unreachable, returns an error — " +
+    "the agent should skip onboarding for this session and retry next time.", {}, async () => {
+    try {
+        const state = await getOnboardingState(getSession, ACCOUNT_ID, getAccountDir());
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(state, null, 2),
+                }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to read onboarding state: ${err instanceof Error ? err.message : String(err)}`,
+                }],
+            isError: true,
+        };
+    }
+});
+server.tool("onboarding-complete-step", "Mark an onboarding step as completed. Sets a completion timestamp on the step " +
+    "and updates currentStep to the highest completed step. Idempotent — completing " +
+    "an already-completed step preserves its original timestamp. Step must be 1–7.", {
+    step: z.number().int().min(1).max(7).describe("The onboarding step number (1–7) to mark as completed"),
+}, async ({ step }) => {
+    try {
+        const state = await completeOnboardingStep(getSession, ACCOUNT_ID, step);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(state, null, 2),
+                }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to complete onboarding step: ${err instanceof Error ? err.message : String(err)}`,
+                }],
+            isError: true,
+        };
+    }
+});
+// ===================================================================
+// Utility tools
+// ===================================================================
+server.tool("qr-generate", "Generate a QR code from text or a URL. Returns the QR code as a data URI (PNG) or saves to a file path.", {
+    data: z.string().describe("The text or URL to encode in the QR code"),
+    outputPath: z
+        .string()
+        .optional()
+        .describe("File path to save the PNG. If omitted, returns a data URI."),
+    width: z.number().optional().describe("Width in pixels (default 300)"),
+}, async ({ data, outputPath, width }) => {
+    try {
+        const options = { width: width ?? 300, margin: 2 };
+        if (outputPath) {
+            await QRCode.toFile(outputPath, data, options);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `QR code saved to ${outputPath}`,
+                    },
+                ],
+            };
+        }
+        const dataUri = await QRCode.toDataURL(data, options);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `QR code generated for: ${data}`,
+                },
+                {
+                    type: "image",
+                    data: dataUri.replace(/^data:image\/png;base64,/, ""),
+                    mimeType: "image/png",
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `QR generation failed: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Cleanup on exit (SIGTERM for systemd service stops on Pi)
+const cleanup = async () => {
+    await closeDriver();
+    process.exit(0);
+};
+process.on("SIGINT", cleanup);
+process.on("SIGTERM", cleanup);
+const transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=index.js.map