npm - @kirosnn/mosaic - Versions diffs - 0.0.7 - Mend

@kirosnn/mosaic 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (154) hide show

package/.mosaic/mosaic.local.jsonc +0 -0
package/MOSAIC.md +188 -0
package/README.md +127 -0
package/docs/mosaic.png +0 -0
package/package.json +42 -0
package/src/agent/Agent.ts +131 -0
package/src/agent/context.ts +96 -0
package/src/agent/index.ts +2 -0
package/src/agent/prompts/systemPrompt.ts +138 -0
package/src/agent/prompts/toolsPrompt.ts +139 -0
package/src/agent/provider/anthropic.ts +122 -0
package/src/agent/provider/google.ts +124 -0
package/src/agent/provider/mistral.ts +117 -0
package/src/agent/provider/ollama.ts +531 -0
package/src/agent/provider/openai.ts +220 -0
package/src/agent/provider/xai.ts +122 -0
package/src/agent/tools/bash.ts +20 -0
package/src/agent/tools/definitions.ts +27 -0
package/src/agent/tools/edit.ts +23 -0
package/src/agent/tools/executor.ts +751 -0
package/src/agent/tools/explore.ts +18 -0
package/src/agent/tools/exploreExecutor.ts +320 -0
package/src/agent/tools/glob.ts +16 -0
package/src/agent/tools/grep.ts +19 -0
package/src/agent/tools/index.ts +4 -0
package/src/agent/tools/list.ts +20 -0
package/src/agent/tools/question.ts +20 -0
package/src/agent/tools/read.ts +15 -0
package/src/agent/tools/write.ts +21 -0
package/src/agent/types.ts +155 -0
package/src/components/App.tsx +174 -0
package/src/components/CommandsModal.tsx +77 -0
package/src/components/CustomInput.tsx +328 -0
package/src/components/Main.tsx +1112 -0
package/src/components/Notification.tsx +91 -0
package/src/components/SelectList.tsx +47 -0
package/src/components/Setup.tsx +528 -0
package/src/components/ShortcutsModal.tsx +67 -0
package/src/components/Welcome.tsx +39 -0
package/src/components/main/ApprovalPanel.tsx +134 -0
package/src/components/main/ChatPage.tsx +516 -0
package/src/components/main/HomePage.tsx +111 -0
package/src/components/main/QuestionPanel.tsx +85 -0
package/src/components/main/ThinkingIndicator.tsx +101 -0
package/src/components/main/types.ts +55 -0
package/src/components/main/wrapText.ts +41 -0
package/src/index.tsx +212 -0
package/src/utils/approvalBridge.ts +129 -0
package/src/utils/commands/echo.ts +22 -0
package/src/utils/commands/help.ts +25 -0
package/src/utils/commands/index.ts +68 -0
package/src/utils/commands/init.ts +68 -0
package/src/utils/commands/redo.ts +74 -0
package/src/utils/commands/registry.ts +29 -0
package/src/utils/commands/sessions.ts +129 -0
package/src/utils/commands/types.ts +20 -0
package/src/utils/commands/undo.ts +75 -0
package/src/utils/commands/web.ts +77 -0
package/src/utils/config.ts +357 -0
package/src/utils/diff.ts +201 -0
package/src/utils/diffRendering.tsx +62 -0
package/src/utils/exploreBridge.ts +87 -0
package/src/utils/fileChangeTracker.ts +98 -0
package/src/utils/fileChangesBridge.ts +18 -0
package/src/utils/history.ts +106 -0
package/src/utils/markdown.tsx +232 -0
package/src/utils/models.ts +304 -0
package/src/utils/questionBridge.ts +122 -0
package/src/utils/terminalUtils.ts +25 -0
package/src/utils/toolFormatting.ts +384 -0
package/src/utils/undoRedo.ts +429 -0
package/src/utils/undoRedoBridge.ts +45 -0
package/src/utils/undoRedoDb.ts +338 -0
package/src/utils/uninstall.ts +45 -0
package/src/utils/version.ts +3 -0
package/src/web/app.tsx +606 -0
package/src/web/assets/css/ChatPage.css +212 -0
package/src/web/assets/css/FileExplorer.css +202 -0
package/src/web/assets/css/HomePage.css +119 -0
package/src/web/assets/css/Markdown.css +178 -0
package/src/web/assets/css/MessageItem.css +160 -0
package/src/web/assets/css/Sidebar.css +208 -0
package/src/web/assets/css/SidebarModal.css +137 -0
package/src/web/assets/css/ThinkingIndicator.css +47 -0
package/src/web/assets/css/ToolMessage.css +148 -0
package/src/web/assets/css/global.css +226 -0
package/src/web/assets/fonts/Geist-Black.woff2 +0 -0
package/src/web/assets/fonts/Geist-BlackItalic.woff2 +0 -0
package/src/web/assets/fonts/Geist-Bold.woff2 +0 -0
package/src/web/assets/fonts/Geist-BoldItalic.woff2 +0 -0
package/src/web/assets/fonts/Geist-ExtraBold.woff2 +0 -0
package/src/web/assets/fonts/Geist-ExtraBoldItalic.woff2 +0 -0
package/src/web/assets/fonts/Geist-ExtraLight.woff2 +0 -0
package/src/web/assets/fonts/Geist-ExtraLightItalic.woff2 +0 -0
package/src/web/assets/fonts/Geist-Italic[wght].woff2 +0 -0
package/src/web/assets/fonts/Geist-Light.woff2 +0 -0
package/src/web/assets/fonts/Geist-LightItalic.woff2 +0 -0
package/src/web/assets/fonts/Geist-Medium.woff2 +0 -0
package/src/web/assets/fonts/Geist-MediumItalic.woff2 +0 -0
package/src/web/assets/fonts/Geist-Regular.woff2 +0 -0
package/src/web/assets/fonts/Geist-RegularItalic.woff2 +0 -0
package/src/web/assets/fonts/Geist-SemiBold.woff2 +0 -0
package/src/web/assets/fonts/Geist-SemiBoldItalic.woff2 +0 -0
package/src/web/assets/fonts/Geist-Thin.woff2 +0 -0
package/src/web/assets/fonts/Geist-ThinItalic.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-Black.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-BlackItalic.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-Bold.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-BoldItalic.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-ExtraBold.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-ExtraBoldItalic.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-ExtraLight.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-ExtraLightItalic.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-Italic.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-Italic[wght].woff2 +0 -0
package/src/web/assets/fonts/GeistMono-Light.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-LightItalic.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-Medium.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-MediumItalic.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-Regular.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-SemiBold.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-SemiBoldItalic.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-Thin.woff2 +0 -0
package/src/web/assets/fonts/GeistMono-ThinItalic.woff2 +0 -0
package/src/web/assets/fonts/GeistMono[wght].woff2 +0 -0
package/src/web/assets/fonts/Geist[wght].woff2 +0 -0
package/src/web/assets/fonts/blauer-nue-regular.woff2 +0 -0
package/src/web/assets/fonts/neue-montreal-regular.woff2 +0 -0
package/src/web/assets/images/favicon-v2.svg +6 -0
package/src/web/assets/images/favicon.png +0 -0
package/src/web/assets/images/foruse.svg +5 -0
package/src/web/assets/images/logo_black.svg +5 -0
package/src/web/assets/images/logo_white.svg +5 -0
package/src/web/assets/images/logoblack.png +0 -0
package/src/web/assets/images/logowhite.png +0 -0
package/src/web/build.ts +23 -0
package/src/web/components/ApprovalPanel.tsx +191 -0
package/src/web/components/ChatPage.tsx +273 -0
package/src/web/components/FileExplorer.tsx +162 -0
package/src/web/components/HomePage.tsx +121 -0
package/src/web/components/MessageItem.tsx +178 -0
package/src/web/components/Modal.tsx +30 -0
package/src/web/components/QuestionPanel.tsx +149 -0
package/src/web/components/Setup.tsx +211 -0
package/src/web/components/Sidebar.tsx +292 -0
package/src/web/components/ThinkingIndicator.tsx +85 -0
package/src/web/logo_black.svg +5 -0
package/src/web/logo_white.svg +5 -0
package/src/web/router.ts +46 -0
package/src/web/server.tsx +662 -0
package/src/web/storage.ts +92 -0
package/src/web/types.ts +17 -0
package/src/web/utils.ts +61 -0
package/tsconfig.json +33 -0

package/src/web/server.tsx ADDED Viewed

@@ -0,0 +1,662 @@
+import { serve } from "bun";
+import { join } from "path";
+import { existsSync, readdirSync, statSync } from "fs";
+import { build } from "bun";
+import { createCliRenderer, TextAttributes } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+import React from "react";
+import { exec } from "child_process";
+const PORT = 8192;
+const HOST = "127.0.0.1";
+import { subscribeQuestion, answerQuestion } from "../utils/questionBridge";
+import { subscribeApproval, respondApproval } from "../utils/approvalBridge";
+let currentAbortController: AbortController | null = null;
+const HTML_TEMPLATE = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Mosaic</title>
+    <link rel="icon" type="image/svg+xml" href="/logo_black.svg" media="(prefers-color-scheme: light)">
+    <link rel="icon" type="image/svg+xml" href="/logo_white.svg" media="(prefers-color-scheme: dark)">
+    <link rel="stylesheet" href="/app.css">
+</head>
+<body>
+    <div id="root"></div>
+    <script type="module" src="/app.js"></script>
+</body>
+</html>`;
+type LogEntry = { message: string; timestamp: string };
+const logs: LogEntry[] = [];
+const listeners: Set<() => void> = new Set();
+function addLog(message: string) {
+    const timestamp = new Date().toLocaleTimeString();
+    const clean = String(message ?? "").replace(/\r/g, "").trimEnd();
+    if (!clean) return;
+    const lines = clean.split("\n");
+    for (const line of lines) {
+        if (!line) continue;
+        logs.push({ message: line, timestamp });
+    }
+    while (logs.length > 50) logs.shift();
+    listeners.forEach((l) => l());
+}
+function installExternalLogCapture() {
+    const originalLog = console.log.bind(console);
+    const originalInfo = console.info.bind(console);
+    const originalWarn = console.warn.bind(console);
+    const originalError = console.error.bind(console);
+    console.log = (...args: any[]) => {
+        addLog(args.map(String).join(" "));
+        originalLog(...args);
+    };
+    console.info = (...args: any[]) => {
+        addLog(args.map(String).join(" "));
+        originalInfo(...args);
+    };
+    console.warn = (...args: any[]) => {
+        addLog(args.map(String).join(" "));
+        originalWarn(...args);
+    };
+    console.error = (...args: any[]) => {
+        addLog(args.map(String).join(" "));
+        originalError(...args);
+    };
+    if (typeof process !== "undefined" && process?.stdout?.write) {
+        const originalStdoutWrite = process.stdout.write.bind(process.stdout) as (
+            chunk: any,
+            encoding?: any,
+            cb?: any
+        ) => boolean;
+        process.stdout.write = ((chunk: any, encoding?: any, cb?: any) => {
+            try {
+                const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+                addLog(text);
+            } catch { }
+            return originalStdoutWrite(chunk, encoding as any, cb as any);
+        }) as any;
+    }
+    if (typeof process !== "undefined" && process?.stderr?.write) {
+        const originalStderrWrite = process.stderr.write.bind(process.stderr) as (
+            chunk: any,
+            encoding?: any,
+            cb?: any
+        ) => boolean;
+        process.stderr.write = ((chunk: any, encoding?: any, cb?: any) => {
+            try {
+                const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+                addLog(text);
+            } catch { }
+            return originalStderrWrite(chunk, encoding as any, cb as any);
+        }) as any;
+    }
+}
+installExternalLogCapture();
+let appJsContent: string | null = null;
+let appCssContent: string | null = null;
+async function buildApp() {
+    const appPath = join(__dirname, "app.tsx");
+    if (!existsSync(appPath)) {
+        throw new Error(`App file not found at: ${appPath}`);
+    }
+    const buildResult = await build({
+        entrypoints: [appPath],
+        target: "browser",
+        format: "esm",
+        minify: false,
+        splitting: false,
+        sourcemap: "none",
+    });
+    if (!buildResult.success) {
+        throw new Error("Build failed");
+    }
+    const outputs = buildResult.outputs;
+    if (outputs.length === 0) {
+        throw new Error("No build output generated");
+    }
+    for (const output of outputs) {
+        if (output.path.endsWith('.js') || output.kind === 'entry-point') {
+            appJsContent = await output.text();
+        } else if (output.path.endsWith('.css') || output.type === 'text/css') {
+            appCssContent = await output.text();
+        }
+    }
+}
+try {
+    await buildApp();
+    addLog("App built");
+    const projectPath = process.env.MOSAIC_PROJECT_PATH;
+    if (projectPath) {
+        const { addRecentProject } = await import("../utils/config");
+        addRecentProject(projectPath);
+        addLog(`Project added to recents: ${projectPath}`);
+    }
+} catch (error) {
+    console.error("Failed to build app:", error);
+    throw error;
+}
+let currentPort = PORT;
+async function startServer(port: number, maxRetries = 10) {
+    try {
+        const server = serve({
+            port: port,
+            hostname: HOST,
+            idleTimeout: 0,
+            async fetch(request) {
+                const url = new URL(request.url);
+                try {
+                    const isApiRoute = url.pathname.startsWith('/api/');
+                    const isStaticFile = url.pathname.match(/\.(js|css|svg|ico|png|jpg|jpeg|gif|webp|woff|woff2|ttf|eot)$/);
+                    if (url.pathname === "/" || url.pathname === "/home" || url.pathname.startsWith("/chat")) {
+                        addLog(`${request.method} ${url.pathname}`);
+                        return new Response(HTML_TEMPLATE, {
+                            headers: { "Content-Type": "text/html" },
+                        });
+                    }
+                    if (url.pathname === "/app.js") {
+                        if (!appJsContent) {
+                            addLog("App not built");
+                            return new Response("App not built", { status: 500 });
+                        }
+                        addLog(`${request.method} /app.js`);
+                        return new Response(appJsContent, {
+                            headers: {
+                                "Content-Type": "application/javascript",
+                                "Cache-Control": "no-cache",
+                            },
+                        });
+                    }
+                    if (url.pathname === "/app.css") {
+                        if (!appCssContent) {
+                            return new Response("", { headers: { "Content-Type": "text/css" } });
+                        }
+                        addLog(`${request.method} /app.css`);
+                        return new Response(appCssContent, {
+                            headers: {
+                                "Content-Type": "text/css",
+                                "Cache-Control": "no-cache",
+                            },
+                        });
+                    }
+                    if (url.pathname === "/logo_black.svg") {
+                        const logoPath = join(__dirname, "logo_black.svg");
+                        if (existsSync(logoPath)) {
+                            return new Response(Bun.file(logoPath), {
+                                headers: { "Content-Type": "image/svg+xml" }
+                            });
+                        }
+                        return new Response("Not Found", { status: 404 });
+                    }
+                    if (url.pathname === "/logo_white.svg") {
+                        const logoPath = join(__dirname, "logo_white.svg");
+                        if (existsSync(logoPath)) {
+                            return new Response(Bun.file(logoPath), {
+                                headers: { "Content-Type": "image/svg+xml" }
+                            });
+                        }
+                        return new Response("Not Found", { status: 404 });
+                    }
+                    if (url.pathname === "/favicon.ico") {
+                        const faviconPath = join(__dirname, "favicon.ico");
+                        if (existsSync(faviconPath)) {
+                            return new Response(Bun.file(faviconPath));
+                        }
+                        return new Response("Not Found", { status: 404 });
+                    }
+                    if (url.pathname === "/favicon.png") {
+                        const faviconPath = join(__dirname, "favicon.png");
+                        if (existsSync(faviconPath)) {
+                            return new Response(Bun.file(faviconPath));
+                        }
+                        return new Response("Not Found", { status: 404 });
+                    }
+                    if (url.pathname === "/api/workspace" && request.method === "GET") {
+                        const workspace = process.cwd();
+                        return new Response(JSON.stringify({ workspace }), {
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+                    if (url.pathname === "/api/workspace" && request.method === "POST") {
+                        const body = (await request.json()) as { path: string };
+                        if (!body.path || typeof body.path !== "string") {
+                            return new Response(JSON.stringify({ error: "Invalid path" }), {
+                                status: 400,
+                                headers: { "Content-Type": "application/json" },
+                            });
+                        }
+                        try {
+                            process.chdir(body.path);
+                            return new Response(JSON.stringify({ success: true, workspace: process.cwd() }), {
+                                headers: { "Content-Type": "application/json" },
+                            });
+                        } catch (error) {
+                            return new Response(JSON.stringify({ error: "Failed to change directory" }), {
+                                status: 500,
+                                headers: { "Content-Type": "application/json" },
+                            });
+                        }
+                    }
+                    if (url.pathname === "/api/files" && request.method === "GET") {
+                        const urlObj = new URL(request.url);
+                        const queryPath = urlObj.searchParams.get("path");
+                        const currentPath = queryPath || process.cwd();
+                        try {
+                            if (!existsSync(currentPath)) {
+                                return new Response(JSON.stringify({ error: "Path does not exist" }), {
+                                    status: 404,
+                                    headers: { "Content-Type": "application/json" },
+                                });
+                            }
+                            const items = readdirSync(currentPath, { withFileTypes: true });
+                            const files = items.map((item) => ({
+                                name: item.name,
+                                isDirectory: item.isDirectory(),
+                                path: join(currentPath, item.name)
+                            })).sort((a, b) => {
+                                if (a.isDirectory === b.isDirectory) {
+                                    return a.name.localeCompare(b.name);
+                                }
+                                return a.isDirectory ? -1 : 1;
+                            });
+                            return new Response(JSON.stringify({
+                                path: currentPath,
+                                files
+                            }), {
+                                headers: { "Content-Type": "application/json" },
+                            });
+                        } catch (error) {
+                            return new Response(JSON.stringify({ error: "Failed to list files" }), {
+                                status: 500,
+                                headers: { "Content-Type": "application/json" },
+                            });
+                        }
+                    }
+                    if (url.pathname === "/api/recent-projects" && request.method === "GET") {
+                        const { getRecentProjects } = await import("../utils/config");
+                        const recentProjects = getRecentProjects();
+                        return new Response(JSON.stringify(recentProjects), {
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+                    if (url.pathname === "/api/config" && request.method === "GET") {
+                        const { readConfig } = await import("../utils/config");
+                        const config = readConfig();
+                        return new Response(JSON.stringify({
+                            provider: config.provider,
+                            model: config.model
+                        }), {
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+                    if (url.pathname === "/api/add-recent-project" && request.method === "POST") {
+                        const body = (await request.json()) as { path: string };
+                        if (!body.path || typeof body.path !== "string") {
+                            return new Response(JSON.stringify({ error: "Invalid path" }), {
+                                status: 400,
+                                headers: { "Content-Type": "application/json" },
+                            });
+                        }
+                        const { addRecentProject } = await import("../utils/config");
+                        addRecentProject(body.path);
+                        addLog(`Added recent project: ${body.path}`);
+                        return new Response(JSON.stringify({ success: true }), {
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+                    if (url.pathname === "/api/question/answer" && request.method === "POST") {
+                        const body = (await request.json()) as { index: number; customText?: string };
+                        answerQuestion(body.index, body.customText);
+                        return new Response(JSON.stringify({ success: true }), {
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+                    if (url.pathname === "/api/approval/respond" && request.method === "POST") {
+                        const body = (await request.json()) as { approved: boolean; customResponse?: string };
+                        respondApproval(body.approved, body.customResponse);
+                        return new Response(JSON.stringify({ success: true }), {
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+                    if (url.pathname === "/api/stop" && request.method === "POST") {
+                        if (currentAbortController) {
+                            currentAbortController.abort();
+                            currentAbortController = null;
+                            addLog("Agent stopped by user");
+                            return new Response(JSON.stringify({ success: true, message: "Agent stopped" }), {
+                                headers: { "Content-Type": "application/json" },
+                            });
+                        }
+                        return new Response(JSON.stringify({ success: false, message: "No agent running" }), {
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+                    if (url.pathname === "/api/message" && request.method === "POST") {
+                        const body = (await request.json()) as {
+                            message: string;
+                            history: Array<{ role: string; content: string }>;
+                        };
+                        if (!body.message || typeof body.message !== "string") {
+                            addLog("Invalid message format");
+                            return new Response(JSON.stringify({ error: "Invalid message format" }), {
+                                status: 400,
+                                headers: { "Content-Type": "application/json" },
+                            });
+                        }
+                        addLog("Message received");
+                        currentAbortController = new AbortController();
+                        const abortSignal = currentAbortController.signal;
+                        const encoder = new TextEncoder();
+                        const stream = new ReadableStream({
+                            async start(controller) {
+                                let keepAlive: ReturnType<typeof setInterval> | null = null;
+                                let aborted = false;
+                                const cleanup = () => {
+                                    if (keepAlive) clearInterval(keepAlive);
+                                    currentAbortController = null;
+                                };
+                                const safeEnqueue = (text: string) => {
+                                    if (aborted) return false;
+                                    try {
+                                        controller.enqueue(encoder.encode(text));
+                                        return true;
+                                    } catch {
+                                        return false;
+                                    }
+                                };
+                                abortSignal.addEventListener('abort', () => {
+                                    aborted = true;
+                                    safeEnqueue(JSON.stringify({ type: 'stopped', message: 'Agent stopped by user' }) + "\n");
+                                    cleanup();
+                                    questionUnsub();
+                                    approvalUnsub();
+                                    exploreUnsub?.();
+                                    try { controller.close(); } catch { }
+                                });
+                                const questionUnsub = subscribeQuestion((req) => {
+                                    safeEnqueue(JSON.stringify({ type: 'question', request: req }) + "\n");
+                                });
+                                const approvalUnsub = subscribeApproval((req) => {
+                                    safeEnqueue(JSON.stringify({ type: 'approval', request: req }) + "\n");
+                                });
+                                keepAlive = setInterval(() => {
+                                    safeEnqueue(JSON.stringify({ type: 'ping' }) + "\n");
+                                }, 5000);
+                                let exploreUnsub: (() => void) | null = null;
+                                try {
+                                    const { Agent } = await import("../agent");
+                                    const { subscribeExploreTool } = await import("../utils/exploreBridge");
+                                    addLog("[EXPLORE] Subscribing...");
+                                    exploreUnsub = subscribeExploreTool((event) => {
+                                        addLog(`[EXPLORE] Tool: ${event.toolName}`);
+                                        safeEnqueue(JSON.stringify({ type: 'explore-tool', ...event }) + "\n");
+                                    });
+                                    addLog("[EXPLORE] Subscribed");
+                                    const providerStatus = await Agent.ensureProviderReady();
+                                    if (!providerStatus.ready) {
+                                        safeEnqueue(
+                                            JSON.stringify({
+                                                type: "error",
+                                                error: providerStatus.error || "Provider not ready",
+                                            }) + "\n"
+                                        );
+                                        cleanup();
+                                        questionUnsub();
+                                        approvalUnsub();
+                                        exploreUnsub?.();
+                                        controller.close();
+                                        return;
+                                    }
+                                    const agent = new Agent();
+                                    const conversationHistory = body.history || [];
+                                    conversationHistory.push({ role: "user", content: body.message });
+                                    for await (const event of agent.streamMessages(conversationHistory as any, {})) {
+                                        if (aborted) break;
+                                        if (!safeEnqueue(JSON.stringify(event) + "\n")) break;
+                                    }
+                                    cleanup();
+                                    questionUnsub();
+                                    approvalUnsub();
+                                    exploreUnsub?.();
+                                    if (!aborted) controller.close();
+                                } catch (error) {
+                                    if (!aborted) {
+                                        safeEnqueue(
+                                            JSON.stringify({
+                                                type: "error",
+                                                error: error instanceof Error ? error.message : "Unknown error",
+                                            }) + "\n"
+                                        );
+                                    }
+                                    cleanup();
+                                    questionUnsub();
+                                    approvalUnsub();
+                                    exploreUnsub?.();
+                                    try { controller.close(); } catch { }
+                                }
+                            },
+                        });
+                        return new Response(stream, {
+                            headers: {
+                                "Content-Type": "text/event-stream",
+                                "Cache-Control": "no-cache",
+                                Connection: "keep-alive",
+                            },
+                        });
+                    }
+                    addLog(`${request.method} ${url.pathname} (404)`);
+                    return new Response("Not Found", { status: 404 });
+                } catch (error) {
+                    console.error("Request error:", error);
+                    addLog(`Server error: ${error instanceof Error ? error.message : "Unknown"}`);
+                    return new Response("Internal Server Error", { status: 500 });
+                }
+            },
+            error(error) {
+                console.error("Server error:", error);
+                return new Response("Internal Server Error", { status: 500 });
+            },
+        });
+        currentPort = port;
+        const serverUrl = `http://${HOST}:${port}`;
+        const openCommand = process.platform === "win32" ? `start ${serverUrl}` :
+            process.platform === "darwin" ? `open ${serverUrl}` :
+                `xdg-open ${serverUrl}`;
+        exec(openCommand, (error) => {
+            if (error) {
+                console.error("Failed to open browser:", error);
+            }
+        });
+        return server;
+    } catch (err: any) {
+        if (err.code === "EADDRINUSE") {
+            if (maxRetries > 0) {
+                console.log(`Port ${port} is in use, trying ${port + 1}...`);
+                return startServer(port + 1, maxRetries - 1);
+            } else {
+                console.error(`Failed to find an available port after retries.`);
+                throw err;
+            }
+        } else {
+            throw err;
+        }
+    }
+}
+await startServer(PORT);
+function ServerStatus() {
+    const [logList, setLogList] = React.useState<LogEntry[]>(logs);
+    const [scrollOffset, setScrollOffset] = React.useState(0);
+    const [terminalHeight, setTerminalHeight] = React.useState(process.stdout.rows || 24);
+    React.useEffect(() => {
+        const listener = () => {
+            setLogList([...logs]);
+            setScrollOffset(Math.max(0, logs.length - (terminalHeight - 6)));
+        };
+        listeners.add(listener);
+        return () => {
+            listeners.delete(listener);
+        };
+    }, [terminalHeight]);
+    React.useEffect(() => {
+        const handleResize = () => {
+            setTerminalHeight(process.stdout.rows || 24);
+        };
+        process.stdout.on('resize', handleResize);
+        return () => {
+            process.stdout.off('resize', handleResize);
+        };
+    }, []);
+    React.useEffect(() => {
+        const handleData = (data: Buffer) => {
+            const str = data.toString();
+            if (str.includes('\x03')) {
+                process.exit(0);
+            }
+            if (str.match(/\x1b\[<64;\d+;\d+M/)) {
+                setScrollOffset(prev => Math.max(0, prev - 1));
+            } else if (str.match(/\x1b\[<65;\d+;\d+M/)) {
+                setScrollOffset(prev => prev + 1);
+            }
+        };
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+            process.stdout.write('\x1b[?1000h\x1b[?1006h\x1b[?1003h');
+            process.stdin.on('data', handleData);
+        }
+        return () => {
+            if (process.stdin.isTTY) {
+                process.stdin.off('data', handleData);
+                process.stdout.write('\x1b[?1000l\x1b[?1006l\x1b[?1003l');
+                process.stdin.setRawMode(false);
+            }
+        };
+    }, []);
+    const logsHeight = Math.max(5, terminalHeight - 6);
+    const visibleLogs = logList.slice(scrollOffset, scrollOffset + logsHeight);
+    return (
+        <box flexDirection="column" width="100%" height="100%" justifyContent="flex-start" alignItems="center" paddingTop={1}>
+            <box flexDirection="row" marginBottom={1}>
+                <text fg="#ffca38" attributes={TextAttributes.BOLD}>
+                    Web interface:{" "}
+                </text>
+                <text fg="gray">http://{HOST}:{currentPort}</text>
+            </box>
+            <box flexDirection="column" width={80} height={logsHeight} borderStyle="rounded" borderColor="gray" title={`Server Logs`}>
+                {logList.length === 0 ? (
+                    <text fg="gray" attributes={TextAttributes.DIM}>
+                        No logs yet...
+                    </text>
+                ) : (
+                    visibleLogs.map((log, i) => (
+                        <text key={i} fg="gray">
+                            [{log.timestamp}] {log.message}
+                        </text>
+                    ))
+                )}
+            </box>
+        </box>
+    );
+}
+const renderer = await createCliRenderer();
+createRoot(renderer).render(<ServerStatus />);