opencami 1.0.0

package/dist/server/assets/router-DbxyvprK.js

@@ -0,0 +1,2749 @@
+import { createRootRoute, Outlet, HeadContent, Scripts, createFileRoute, lazyRouteComponent, redirect, createRouter } from "@tanstack/react-router";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { QueryClientProvider, QueryClient } from "@tanstack/react-query";
+import { randomUUID } from "node:crypto";
+import WebSocket from "ws";
+import { json } from "@tanstack/router-core/ssr/client";
+import { readFile, mkdir, writeFile, rename, stat, readdir, rm, realpath, lstat } from "node:fs/promises";
+import os from "node:os";
+import path, { join, resolve, relative, extname } from "node:path";
+import { posix } from "path";
+const appCss = "/assets/styles-7aVSlb6l.css";
+const swRegisterScript = `
+(() => {
+  // Skip PWA service worker inside Capacitor native shell — they conflict
+  // with the native networking layer and caching.
+  if (window.Capacitor && window.Capacitor.isNativePlatform && window.Capacitor.isNativePlatform()) return;
+  if ('serviceWorker' in navigator) {
+    window.addEventListener('load', () => {
+      navigator.serviceWorker.register('/sw.js', { scope: '/' })
+        .then((reg) => {
+          // Auto-update: check for updates periodically
+          setInterval(() => reg.update(), 60 * 60 * 1000); // every hour
+          reg.addEventListener('updatefound', () => {
+            const newWorker = reg.installing;
+            if (newWorker) {
+              newWorker.addEventListener('statechange', () => {
+                if (newWorker.state === 'activated') {
+                  // New version activated, could notify user here
+                  console.log('[SW] New version activated');
+                }
+              });
+            }
+          });
+        })
+        .catch((err) => console.warn('[SW] Registration failed:', err));
+    });
+  }
+})()
+`;
+const themeScript = `
+(() => {
+  try {
+    const stored = localStorage.getItem('chat-settings')
+    let theme = 'system'
+    if (stored) {
+      const parsed = JSON.parse(stored)
+      const storedTheme = parsed?.state?.settings?.theme
+      if (storedTheme === 'light' || storedTheme === 'dark' || storedTheme === 'system' || storedTheme === 'chameleon') {
+        theme = storedTheme
+      }
+    }
+    const root = document.documentElement
+    const media = window.matchMedia('(prefers-color-scheme: dark)')
+    const apply = () => {
+      root.classList.remove('light', 'dark', 'system', 'chameleon')
+      root.classList.add(theme)
+      if (theme === 'system' && media.matches) {
+        root.classList.add('dark')
+      }
+    }
+    apply()
+    media.addEventListener('change', () => {
+      if (theme === 'system') apply()
+    })
+  } catch {}
+})()
+`;
+const textSizeScript = `
+(() => {
+  try {
+    const stored = localStorage.getItem('opencami-text-size')
+    const allowed = new Set(['14px', '16px', '18px', '20px'])
+    const value = allowed.has(stored) ? stored : '16px'
+    document.documentElement.style.setProperty('--opencami-text-size', value)
+  } catch {}
+})()
+`;
+const Route$p = createRootRoute({
+  head: () => ({
+    meta: [
+      {
+        charSet: "utf-8"
+      },
+      {
+        name: "viewport",
+        content: "width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover"
+      },
+      {
+        title: "OpenCami"
+      },
+      {
+        name: "description",
+        content: "a fast web client for OpenClaw"
+      },
+      {
+        property: "og:image",
+        content: "/cover.webp"
+      },
+      {
+        property: "og:image:type",
+        content: "image/webp"
+      },
+      {
+        name: "twitter:card",
+        content: "summary_large_image"
+      },
+      {
+        name: "twitter:image",
+        content: "/cover.webp"
+      },
+      // PWA - Theme color
+      {
+        name: "theme-color",
+        content: "#0a0a0a"
+      },
+      // PWA - Apple iOS meta tags
+      {
+        name: "apple-mobile-web-app-capable",
+        content: "yes"
+      },
+      {
+        name: "apple-mobile-web-app-status-bar-style",
+        content: "black-translucent"
+      },
+      {
+        name: "apple-mobile-web-app-title",
+        content: "OpenCami"
+      },
+      // PWA - Android meta tags
+      {
+        name: "mobile-web-app-capable",
+        content: "yes"
+      }
+    ],
+    links: [
+      {
+        rel: "stylesheet",
+        href: appCss
+      },
+      {
+        rel: "icon",
+        type: "image/svg+xml",
+        href: "/favicon.svg"
+      },
+      // PWA - Apple touch icon
+      {
+        rel: "apple-touch-icon",
+        href: "/apple-touch-icon-180x180.png"
+      },
+      // PWA - Manifest
+      {
+        rel: "manifest",
+        href: "/manifest.json"
+      }
+    ]
+  }),
+  shellComponent: RootDocument,
+  component: RootLayout
+});
+const queryClient = new QueryClient();
+function RootLayout() {
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(Outlet, {}) });
+}
+function RootDocument({ children }) {
+  return /* @__PURE__ */ jsxs("html", { lang: "en", suppressHydrationWarning: true, children: [
+    /* @__PURE__ */ jsxs("head", { children: [
+      /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: textSizeScript } }),
+      /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: themeScript } }),
+      /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: swRegisterScript } }),
+      /* @__PURE__ */ jsx(HeadContent, {})
+    ] }),
+    /* @__PURE__ */ jsxs("body", { children: [
+      /* @__PURE__ */ jsx("div", { className: "root", children }),
+      /* @__PURE__ */ jsx(Scripts, {})
+    ] })
+  ] });
+}
+const $$splitComponentImporter$4 = () => import("./new-Dzk5YxE9.js");
+const Route$o = createFileRoute("/new")({
+  beforeLoad: function redirectToNewChat() {
+    throw redirect({
+      to: "/chat/$sessionKey",
+      params: {
+        sessionKey: "new"
+      },
+      replace: true
+    });
+  },
+  component: lazyRouteComponent($$splitComponentImporter$4, "component")
+});
+const $$splitComponentImporter$3 = () => import("./files-CONoVTGD.js");
+const Route$n = createFileRoute("/files")({
+  component: lazyRouteComponent($$splitComponentImporter$3, "component")
+});
+const $$splitComponentImporter$2 = () => import("./connect-BWI_6rCm.js");
+const Route$m = createFileRoute("/connect")({
+  component: lazyRouteComponent($$splitComponentImporter$2, "component")
+});
+const $$splitComponentImporter$1 = () => import("./index-Bp8QskbI.js");
+const Route$l = createFileRoute("/")({
+  component: lazyRouteComponent($$splitComponentImporter$1, "component")
+});
+const $$splitComponentImporter = () => import("./_sessionKey-qlAPF_Ft.js").then((n) => n.$);
+const Route$k = createFileRoute("/chat/$sessionKey")({
+  component: lazyRouteComponent($$splitComponentImporter, "component")
+});
+function getGatewayConfig() {
+  const url = process.env.CLAWDBOT_GATEWAY_URL?.trim() || "ws://127.0.0.1:18789";
+  const token = process.env.CLAWDBOT_GATEWAY_TOKEN?.trim() || "";
+  const password = process.env.CLAWDBOT_GATEWAY_PASSWORD?.trim() || "";
+  if (!token && !password) {
+    throw new Error(
+      "Missing gateway auth. Set CLAWDBOT_GATEWAY_TOKEN (recommended) or CLAWDBOT_GATEWAY_PASSWORD in the server environment."
+    );
+  }
+  return { url, token, password };
+}
+function buildConnectParams(token, password) {
+  return {
+    minProtocol: 3,
+    maxProtocol: 3,
+    client: {
+      id: "gateway-client",
+      displayName: "webclaw",
+      version: "dev",
+      platform: process.platform,
+      mode: "ui",
+      instanceId: randomUUID()
+    },
+    auth: {
+      token: token || void 0,
+      password: password || void 0
+    },
+    role: "operator",
+    scopes: ["operator.admin"]
+  };
+}
+class PersistentGatewayConnection {
+  ws = null;
+  connected = false;
+  connectPromise = null;
+  pendingRpcs = /* @__PURE__ */ new Map();
+  reconnectTimer = null;
+  reconnectDelay = 1e3;
+  maxReconnectDelay = 3e4;
+  destroyed = false;
+  // Event listeners keyed by sessionKey — each sessionKey can have multiple listeners
+  sessionListeners = /* @__PURE__ */ new Map();
+  // Listeners that receive ALL events (for debugging or global subscriptions)
+  globalListeners = /* @__PURE__ */ new Set();
+  // Event buffer: store recent events per sessionKey so late subscribers don't miss them
+  eventBuffer = /* @__PURE__ */ new Map();
+  get isConnected() {
+    return this.connected && this.ws?.readyState === WebSocket.OPEN;
+  }
+  /** Ensure the persistent connection is up and authenticated. */
+  async ensureConnected() {
+    if (this.isConnected) return;
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = this._connect();
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+  async _connect() {
+    if (this.destroyed) throw new Error("Connection destroyed");
+    const { url, token, password } = getGatewayConfig();
+    const ws = new WebSocket(url);
+    this.ws = ws;
+    await new Promise((resolve2, reject) => {
+      const onOpen = () => {
+        cleanup();
+        resolve2();
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(new Error(`WS open error: ${err.message}`));
+      };
+      const cleanup = () => {
+        ws.off("open", onOpen);
+        ws.off("error", onError);
+      };
+      ws.on("open", onOpen);
+      ws.on("error", onError);
+    });
+    ws.on("message", (data) => this._onMessage(data));
+    ws.on("close", () => this._onClose());
+    ws.on("error", () => {
+    });
+    const connectId = randomUUID();
+    const connectParams = buildConnectParams(token, password);
+    ws.send(JSON.stringify({
+      type: "req",
+      id: connectId,
+      method: "connect",
+      params: connectParams
+    }));
+    await this._waitForRes(connectId, 1e4);
+    this.connected = true;
+    this.reconnectDelay = 1e3;
+    console.log("[gateway-ws] Persistent connection established");
+  }
+  _onMessage(data) {
+    try {
+      const str = typeof data === "string" ? data : data.toString();
+      const parsed = JSON.parse(str);
+      if (parsed.type === "res") {
+        const pending = this.pendingRpcs.get(parsed.id);
+        if (pending) {
+          this.pendingRpcs.delete(parsed.id);
+          clearTimeout(pending.timer);
+          if (parsed.ok) {
+            pending.resolve(parsed.payload);
+          } else {
+            pending.reject(new Error(parsed.error?.message ?? "gateway error"));
+          }
+        }
+        return;
+      }
+      if (parsed.type === "event") {
+        const event = {
+          event: parsed.event,
+          payload: parsed.payload ?? {},
+          seq: parsed.seq
+        };
+        const sessionKey = this._extractSessionKey(event);
+        for (const listener of this.globalListeners) {
+          try {
+            listener(event);
+          } catch {
+          }
+        }
+        if (sessionKey) {
+          const listeners = this.sessionListeners.get(sessionKey);
+          if (listeners && listeners.size > 0) {
+            for (const listener of listeners) {
+              try {
+                listener(event);
+              } catch {
+              }
+            }
+          } else {
+            let buf = this.eventBuffer.get(sessionKey);
+            if (!buf) {
+              const timer = setTimeout(() => {
+                this.eventBuffer.delete(sessionKey);
+              }, 1e4);
+              buf = { events: [], timer };
+              this.eventBuffer.set(sessionKey, buf);
+            }
+            buf.events.push(event);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  _extractSessionKey(event) {
+    const payload = event.payload;
+    if (typeof payload?.sessionKey === "string") return payload.sessionKey;
+    if (typeof payload?.session === "string") return payload.session;
+    if (payload?.data && typeof payload.data?.sessionKey === "string") {
+      return payload.data.sessionKey;
+    }
+    return null;
+  }
+  _onClose() {
+    const wasConnected = this.connected;
+    this.connected = false;
+    this.ws = null;
+    for (const [, pending] of this.pendingRpcs) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Connection closed"));
+    }
+    this.pendingRpcs.clear();
+    if (wasConnected) {
+      console.log("[gateway-ws] Connection lost, scheduling reconnect...");
+    }
+    if (!this.destroyed) {
+      this._scheduleReconnect();
+    }
+  }
+  _scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    const delay = this.reconnectDelay;
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+    console.log(`[gateway-ws] Reconnecting in ${delay}ms...`);
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.ensureConnected();
+      } catch (err) {
+        console.error("[gateway-ws] Reconnect failed:", err instanceof Error ? err.message : err);
+      }
+    }, delay);
+  }
+  _waitForRes(id, timeoutMs = 3e4) {
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRpcs.delete(id);
+        reject(new Error(`RPC timeout waiting for ${id}`));
+      }, timeoutMs);
+      this.pendingRpcs.set(id, { resolve: resolve2, reject, timer });
+    });
+  }
+  /** Send an RPC request over the persistent connection. */
+  async rpc(method, params, timeoutMs = 3e4) {
+    await this.ensureConnected();
+    const id = randomUUID();
+    const frame = { type: "req", id, method, params };
+    this.ws.send(JSON.stringify(frame));
+    const payload = await this._waitForRes(id, timeoutMs);
+    return payload;
+  }
+  /** Subscribe to events for a specific sessionKey. Returns an unsubscribe function. */
+  subscribe(sessionKey, listener) {
+    let listeners = this.sessionListeners.get(sessionKey);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.sessionListeners.set(sessionKey, listeners);
+    }
+    listeners.add(listener);
+    const buf = this.eventBuffer.get(sessionKey);
+    if (buf) {
+      this.eventBuffer.delete(sessionKey);
+      clearTimeout(buf.timer);
+      for (const event of buf.events) {
+        try {
+          listener(event);
+        } catch {
+        }
+      }
+    }
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        this.sessionListeners.delete(sessionKey);
+      }
+    };
+  }
+  /** Subscribe to ALL events. Returns an unsubscribe function. */
+  subscribeAll(listener) {
+    this.globalListeners.add(listener);
+    return () => {
+      this.globalListeners.delete(listener);
+    };
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+    this.sessionListeners.clear();
+    this.globalListeners.clear();
+  }
+}
+let _instance = null;
+function getPersistentConnection() {
+  if (!_instance) {
+    _instance = new PersistentGatewayConnection();
+  }
+  return _instance;
+}
+async function gatewayRpc(method, params) {
+  const conn = getPersistentConnection();
+  return conn.rpc(method, params);
+}
+function subscribeGatewayEvents(sessionKey, listener) {
+  const conn = getPersistentConnection();
+  return conn.subscribe(sessionKey, listener);
+}
+async function gatewayConnectCheck() {
+  const conn = getPersistentConnection();
+  await conn.ensureConnected();
+}
+async function ttsElevenLabs(text, apiKey, voice) {
+  const voiceId = voice || "21m00Tcm4TlvDq8ikWAM";
+  const res = await fetch(
+    `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`,
+    {
+      method: "POST",
+      headers: {
+        "xi-api-key": apiKey,
+        "Content-Type": "application/json",
+        Accept: "audio/mpeg"
+      },
+      body: JSON.stringify({
+        text: text.substring(0, 5e3),
+        model_id: "eleven_multilingual_v2",
+        voice_settings: {
+          stability: 0.5,
+          similarity_boost: 0.75
+        }
+      })
+    }
+  );
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`ElevenLabs error: ${err}`);
+  }
+  const audioBuffer = await res.arrayBuffer();
+  return new Response(audioBuffer, {
+    headers: {
+      "Content-Type": "audio/mpeg",
+      "Cache-Control": "public, max-age=3600"
+    }
+  });
+}
+async function ttsOpenAI(text, apiKey, voice) {
+  const res = await fetch("https://api.openai.com/v1/audio/speech", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: "tts-1",
+      input: text.substring(0, 4096),
+      voice: voice || "nova",
+      response_format: "mp3"
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`OpenAI TTS error: ${err}`);
+  }
+  const audioBuffer = await res.arrayBuffer();
+  return new Response(audioBuffer, {
+    headers: {
+      "Content-Type": "audio/mpeg",
+      "Cache-Control": "public, max-age=3600"
+    }
+  });
+}
+async function ttsEdge(text, voice) {
+  const { EdgeTTS } = await import("node-edge-tts");
+  const tts = new EdgeTTS();
+  await tts.synthesize(
+    text.substring(0, 5e3),
+    voice || "en-US-AriaNeural",
+    {}
+  );
+  const audioBuffer = await tts.toBuffer();
+  return new Response(audioBuffer, {
+    headers: {
+      "Content-Type": "audio/mpeg",
+      "Cache-Control": "public, max-age=3600"
+    }
+  });
+}
+const Route$j = createFileRoute("/api/tts")({
+  server: {
+    handlers: {
+      POST: async ({ request }) => {
+        try {
+          const body = await request.json().catch(() => ({}));
+          const text = typeof body.text === "string" ? body.text.trim() : "";
+          const voice = typeof body.voice === "string" ? body.voice.trim() : "";
+          const provider = typeof body.provider === "string" ? body.provider.trim() : "";
+          if (!text) {
+            return json(
+              { ok: false, error: "No text provided" },
+              { status: 400 }
+            );
+          }
+          const configRes = await gatewayRpc("config.get", {});
+          const ttsConfig = configRes?.config?.messages?.tts;
+          const env = configRes?.config?.env || {};
+          const elevenLabsKey = ttsConfig?.elevenlabs?.apiKey || env.ELEVENLABS_API_KEY || env.XI_API_KEY;
+          const openaiKey = ttsConfig?.openai?.apiKey || env.OPENAI_API_KEY;
+          const preferredProvider = provider || ttsConfig?.provider || "auto";
+          const errors = [];
+          if (preferredProvider === "elevenlabs" && elevenLabsKey) {
+            try {
+              return await ttsElevenLabs(text, elevenLabsKey, voice);
+            } catch (e) {
+              errors.push(
+                e instanceof Error ? e.message : String(e)
+              );
+            }
+          }
+          if (preferredProvider === "openai" && openaiKey) {
+            try {
+              return await ttsOpenAI(text, openaiKey, voice);
+            } catch (e) {
+              errors.push(
+                e instanceof Error ? e.message : String(e)
+              );
+            }
+          }
+          if (preferredProvider === "edge") {
+            try {
+              return await ttsEdge(text, voice);
+            } catch (e) {
+              errors.push(
+                e instanceof Error ? e.message : String(e)
+              );
+            }
+          }
+          if (preferredProvider === "auto" || errors.length > 0) {
+            if (elevenLabsKey) {
+              try {
+                return await ttsElevenLabs(
+                  text,
+                  elevenLabsKey,
+                  voice
+                );
+              } catch (e) {
+                errors.push(
+                  e instanceof Error ? e.message : String(e)
+                );
+              }
+            }
+            if (openaiKey) {
+              try {
+                return await ttsOpenAI(text, openaiKey, voice);
+              } catch (e) {
+                errors.push(
+                  e instanceof Error ? e.message : String(e)
+                );
+              }
+            }
+            try {
+              return await ttsEdge(text, voice);
+            } catch (e) {
+              errors.push(
+                e instanceof Error ? e.message : String(e)
+              );
+            }
+          }
+          return json(
+            {
+              ok: false,
+              error: `All TTS providers failed: ${errors.join("; ")}`
+            },
+            { status: 502 }
+          );
+        } catch (err) {
+          return json(
+            {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err)
+            },
+            { status: 500 }
+          );
+        }
+      }
+    }
+  }
+});
+const Route$i = createFileRoute("/api/stream")({
+  server: {
+    handlers: {
+      GET: async ({ request }) => {
+        const url = new URL(request.url);
+        const sessionKey = url.searchParams.get("sessionKey");
+        if (!sessionKey) {
+          return new Response(
+            JSON.stringify({ ok: false, error: "sessionKey required" }),
+            { status: 400, headers: { "content-type": "application/json" } }
+          );
+        }
+        const encoder = new TextEncoder();
+        let unsubscribe = null;
+        let closed = false;
+        const stream = new ReadableStream({
+          start(controller) {
+            controller.enqueue(encoder.encode(": connected\n\n"));
+            function sendSSE(event, data) {
+              if (closed) return;
+              try {
+                controller.enqueue(
+                  encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`)
+                );
+              } catch {
+              }
+            }
+            let gotAgentStream = false;
+            unsubscribe = subscribeGatewayEvents(sessionKey, (evt) => {
+              if (evt.event === "agent") {
+                const payload = evt.payload;
+                const agentStream = payload.stream;
+                if (agentStream === "assistant") {
+                  gotAgentStream = true;
+                  const data = payload.data ?? payload;
+                  const text = typeof data.delta === "string" ? data.delta : typeof data.text === "string" ? data.text : typeof payload.text === "string" ? payload.text : typeof payload.delta === "string" ? payload.delta : "";
+                  if (text) {
+                    sendSSE("delta", { text, sessionKey });
+                  }
+                } else if (agentStream === "tool") {
+                  gotAgentStream = true;
+                  const tdata = payload.data ?? payload;
+                  sendSSE("tool", {
+                    name: tdata.name ?? tdata.toolName ?? payload.name ?? "",
+                    status: tdata.phase ?? tdata.status ?? payload.phase ?? "running",
+                    id: tdata.id ?? tdata.toolCallId ?? payload.id ?? "",
+                    sessionKey
+                  });
+                } else if (agentStream === "lifecycle") {
+                  const ldata = payload.data ?? payload;
+                  const phase = ldata.phase ?? payload.phase;
+                  if (phase === "end" || phase === "error") {
+                    sendSSE("done", {
+                      sessionKey,
+                      status: phase,
+                      error: phase === "error" ? payload.error : void 0
+                    });
+                  }
+                }
+              } else if (evt.event === "chat") {
+                const payload = evt.payload;
+                const kind = payload.kind;
+                if (kind === "delta" && !gotAgentStream) {
+                  const text = typeof payload.text === "string" ? payload.text : typeof payload.delta === "string" ? payload.delta : "";
+                  if (text) {
+                    sendSSE("delta", { text, sessionKey });
+                  }
+                } else if (kind === "final") {
+                  sendSSE("done", { sessionKey, status: "end" });
+                }
+              }
+            });
+          },
+          cancel() {
+            closed = true;
+            if (unsubscribe) {
+              unsubscribe();
+              unsubscribe = null;
+            }
+          }
+        });
+        if (request.signal) {
+          request.signal.addEventListener("abort", () => {
+            closed = true;
+            if (unsubscribe) {
+              unsubscribe();
+              unsubscribe = null;
+            }
+          });
+        }
+        return new Response(stream, {
+          headers: {
+            "content-type": "text/event-stream",
+            "cache-control": "no-cache, no-transform",
+            connection: "keep-alive",
+            "x-accel-buffering": "no"
+          }
+        });
+      }
+    }
+  }
+});
+function deriveFriendlyIdFromKey(key) {
+  if (typeof key !== "string" || key.trim().length === 0) return "main";
+  const parts = key.split(":");
+  const tail = parts[parts.length - 1];
+  return tail && tail.trim().length > 0 ? tail.trim() : key;
+}
+function normalizeSessions(payload) {
+  const sessions = Array.isArray(
+    payload.sessions
+  ) ? payload.sessions : [];
+  const normalized = sessions.map((session) => {
+    const rawKey = session.key;
+    const key = typeof rawKey === "string" ? rawKey : "";
+    const rawFriendly = session.friendlyId;
+    const friendlyIdFromPayload = typeof rawFriendly === "string" ? rawFriendly.trim() : "";
+    const friendlyId = friendlyIdFromPayload.length > 0 ? friendlyIdFromPayload : deriveFriendlyIdFromKey(key);
+    return {
+      ...session,
+      key,
+      friendlyId
+    };
+  });
+  return { sessions: normalized };
+}
+const Route$h = createFileRoute("/api/sessions")({
+  server: {
+    handlers: {
+      GET: async () => {
+        try {
+          const payload = await gatewayRpc(
+            "sessions.list",
+            {
+              limit: 50,
+              includeLastMessage: true,
+              includeDerivedTitles: true
+            }
+          );
+          return json(normalizeSessions(payload));
+        } catch (err) {
+          return json(
+            {
+              error: err instanceof Error ? err.message : String(err)
+            },
+            { status: 500 }
+          );
+        }
+      },
+      POST: async ({ request }) => {
+        try {
+          const body = await request.json().catch(() => ({}));
+          const requestedLabel = typeof body.label === "string" ? body.label.trim() : "";
+          const label = requestedLabel || void 0;
+          const friendlyId = randomUUID();
+          const params = { key: friendlyId };
+          if (label) params.label = label;
+          const payload = await gatewayRpc(
+            "sessions.patch",
+            params
+          );
+          const sessionKeyRaw = payload.key;
+          const sessionKey = typeof sessionKeyRaw === "string" && sessionKeyRaw.trim().length > 0 ? sessionKeyRaw.trim() : "";
+          if (sessionKey.length === 0) {
+            throw new Error("gateway returned an invalid response");
+          }
+          await gatewayRpc("sessions.resolve", {
+            key: friendlyId,
+            includeUnknown: true,
+            includeGlobal: true
+          }).catch(() => ({ ok: false }));
+          return json({
+            ok: true,
+            sessionKey,
+            friendlyId,
+            entry: payload.entry
+          });
+        } catch (err) {
+          return json(
+            {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err)
+            },
+            { status: 500 }
+          );
+        }
+      },
+      PATCH: async ({ request }) => {
+        try {
+          const body = await request.json().catch(() => ({}));
+          const rawSessionKey = typeof body.sessionKey === "string" ? body.sessionKey.trim() : "";
+          const rawFriendlyId = typeof body.friendlyId === "string" ? body.friendlyId.trim() : "";
+          const label = typeof body.label === "string" ? body.label.trim() : void 0;
+          let sessionKey = rawSessionKey;
+          const friendlyId = rawFriendlyId;
+          if (friendlyId) {
+            const resolved = await gatewayRpc(
+              "sessions.resolve",
+              {
+                key: friendlyId,
+                includeUnknown: true,
+                includeGlobal: true
+              }
+            );
+            const resolvedKey = typeof resolved.key === "string" ? resolved.key.trim() : "";
+            if (resolvedKey.length > 0) sessionKey = resolvedKey;
+          }
+          if (!sessionKey) {
+            return json(
+              { ok: false, error: "sessionKey required" },
+              { status: 400 }
+            );
+          }
+          const params = { key: sessionKey };
+          if (label) params.label = label;
+          const payload = await gatewayRpc(
+            "sessions.patch",
+            params
+          );
+          return json({
+            ok: true,
+            sessionKey,
+            entry: payload.entry
+          });
+        } catch (err) {
+          return json(
+            {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err)
+            },
+            { status: 500 }
+          );
+        }
+      },
+      DELETE: async ({ request }) => {
+        try {
+          const url = new URL(request.url);
+          const rawSessionKey = url.searchParams.get("sessionKey") ?? "";
+          const rawFriendlyId = url.searchParams.get("friendlyId") ?? "";
+          let sessionKey = rawSessionKey.trim();
+          const friendlyId = rawFriendlyId.trim();
+          if (friendlyId) {
+            const resolved = await gatewayRpc(
+              "sessions.resolve",
+              {
+                key: friendlyId,
+                includeUnknown: true,
+                includeGlobal: true
+              }
+            );
+            const resolvedKey = typeof resolved.key === "string" ? resolved.key.trim() : "";
+            if (resolvedKey.length > 0) sessionKey = resolvedKey;
+          }
+          if (!sessionKey) {
+            return json(
+              { ok: false, error: "sessionKey required" },
+              { status: 400 }
+            );
+          }
+          await gatewayRpc("sessions.delete", { key: sessionKey });
+          if (friendlyId && friendlyId !== sessionKey) {
+            await gatewayRpc("sessions.delete", { key: friendlyId }).catch(
+              () => ({})
+            );
+          }
+          return json({ ok: true, sessionKey });
+        } catch (err) {
+          return json(
+            {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err)
+            },
+            { status: 500 }
+          );
+        }
+      }
+    }
+  }
+});
+const Route$g = createFileRoute("/api/send")({
+  server: {
+    handlers: {
+      POST: async ({ request }) => {
+        try {
+          const body = await request.json().catch(() => ({}));
+          const rawSessionKey = typeof body.sessionKey === "string" ? body.sessionKey.trim() : "";
+          const friendlyId = typeof body.friendlyId === "string" ? body.friendlyId.trim() : "";
+          const message = String(body.message ?? "");
+          const thinking = typeof body.thinking === "string" ? body.thinking : void 0;
+          const rawAttachments = body.attachments;
+          const attachments = Array.isArray(rawAttachments) ? rawAttachments.filter(
+            (a) => typeof a === "object" && a !== null && typeof a.mimeType === "string" && typeof a.content === "string"
+          ) : void 0;
+          if (!message.trim() && (!attachments || attachments.length === 0)) {
+            return json(
+              { ok: false, error: "message required" },
+              { status: 400 }
+            );
+          }
+          let sessionKey = rawSessionKey.length > 0 ? rawSessionKey : "";
+          if (!sessionKey && friendlyId) {
+            const resolved = await gatewayRpc(
+              "sessions.resolve",
+              {
+                key: friendlyId,
+                includeUnknown: true,
+                includeGlobal: true
+              }
+            );
+            const resolvedKey = typeof resolved.key === "string" ? resolved.key.trim() : "";
+            if (resolvedKey.length === 0) {
+              return json(
+                { ok: false, error: "session not found" },
+                { status: 404 }
+              );
+            }
+            sessionKey = resolvedKey;
+          }
+          if (sessionKey.length === 0) {
+            sessionKey = "main";
+          }
+          const res = await gatewayRpc("chat.send", {
+            sessionKey,
+            message,
+            thinking,
+            // model, // Gateway doesn't support model override yet
+            attachments,
+            deliver: false,
+            timeoutMs: 12e4,
+            idempotencyKey: typeof body.idempotencyKey === "string" ? body.idempotencyKey : randomUUID()
+          });
+          return json({ ok: true, ...res, sessionKey });
+        } catch (err) {
+          return json(
+            {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err)
+            },
+            { status: 500 }
+          );
+        }
+      }
+    }
+  }
+});
+const Route$f = createFileRoute("/api/ping")({
+  server: {
+    handlers: {
+      GET: async () => {
+        try {
+          await gatewayConnectCheck();
+          return json({ ok: true });
+        } catch (err) {
+          return json(
+            {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err)
+            },
+            { status: 503 }
+          );
+        }
+      }
+    }
+  }
+});
+const categories = { "core": [{ "id": "cami", "name": "Cami", "emoji": "🦎", "description": "Adaptive AI chameleon companion" }, { "id": "chameleon-agent", "name": "Chameleon Agent", "emoji": "🌀", "description": "Meta-adaptive agent" }, { "id": "professor-stein", "name": "Professor Stein", "emoji": "🎓", "description": "Academic educator & researcher" }, { "id": "dev", "name": "Dev", "emoji": "💻", "description": "Senior programmer & code expert" }, { "id": "flash", "name": "Flash", "emoji": "⚡", "description": "Quick answers & fast problem solver" }], "creative": [{ "id": "luna", "name": "Luna", "emoji": "🌙", "description": "Creative writer & storyteller" }], "curator": [{ "id": "vibe", "name": "Vibe", "emoji": "🎵", "description": "Music curator & playlist expert" }], "learning": [{ "id": "herr-mueller", "name": "Herr Müller", "emoji": "🇩🇪", "description": "German language teacher" }, { "id": "scholar", "name": "Scholar", "emoji": "📚", "description": "Research assistant & academic guide" }, { "id": "lingua", "name": "Lingua", "emoji": "🌍", "description": "Multilingual language coach" }], "lifestyle": [{ "id": "chef-marco", "name": "Chef Marco", "emoji": "👨‍🍳", "description": "Italian cooking expert" }, { "id": "fit", "name": "Fit", "emoji": "💪", "description": "Fitness trainer & health coach" }, { "id": "zen", "name": "Zen", "emoji": "🧘", "description": "Mindfulness & meditation guide" }], "professional": [{ "id": "cyberguard", "name": "Cyberguard", "emoji": "🛡️", "description": "Cybersecurity expert" }, { "id": "dataviz", "name": "DataViz", "emoji": "📊", "description": "Data visualization specialist" }, { "id": "career-coach", "name": "Career Coach", "emoji": "🎯", "description": "Career guidance & interview prep" }, { "id": "legal-guide", "name": "Legal Guide", "emoji": "⚖️", "description": "Legal information assistant" }, { "id": "startup-sam", "name": "Startup Sam", "emoji": "🚀", "description": "Startup advisor & entrepreneur" }, { "id": "dr-med", "name": "Dr. Med", "emoji": "🩺", "description": "Medical information educator" }, { "id": "wordsmith", "name": "Wordsmith", "emoji": "✍️", "description": "Writing coach & editor" }] };
+const personasData = {
+  categories
+};
+const Route$e = createFileRoute("/api/personas")({
+  server: {
+    handlers: {
+      GET: async () => {
+        try {
+          const res = await gatewayRpc("config.get", {});
+          const workspace = res.config?.agents?.defaults?.workspace || "/root/clawd";
+          const skillJson = await readFile(
+            `${workspace}/skills/personas/skill.json`,
+            "utf-8"
+          );
+          const skill = JSON.parse(skillJson);
+          return json({
+            ok: true,
+            personas: personasData.categories,
+            available: true,
+            skillVersion: skill.version
+          });
+        } catch {
+          return json({
+            ok: true,
+            personas: {},
+            available: false
+          });
+        }
+      }
+    }
+  }
+});
+function resolveSessionsDir() {
+  const agentId = (process.env.CLAWDBOT_AGENT_ID || "main").trim() || "main";
+  const stateDir = (process.env.CLAWDBOT_STATE_DIR || path.join(os.homedir(), ".clawdbot")).trim();
+  return {
+    agentId,
+    stateDir,
+    sessionsDir: path.join(stateDir, "agents", agentId, "sessions"),
+    storePath: path.join(
+      stateDir,
+      "agents",
+      agentId,
+      "sessions",
+      "sessions.json"
+    )
+  };
+}
+const Route$d = createFileRoute("/api/paths")({
+  server: {
+    handlers: {
+      GET: () => {
+        return json(resolveSessionsDir());
+      }
+    }
+  }
+});
+function parseModelName(modelId) {
+  if (modelId.includes("hf:")) {
+    const match = modelId.match(/hf:[^/]+\/(.+)$/);
+    if (match) {
+      return match[1].replace(/-/g, " ");
+    }
+  }
+  const segments = modelId.split("/");
+  const model = segments[segments.length - 1];
+  return model.split("-").map((word) => {
+    if (["gpt", "ai", "api", "glm"].includes(word.toLowerCase())) {
+      return word.toUpperCase();
+    }
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }).join(" ");
+}
+const Route$c = createFileRoute("/api/models")({
+  server: {
+    handlers: {
+      GET: async () => {
+        try {
+          const res = await gatewayRpc("config.get", {});
+          const models = [];
+          if (res.config?.agents?.defaults?.models) {
+            const agentModels = res.config.agents.defaults.models;
+            for (const [modelId, modelConfig] of Object.entries(agentModels)) {
+              const parsedName = parseModelName(modelId);
+              models.push({
+                id: modelId,
+                name: modelConfig.alias ? `${parsedName} (${modelConfig.alias})` : parsedName,
+                provider: modelId.split("/")[0]
+              });
+            }
+          }
+          if (models.length === 0 && res.config?.chat?.models && Array.isArray(res.config.chat.models)) {
+            for (const model of res.config.chat.models) {
+              if (model.enabled !== false && model.id) {
+                models.push({
+                  id: model.id,
+                  name: model.name || parseModelName(model.id),
+                  provider: model.provider
+                });
+              }
+            }
+          }
+          if (models.length === 0 && res.config?.model?.allowed) {
+            for (const modelId of res.config.model.allowed) {
+              models.push({
+                id: modelId,
+                name: parseModelName(modelId)
+              });
+            }
+          }
+          const defaultModel = res.config?.agents?.defaults?.model?.primary || res.config?.chat?.defaultModel || res.config?.model?.defaultModel || models[0]?.id || "";
+          return json({
+            ok: true,
+            models,
+            defaultModel
+          });
+        } catch (err) {
+          console.error("[models] Error fetching models:", err);
+          return json({
+            ok: true,
+            models: [
+              {
+                id: "default",
+                name: "Default Model"
+              }
+            ],
+            defaultModel: "default"
+          });
+        }
+      }
+    }
+  }
+});
+const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+const DEFAULT_TIMEOUT_MS = 1e4;
+const MODEL_FALLBACK_CHAIN = [
+  "gpt-4.1-nano",
+  "gpt-4o-mini",
+  "gpt-3.5-turbo"
+];
+async function chatCompletion(messages, options) {
+  const {
+    apiKey,
+    baseUrl = DEFAULT_BASE_URL,
+    model,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    maxTokens = 100
+  } = options;
+  const modelsToTry = model ? [model] : MODEL_FALLBACK_CHAIN;
+  let lastError = null;
+  for (const currentModel of modelsToTry) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model: currentModel,
+          messages,
+          max_tokens: maxTokens,
+          temperature: 0.7
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        if (response.status === 404 || errorText.includes("model_not_found")) {
+          console.log(`[llm-client] Model ${currentModel} not available, trying next...`);
+          lastError = new Error(`Model ${currentModel} not found`);
+          continue;
+        }
+        throw new Error(`OpenAI API error: ${response.status} ${errorText}`);
+      }
+      const data = await response.json();
+      const content = data.choices[0]?.message?.content?.trim() || "";
+      if (content) {
+        return content;
+      }
+      lastError = new Error(`Model ${currentModel} returned empty response`);
+      continue;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        lastError = new Error("OpenAI API request timed out");
+        continue;
+      }
+      lastError = error instanceof Error ? error : new Error(String(error));
+      continue;
+    }
+  }
+  throw lastError || new Error("All models failed");
+}
+async function generateSessionTitle(message, options) {
+  const systemPrompt = `Generate a concise 3-6 word title for this conversation. 
+Rules:
+- No quotes or punctuation at the end
+- Capture the main topic/intent
+- Be specific, not generic
+- Use title case`;
+  return chatCompletion(
+    [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: message }
+    ],
+    { ...options, maxTokens: 25 }
+  );
+}
+async function generateFollowUps(conversationContext, options) {
+  const systemPrompt = `Based on this conversation, suggest 3 natural follow-up questions the user might ask.
+Rules:
+- Each question max 10 words
+- Make them specific to the conversation context
+- Vary the types: clarification, deeper dive, related topic
+- Return ONLY a JSON array of 3 strings, nothing else`;
+  const response = await chatCompletion(
+    [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: conversationContext }
+    ],
+    { ...options, maxTokens: 150 }
+  );
+  try {
+    let jsonStr = response.trim();
+    if (jsonStr.startsWith("```")) {
+      jsonStr = jsonStr.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+    }
+    const parsed = JSON.parse(jsonStr);
+    if (Array.isArray(parsed) && parsed.length > 0) {
+      return parsed.slice(0, 3).map(String);
+    }
+  } catch {
+  }
+  return [];
+}
+async function testApiKey(apiKey) {
+  try {
+    await chatCompletion(
+      [{ role: "user", content: "Hi" }],
+      { apiKey, maxTokens: 1, timeoutMs: 5e3 }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getApiKey(request) {
+  const headerKey = request.headers.get("X-OpenAI-API-Key");
+  if (headerKey?.trim()) {
+    return headerKey.trim();
+  }
+  const envKey = process.env.OPENAI_API_KEY?.trim();
+  if (envKey) {
+    return envKey;
+  }
+  return null;
+}
+function generateHeuristicTitle(message) {
+  let text = message.replace(/```[\s\S]*?```/g, " ");
+  text = text.replace(/`[^`]+`/g, " ");
+  text = text.replace(/https?:\/\/[^\s]+/g, " ");
+  text = text.replace(/[^\w\s.,!?'-]/g, " ");
+  text = text.replace(/\s+/g, " ").trim();
+  const words = text.split(/\s+/).filter((word) => {
+    if (word.length <= 2 && !["AI", "ML", "UI", "UX", "API", "CSS", "JS"].includes(word.toUpperCase())) {
+      return false;
+    }
+    return true;
+  });
+  const titleWords = words.slice(0, 6);
+  let title = titleWords.join(" ");
+  title = title.replace(/[.,!?]+$/, "");
+  if (title.length > 60) {
+    title = title.slice(0, 57) + "...";
+  }
+  return title || message.slice(0, 50);
+}
+const Route$b = createFileRoute("/api/llm-features")({
+  server: {
+    handlers: {
+      /**
+       * GET /api/llm-features - Check LLM features status
+       */
+      GET: async () => {
+        try {
+          const hasEnvKey = Boolean(process.env.OPENAI_API_KEY?.trim());
+          return json({
+            ok: true,
+            hasEnvKey
+          });
+        } catch (err) {
+          return json({
+            ok: false,
+            hasEnvKey: false,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      },
+      /**
+       * POST /api/llm-features - Handle LLM feature requests
+       * 
+       * Request body should include an "action" field:
+       * - action: "title" - Generate session title
+       * - action: "followups" - Generate follow-up suggestions
+       * - action: "test" - Test API key validity
+       */
+      POST: async ({ request }) => {
+        try {
+          const body = await request.json().catch(() => ({}));
+          const action = body.action;
+          switch (action) {
+            case "title": {
+              const { message } = body;
+              if (!message || typeof message !== "string" || message.trim().length < 3) {
+                return json({
+                  ok: false,
+                  error: "Message is required and must be at least 3 characters"
+                });
+              }
+              const apiKey = getApiKey(request);
+              if (!apiKey) {
+                const title = generateHeuristicTitle(message);
+                return json({
+                  ok: true,
+                  title,
+                  source: "heuristic"
+                });
+              }
+              try {
+                const title = await generateSessionTitle(message, { apiKey });
+                return json({
+                  ok: true,
+                  title,
+                  source: "llm"
+                });
+              } catch (err) {
+                console.error("[llm-features] Title generation error:", err);
+                const title = generateHeuristicTitle(message);
+                return json({
+                  ok: true,
+                  title,
+                  source: "heuristic",
+                  error: err instanceof Error ? err.message : "LLM error, used heuristic"
+                });
+              }
+            }
+            case "followups": {
+              const { conversationContext } = body;
+              if (!conversationContext || typeof conversationContext !== "string" || conversationContext.trim().length < 10) {
+                return json({
+                  ok: true,
+                  suggestions: [],
+                  source: "heuristic"
+                });
+              }
+              const apiKey = getApiKey(request);
+              if (!apiKey) {
+                return json({
+                  ok: true,
+                  suggestions: [],
+                  source: "heuristic"
+                });
+              }
+              try {
+                const suggestions = await generateFollowUps(conversationContext, { apiKey });
+                return json({
+                  ok: true,
+                  suggestions,
+                  source: "llm"
+                });
+              } catch (err) {
+                console.error("[llm-features] Follow-ups generation error:", err);
+                return json({
+                  ok: true,
+                  suggestions: [],
+                  source: "heuristic",
+                  error: err instanceof Error ? err.message : "LLM error"
+                });
+              }
+            }
+            case "test": {
+              const headerKey = request.headers.get("X-OpenAI-API-Key")?.trim();
+              if (!headerKey) {
+                return json({
+                  ok: false,
+                  error: "API key required in X-OpenAI-API-Key header"
+                });
+              }
+              try {
+                const valid = await testApiKey(headerKey);
+                return json({
+                  ok: true,
+                  valid
+                });
+              } catch (err) {
+                return json({
+                  ok: true,
+                  valid: false,
+                  error: err instanceof Error ? err.message : "Test failed"
+                });
+              }
+            }
+            default:
+              return json({
+                ok: false,
+                error: `Unknown action: ${action}. Valid actions: title, followups, test`
+              }, { status: 400 });
+          }
+        } catch (err) {
+          console.error("[llm-features] Error:", err);
+          return json({
+            ok: false,
+            error: err instanceof Error ? err.message : String(err)
+          }, { status: 500 });
+        }
+      }
+    }
+  }
+});
+const Route$a = createFileRoute("/api/history")({
+  server: {
+    handlers: {
+      GET: async ({ request }) => {
+        try {
+          const url = new URL(request.url);
+          const limit = Number(url.searchParams.get("limit") || "200");
+          const rawSessionKey = url.searchParams.get("sessionKey")?.trim();
+          const friendlyId = url.searchParams.get("friendlyId")?.trim();
+          let sessionKey = rawSessionKey && rawSessionKey.length > 0 ? rawSessionKey : "";
+          if (!sessionKey && friendlyId) {
+            const resolved = await gatewayRpc(
+              "sessions.resolve",
+              {
+                key: friendlyId,
+                includeUnknown: true,
+                includeGlobal: true
+              }
+            );
+            const resolvedKey = typeof resolved.key === "string" ? resolved.key.trim() : "";
+            if (resolvedKey.length === 0) {
+              return json({ error: "session not found" }, { status: 404 });
+            }
+            sessionKey = resolvedKey;
+          }
+          if (sessionKey.length === 0) {
+            sessionKey = "main";
+          }
+          const payload = await gatewayRpc(
+            "chat.history",
+            {
+              sessionKey,
+              limit
+            }
+          );
+          return json(payload);
+        } catch (err) {
+          return json(
+            {
+              error: err instanceof Error ? err.message : String(err)
+            },
+            { status: 500 }
+          );
+        }
+      }
+    }
+  }
+});
+const FOLLOW_UP_SYSTEM_PROMPT = `You are a helpful assistant that generates follow-up question suggestions.
+Given the assistant's last response, generate exactly 3 short, natural follow-up questions the user might want to ask.
+
+Rules:
+- Each suggestion should be a single, concise question (under 60 characters preferred)
+- Make them contextually relevant to the response
+- Vary the types: clarification, deeper exploration, practical application
+- Use natural, conversational language
+- Do not number them or add any prefix
+
+Output format: Return ONLY the 3 questions, one per line, nothing else.`;
+function parseFollowUps(text) {
+  const lines = text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => line.replace(/^\d+[.)\s]+/, "").trim()).map((line) => line.replace(/^[-•*]\s*/, "").trim()).map((line) => line.replace(/^["']|["']$/g, "").trim()).filter((line) => line.length > 0 && line.length < 150);
+  return lines.slice(0, 3);
+}
+const Route$9 = createFileRoute("/api/follow-ups")({
+  server: {
+    handlers: {
+      POST: async ({ request }) => {
+        try {
+          const body = await request.json().catch(() => ({}));
+          const responseText = typeof body.responseText === "string" ? body.responseText.trim() : "";
+          if (!responseText || responseText.length < 30) {
+            return json({ ok: true, suggestions: [] });
+          }
+          const truncatedResponse = responseText.length > 1500 ? responseText.slice(0, 1500) + "..." : responseText;
+          const contextSummary = typeof body.contextSummary === "string" ? body.contextSummary.slice(0, 500) : "";
+          const userPrompt = contextSummary ? `Context: ${contextSummary}
+
+Assistant's response:
+${truncatedResponse}` : `Assistant's response:
+${truncatedResponse}`;
+          const res = await gatewayRpc("chat.complete", {
+            messages: [
+              { role: "system", content: FOLLOW_UP_SYSTEM_PROMPT },
+              { role: "user", content: userPrompt }
+            ],
+            maxTokens: 200,
+            temperature: 0.7
+            // Use session's default model (no hardcoding!)
+          });
+          const content = res.content || res.message?.content || res.choices?.[0]?.message?.content || "";
+          const suggestions = parseFollowUps(content);
+          return json({ ok: true, suggestions });
+        } catch (err) {
+          console.error("[follow-ups] Error generating suggestions:", err);
+          return json({
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+            suggestions: []
+          });
+        }
+      }
+    }
+  }
+});
+function createError(message, status, code) {
+  const err = new Error(message);
+  err.status = status;
+  err.code = code;
+  return err;
+}
+let _cachedRoot = null;
+function getFilesRoot() {
+  if (_cachedRoot) return _cachedRoot;
+  const root = process.env.FILES_ROOT?.trim();
+  _cachedRoot = root ? resolve(root) : process.env.HOME || "/home";
+  return _cachedRoot;
+}
+async function resolveSafePath(virtualPath) {
+  const root = getFilesRoot();
+  if (virtualPath.includes("\0")) {
+    throw createError("Invalid path", 400, "INVALID_PATH");
+  }
+  const cleaned = virtualPath.replace(/^\/+/, "");
+  const resolved = resolve(root, cleaned);
+  const rel = relative(root, resolved);
+  if (rel.startsWith("..") || resolve(root, rel) !== resolved) {
+    throw createError("Path is outside the allowed directory", 403, "FORBIDDEN");
+  }
+  try {
+    const real = await realpath(resolved);
+    const realRoot = await realpath(root);
+    if (!real.startsWith(realRoot + "/") && real !== realRoot) {
+      throw createError("Path is outside the allowed directory", 403, "FORBIDDEN");
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT" && err.status !== 403) ;
+    if (err.status === 403) throw err;
+  }
+  return resolved;
+}
+function classifyFile(name, isDirectory) {
+  if (isDirectory) return "directory";
+  const ext = extname(name).toLowerCase().slice(1);
+  const imageExts = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "ico", "tiff"]);
+  const videoExts = /* @__PURE__ */ new Set(["mp4", "mkv", "avi", "mov", "wmv", "flv", "webm"]);
+  const audioExts = /* @__PURE__ */ new Set(["mp3", "wav", "ogg", "flac", "aac", "m4a", "wma"]);
+  const textExts = /* @__PURE__ */ new Set([
+    "txt",
+    "md",
+    "log",
+    "json",
+    "xml",
+    "yaml",
+    "yml",
+    "csv",
+    "ini",
+    "conf",
+    "cfg",
+    "js",
+    "ts",
+    "jsx",
+    "tsx",
+    "py",
+    "java",
+    "cpp",
+    "c",
+    "h",
+    "css",
+    "html",
+    "htm",
+    "php",
+    "rb",
+    "go",
+    "rs",
+    "sh",
+    "bash",
+    "zsh",
+    "fish",
+    "toml",
+    "env",
+    "gitignore",
+    "dockerfile",
+    "makefile"
+  ]);
+  if (imageExts.has(ext)) return "image";
+  if (videoExts.has(ext)) return "video";
+  if (audioExts.has(ext)) return "audio";
+  if (textExts.has(ext)) return "text";
+  return "blob";
+}
+async function buildFileItem(absolutePath, name, virtualPath) {
+  const [stats, linkStats] = await Promise.all([
+    stat(absolutePath),
+    lstat(absolutePath)
+  ]);
+  const isDir = stats.isDirectory();
+  return {
+    path: virtualPath,
+    name,
+    size: stats.size,
+    extension: isDir ? "" : extname(name).slice(1).toLowerCase(),
+    modified: stats.mtime.toISOString(),
+    mode: stats.mode,
+    isDir,
+    isSymlink: linkStats.isSymbolicLink(),
+    type: classifyFile(name, isDir)
+  };
+}
+async function listFiles(path2 = "/") {
+  const absolutePath = await resolveSafePath(path2);
+  let stats;
+  try {
+    stats = await stat(absolutePath);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw createError(`Path not found: ${path2}`, 404, "NOT_FOUND");
+    }
+    throw createError(`Failed to access path: ${err.message}`, 500, "FS_ERROR");
+  }
+  if (!stats.isDirectory()) {
+    throw createError("Path is not a directory", 400, "NOT_DIRECTORY");
+  }
+  let entries;
+  try {
+    entries = await readdir(absolutePath, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === "EACCES") {
+      throw createError("Permission denied", 403, "PERMISSION_DENIED");
+    }
+    throw createError(`Failed to read directory: ${err.message}`, 500, "FS_ERROR");
+  }
+  const visibleEntries = entries;
+  const items = [];
+  let numDirs = 0;
+  let numFiles = 0;
+  for (const entry of visibleEntries) {
+    const entryPath = join(absolutePath, entry.name);
+    const virtualEntryPath = path2 === "/" ? `/${entry.name}` : `${path2}/${entry.name}`;
+    try {
+      const item = await buildFileItem(entryPath, entry.name, virtualEntryPath);
+      items.push(item);
+      if (item.isDir) numDirs++;
+      else numFiles++;
+    } catch {
+    }
+  }
+  items.sort((a, b) => {
+    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+    return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+  });
+  const dirName = path2 === "/" ? "/" : path2.split("/").pop() || "/";
+  return {
+    items,
+    path: path2,
+    name: dirName,
+    isDir: true,
+    size: stats.size,
+    modified: stats.mtime.toISOString(),
+    mode: stats.mode,
+    numDirs,
+    numFiles,
+    sorting: { by: "name", asc: true }
+  };
+}
+async function getFileInfo(path2) {
+  const absolutePath = await resolveSafePath(path2);
+  try {
+    const name = path2.split("/").pop() || "";
+    return await buildFileItem(absolutePath, name, path2);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw createError(`File not found: ${path2}`, 404, "NOT_FOUND");
+    }
+    throw createError(`Failed to get file info: ${err.message}`, 500, "FS_ERROR");
+  }
+}
+async function downloadFile(path2) {
+  const absolutePath = await resolveSafePath(path2);
+  try {
+    const buffer = await readFile(absolutePath);
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw createError(`File not found: ${path2}`, 404, "NOT_FOUND");
+    }
+    if (err.code === "EACCES") {
+      throw createError("Permission denied", 403, "PERMISSION_DENIED");
+    }
+    throw createError(`Failed to read file: ${err.message}`, 500, "FS_ERROR");
+  }
+}
+async function uploadFile(path2, content) {
+  const absolutePath = await resolveSafePath(path2);
+  const parentDir = absolutePath.substring(0, absolutePath.lastIndexOf("/"));
+  await mkdir(parentDir, { recursive: true }).catch(() => {
+  });
+  try {
+    await writeFile(absolutePath, Buffer.from(content));
+  } catch (err) {
+    if (err.code === "EACCES") {
+      throw createError("Permission denied", 403, "PERMISSION_DENIED");
+    }
+    throw createError(`Failed to write file: ${err.message}`, 500, "FS_ERROR");
+  }
+}
+async function deleteFile(path2) {
+  const absolutePath = await resolveSafePath(path2);
+  try {
+    await rm(absolutePath, { recursive: true });
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw createError(`File not found: ${path2}`, 404, "NOT_FOUND");
+    }
+    if (err.code === "EACCES") {
+      throw createError("Permission denied", 403, "PERMISSION_DENIED");
+    }
+    throw createError(`Failed to delete: ${err.message}`, 500, "FS_ERROR");
+  }
+}
+async function createFolder(path2) {
+  const absolutePath = await resolveSafePath(path2);
+  try {
+    await mkdir(absolutePath, { recursive: true });
+  } catch (err) {
+    if (err.code === "EACCES") {
+      throw createError("Permission denied", 403, "PERMISSION_DENIED");
+    }
+    if (err.code === "EEXIST") {
+      throw createError("Directory already exists", 409, "ALREADY_EXISTS");
+    }
+    throw createError(`Failed to create directory: ${err.message}`, 500, "FS_ERROR");
+  }
+}
+async function renameFile(src, dst) {
+  const absoluteSrc = await resolveSafePath(src);
+  const absoluteDst = await resolveSafePath(dst);
+  const parentDir = absoluteDst.substring(0, absoluteDst.lastIndexOf("/"));
+  await mkdir(parentDir, { recursive: true }).catch(() => {
+  });
+  try {
+    await rename(absoluteSrc, absoluteDst);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw createError(`Source not found: ${src}`, 404, "NOT_FOUND");
+    }
+    if (err.code === "EACCES") {
+      throw createError("Permission denied", 403, "PERMISSION_DENIED");
+    }
+    throw createError(`Failed to rename: ${err.message}`, 500, "FS_ERROR");
+  }
+}
+function sanitizePath(path2) {
+  if (typeof path2 !== "string" || path2.length === 0) {
+    return "/";
+  }
+  let normalized = posix.normalize(path2);
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  const parts = normalized.split("/").filter((part) => part !== "" && part !== ".");
+  const safeParts = [];
+  for (const part of parts) {
+    if (part === "..") {
+      if (safeParts.length > 0) {
+        safeParts.pop();
+      }
+    } else {
+      safeParts.push(part);
+    }
+  }
+  return "/" + safeParts.join("/");
+}
+function isPathSafe(path2) {
+  if (typeof path2 !== "string") {
+    return false;
+  }
+  if (path2.includes("../") || path2.includes("..\\") || path2 === "..") {
+    return false;
+  }
+  if (path2.includes("\0")) {
+    return false;
+  }
+  if (path2.includes("\\")) {
+    return false;
+  }
+  const sanitized = sanitizePath(path2);
+  return path2 === sanitized || path2.endsWith("/") && sanitized === path2.slice(0, -1);
+}
+function validatePath(path2, context = "Path") {
+  if (!path2 || typeof path2 !== "string") {
+    throw new Error(`${context} is required`);
+  }
+  if (!isPathSafe(path2)) {
+    throw new Error(`${context} contains invalid characters or traversal attempts`);
+  }
+  return sanitizePath(path2);
+}
+function validateFilename(filename) {
+  if (typeof filename !== "string" || filename.length === 0) {
+    return false;
+  }
+  if (filename.includes("/") || filename.includes("\\")) {
+    return false;
+  }
+  if (filename.includes("\0")) {
+    return false;
+  }
+  for (let i = 0; i < filename.length; i++) {
+    const code = filename.charCodeAt(i);
+    if (code >= 0 && code <= 31) {
+      return false;
+    }
+  }
+  const reserved = [
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9"
+  ];
+  const nameUpper = filename.toUpperCase();
+  if (reserved.includes(nameUpper) || reserved.some((res) => nameUpper.startsWith(res + "."))) {
+    return false;
+  }
+  if (filename === "." || filename === "..") {
+    return false;
+  }
+  return true;
+}
+const MAX_FILE_SIZE = 100 * 1024 * 1024;
+const Route$8 = createFileRoute("/api/files/upload")({
+  server: {
+    handlers: {
+      POST: async ({ request }) => {
+        try {
+          const formData = await request.formData();
+          const rawPath = formData.get("path");
+          if (!rawPath) {
+            return json(
+              {
+                error: "path parameter is required",
+                code: "MISSING_PATH"
+              },
+              { status: 400 }
+            );
+          }
+          const path2 = validatePath(rawPath, "Path parameter");
+          const files = [];
+          for (const [key, value] of formData.entries()) {
+            if (key === "file" || key.startsWith("file")) {
+              if (value instanceof File) {
+                files.push(value);
+              }
+            }
+          }
+          if (files.length === 0) {
+            return json(
+              {
+                error: "At least one file is required",
+                code: "NO_FILES"
+              },
+              { status: 400 }
+            );
+          }
+          const uploadedFiles = [];
+          for (const file of files) {
+            if (file.size > MAX_FILE_SIZE) {
+              return json(
+                {
+                  error: `File "${file.name}" is too large. Maximum size is ${MAX_FILE_SIZE / 1024 / 1024}MB`,
+                  code: "FILE_TOO_LARGE"
+                },
+                { status: 413 }
+                // Payload Too Large
+              );
+            }
+            if (!validateFilename(file.name)) {
+              return json(
+                {
+                  error: `Invalid filename: "${file.name}". Filenames cannot contain path separators or control characters`,
+                  code: "INVALID_FILENAME"
+                },
+                { status: 400 }
+              );
+            }
+            const content = await file.arrayBuffer();
+            const fullPath = path2.endsWith("/") ? `${path2}${file.name}` : `${path2}/${file.name}`;
+            await uploadFile(fullPath, content);
+            uploadedFiles.push({
+              filename: file.name,
+              size: content.byteLength,
+              path: fullPath
+            });
+          }
+          return json({
+            ok: true,
+            message: `${uploadedFiles.length} file(s) uploaded successfully`,
+            files: uploadedFiles
+          });
+        } catch (err) {
+          const error = err;
+          if (error.message.includes("invalid characters") || error.message.includes("traversal attempts") || error.message.includes("Invalid filename")) {
+            return json(
+              {
+                error: error.message,
+                code: "VALIDATION_ERROR"
+              },
+              { status: 400 }
+            );
+          }
+          const status = error.status || 500;
+          const code = error.code || "INTERNAL_ERROR";
+          return json(
+            {
+              error: error.message || "An unexpected error occurred",
+              code
+            },
+            { status }
+          );
+        }
+      }
+    }
+  }
+});
+const MAX_TEXT_SIZE$1 = 5 * 1024 * 1024;
+const Route$7 = createFileRoute("/api/files/save")({
+  server: {
+    handlers: {
+      POST: async ({ request }) => {
+        try {
+          const body = await request.json().catch(() => ({}));
+          const rawPath = typeof body.path === "string" ? body.path.trim() : "";
+          const content = typeof body.content === "string" ? body.content : null;
+          if (!rawPath) {
+            return json({ error: "path is required", code: "MISSING_PATH" }, { status: 400 });
+          }
+          if (content === null) {
+            return json({ error: "content is required", code: "MISSING_CONTENT" }, { status: 400 });
+          }
+          const path2 = validatePath(rawPath, "Path parameter");
+          const encoded = new TextEncoder().encode(content);
+          if (encoded.byteLength > MAX_TEXT_SIZE$1) {
+            return json(
+              { error: "Content too large (max 5MB)", code: "CONTENT_TOO_LARGE" },
+              { status: 413 }
+            );
+          }
+          await uploadFile(path2, encoded.buffer);
+          return json({
+            ok: true,
+            message: "File saved successfully",
+            path: path2,
+            size: encoded.byteLength
+          });
+        } catch (err) {
+          const error = err;
+          const status = error.status || 500;
+          const code = error.code || "INTERNAL_ERROR";
+          return json(
+            { error: error.message || "An unexpected error occurred", code },
+            { status }
+          );
+        }
+      }
+    }
+  }
+});
+const Route$6 = createFileRoute("/api/files/rename")({
+  server: {
+    handlers: {
+      POST: async ({ request }) => {
+        try {
+          const body = await request.json().catch(() => ({}));
+          const rawSrc = typeof body.src === "string" ? body.src.trim() : "";
+          const rawDst = typeof body.dst === "string" ? body.dst.trim() : "";
+          if (!rawSrc) {
+            return json(
+              {
+                error: "src path is required",
+                code: "MISSING_SRC_PATH"
+              },
+              { status: 400 }
+            );
+          }
+          if (!rawDst) {
+            return json(
+              {
+                error: "dst path is required",
+                code: "MISSING_DST_PATH"
+              },
+              { status: 400 }
+            );
+          }
+          const src = validatePath(rawSrc, "Source path");
+          const dst = validatePath(rawDst, "Destination path");
+          if (src === "/" || src === "") {
+            return json(
+              {
+                error: "Cannot rename the root directory",
+                code: "FORBIDDEN_RENAME_ROOT"
+              },
+              { status: 403 }
+            );
+          }
+          const dstFilename = dst.split("/").pop() || "";
+          if (dstFilename && !validateFilename(dstFilename)) {
+            return json(
+              {
+                error: `Invalid destination filename: "${dstFilename}". Filenames cannot contain path separators or control characters`,
+                code: "INVALID_FILENAME"
+              },
+              { status: 400 }
+            );
+          }
+          let overwriteWarning = false;
+          try {
+            await getFileInfo(dst);
+            overwriteWarning = true;
+          } catch (err) {
+          }
+          const url = new URL(request.url);
+          const allowOverwrite = url.searchParams.get("override") === "true";
+          if (overwriteWarning && !allowOverwrite) {
+            return json(
+              {
+                error: `Destination "${dst}" already exists. Use ?override=true to overwrite`,
+                code: "DESTINATION_EXISTS"
+              },
+              { status: 409 }
+              // Conflict
+            );
+          }
+          await renameFile(src, dst);
+          return json({
+            ok: true,
+            message: overwriteWarning ? "File renamed successfully (existing file overwritten)" : "File renamed successfully",
+            src,
+            dst
+          });
+        } catch (err) {
+          const error = err;
+          if (error.message.includes("invalid characters") || error.message.includes("traversal attempts") || error.message.includes("Invalid destination") || error.message.includes("Cannot rename") || error.message.includes("already exists")) {
+            return json(
+              {
+                error: error.message,
+                code: "VALIDATION_ERROR"
+              },
+              { status: 400 }
+            );
+          }
+          const status = error.status || 500;
+          const code = error.code || "INTERNAL_ERROR";
+          return json(
+            {
+              error: error.message || "An unexpected error occurred",
+              code
+            },
+            { status }
+          );
+        }
+      }
+    }
+  }
+});
+const MAX_TEXT_SIZE = 5 * 1024 * 1024;
+const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  "txt",
+  "md",
+  "log",
+  "json",
+  "xml",
+  "yaml",
+  "yml",
+  "csv",
+  "ini",
+  "conf",
+  "cfg",
+  "js",
+  "ts",
+  "jsx",
+  "tsx",
+  "py",
+  "java",
+  "cpp",
+  "c",
+  "h",
+  "css",
+  "html",
+  "htm",
+  "php",
+  "rb",
+  "go",
+  "rs",
+  "sh",
+  "bash",
+  "zsh",
+  "toml",
+  "env",
+  "gitignore",
+  "dockerfile",
+  "makefile",
+  "sql",
+  "graphql",
+  "svelte",
+  "vue",
+  "scss",
+  "less",
+  "diff",
+  "patch"
+]);
+const Route$5 = createFileRoute("/api/files/read")({
+  server: {
+    handlers: {
+      GET: async ({ request }) => {
+        try {
+          const url = new URL(request.url);
+          const rawPath = url.searchParams.get("path");
+          if (!rawPath) {
+            return new Response(
+              JSON.stringify({ error: "path parameter is required", code: "MISSING_PATH" }),
+              { status: 400, headers: { "Content-Type": "application/json" } }
+            );
+          }
+          const path2 = validatePath(rawPath, "Path parameter");
+          const fileInfo = await getFileInfo(path2);
+          if (fileInfo.isDir) {
+            return new Response(
+              JSON.stringify({ error: "Cannot read a directory", code: "IS_DIRECTORY" }),
+              { status: 400, headers: { "Content-Type": "application/json" } }
+            );
+          }
+          const ext = fileInfo.extension.toLowerCase();
+          if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
+            return new Response(
+              JSON.stringify({ error: "File type not supported for text editing", code: "UNSUPPORTED_TYPE" }),
+              { status: 400, headers: { "Content-Type": "application/json" } }
+            );
+          }
+          if (fileInfo.size > MAX_TEXT_SIZE) {
+            return new Response(
+              JSON.stringify({ error: "File too large for text editing (max 5MB)", code: "FILE_TOO_LARGE" }),
+              { status: 413, headers: { "Content-Type": "application/json" } }
+            );
+          }
+          const content = await downloadFile(path2);
+          const text = new TextDecoder("utf-8", { fatal: false }).decode(new Uint8Array(content));
+          return new Response(
+            JSON.stringify({ content: text, name: fileInfo.name, extension: fileInfo.extension, size: fileInfo.size }),
+            { headers: { "Content-Type": "application/json" } }
+          );
+        } catch (err) {
+          const error = err;
+          const status = error.status || 500;
+          const code = error.code || "INTERNAL_ERROR";
+          return new Response(
+            JSON.stringify({ error: error.message || "An unexpected error occurred", code }),
+            { status, headers: { "Content-Type": "application/json" } }
+          );
+        }
+      }
+    }
+  }
+});
+function validateFolderName(path2) {
+  const folderName = path2.split("/").pop() || "";
+  if (!folderName) {
+    throw new Error("Folder name cannot be empty");
+  }
+  const invalidChars = /[<>:"|*?]/;
+  if (invalidChars.test(folderName)) {
+    throw new Error(`Folder name contains invalid characters: ${folderName}`);
+  }
+  const systemPaths = [
+    "bin",
+    "boot",
+    "dev",
+    "etc",
+    "lib",
+    "lib64",
+    "mnt",
+    "opt",
+    "proc",
+    "root",
+    "run",
+    "sbin",
+    "srv",
+    "sys",
+    "tmp",
+    "usr",
+    "var",
+    "System",
+    "Windows",
+    "Program Files",
+    "Program Files (x86)"
+  ];
+  if (systemPaths.includes(folderName)) {
+    throw new Error(`Cannot create system directory: ${folderName}`);
+  }
+  if (folderName.trim() === "" || /^\.+$/.test(folderName)) {
+    throw new Error("Invalid folder name");
+  }
+}
+const Route$4 = createFileRoute("/api/files/mkdir")({
+  server: {
+    handlers: {
+      POST: async ({ request }) => {
+        try {
+          const body = await request.json().catch(() => ({}));
+          const rawPath = typeof body.path === "string" ? body.path.trim() : "";
+          if (!rawPath) {
+            return json(
+              {
+                error: "path is required",
+                code: "MISSING_PATH"
+              },
+              { status: 400 }
+            );
+          }
+          const path2 = validatePath(rawPath, "Path parameter");
+          validateFolderName(path2);
+          await createFolder(path2);
+          return json({
+            ok: true,
+            message: "Directory created successfully",
+            path: path2
+          });
+        } catch (err) {
+          const error = err;
+          if (error.message.includes("invalid characters") || error.message.includes("traversal attempts") || error.message.includes("Invalid folder") || error.message.includes("Cannot create system") || error.message.includes("Folder name")) {
+            return json(
+              {
+                error: error.message,
+                code: "VALIDATION_ERROR"
+              },
+              { status: 400 }
+            );
+          }
+          const status = error.status || 500;
+          const code = error.code || "INTERNAL_ERROR";
+          return json(
+            {
+              error: error.message || "An unexpected error occurred",
+              code
+            },
+            { status }
+          );
+        }
+      }
+    }
+  }
+});
+const Route$3 = createFileRoute("/api/files/list")({
+  server: {
+    handlers: {
+      GET: async ({ request }) => {
+        try {
+          const url = new URL(request.url);
+          const rawPath = url.searchParams.get("path") || "/";
+          const path2 = validatePath(rawPath, "Path parameter");
+          const listing = await listFiles(path2);
+          return json(listing);
+        } catch (err) {
+          const error = err;
+          if (error.message.includes("invalid characters") || error.message.includes("traversal attempts")) {
+            return json(
+              {
+                error: error.message,
+                code: "INVALID_PATH"
+              },
+              { status: 400 }
+            );
+          }
+          const status = error.status || 500;
+          const code = error.code || "INTERNAL_ERROR";
+          return json(
+            {
+              error: error.message || "An unexpected error occurred",
+              code
+            },
+            { status }
+          );
+        }
+      }
+    }
+  }
+});
+const Route$2 = createFileRoute("/api/files/info")({
+  server: {
+    handlers: {
+      GET: async ({ request }) => {
+        try {
+          const url = new URL(request.url);
+          const rawPath = url.searchParams.get("path");
+          if (!rawPath) {
+            return json(
+              {
+                error: "path parameter is required",
+                code: "MISSING_PATH"
+              },
+              { status: 400 }
+            );
+          }
+          const path2 = validatePath(rawPath, "Path parameter");
+          const fileInfo = await getFileInfo(path2);
+          return json(fileInfo);
+        } catch (err) {
+          const error = err;
+          if (error.message.includes("invalid characters") || error.message.includes("traversal attempts")) {
+            return json(
+              {
+                error: error.message,
+                code: "INVALID_PATH"
+              },
+              { status: 400 }
+            );
+          }
+          const status = error.status || 500;
+          const code = error.code || "INTERNAL_ERROR";
+          return json(
+            {
+              error: error.message || "An unexpected error occurred",
+              code
+            },
+            { status }
+          );
+        }
+      }
+    }
+  }
+});
+function getContentType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() || "";
+  const mimeTypes = {
+    // Text files
+    "txt": "text/plain",
+    "md": "text/markdown",
+    "html": "text/html",
+    "css": "text/css",
+    "js": "text/javascript",
+    "json": "application/json",
+    "xml": "application/xml",
+    "csv": "text/csv",
+    "yaml": "application/x-yaml",
+    "yml": "application/x-yaml",
+    // Programming languages
+    "ts": "application/typescript",
+    "tsx": "application/typescript",
+    "py": "text/x-python",
+    // Images
+    "png": "image/png",
+    "jpg": "image/jpeg",
+    "jpeg": "image/jpeg",
+    "gif": "image/gif",
+    "webp": "image/webp",
+    "svg": "image/svg+xml",
+    // Audio/Video
+    "mp3": "audio/mpeg",
+    "mp4": "video/mp4",
+    // Documents
+    "pdf": "application/pdf",
+    "doc": "application/msword",
+    "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "xls": "application/vnd.ms-excel",
+    "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "ppt": "application/vnd.ms-powerpoint",
+    "pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    // Archives
+    "zip": "application/zip",
+    "tar.gz": "application/gzip",
+    "gz": "application/gzip",
+    // Fonts
+    "woff": "font/woff",
+    "woff2": "font/woff2",
+    "ttf": "font/ttf",
+    "otf": "font/otf"
+  };
+  return mimeTypes[ext] || "application/octet-stream";
+}
+function encodeFilename(filename) {
+  const encodedFilename = encodeURIComponent(filename);
+  return `filename*=UTF-8''${encodedFilename}`;
+}
+function isStaticAsset(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() || "";
+  const staticExts = ["png", "jpg", "jpeg", "gif", "webp", "svg", "css", "js", "woff", "woff2", "ttf", "otf"];
+  return staticExts.includes(ext);
+}
+const Route$1 = createFileRoute("/api/files/download")({
+  server: {
+    handlers: {
+      GET: async ({ request }) => {
+        try {
+          const url = new URL(request.url);
+          const rawPath = url.searchParams.get("path");
+          if (!rawPath) {
+            return new Response(
+              JSON.stringify({
+                error: "path parameter is required",
+                code: "MISSING_PATH"
+              }),
+              {
+                status: 400,
+                headers: { "Content-Type": "application/json" }
+              }
+            );
+          }
+          const path2 = validatePath(rawPath, "Path parameter");
+          const fileInfo = await getFileInfo(path2);
+          const content = await downloadFile(path2);
+          const contentType = getContentType(fileInfo.name);
+          const contentDisposition = `attachment; ${encodeFilename(fileInfo.name)}`;
+          const headers = {
+            "Content-Type": contentType,
+            "Content-Disposition": contentDisposition,
+            "Content-Length": content.byteLength.toString()
+          };
+          if (isStaticAsset(fileInfo.name)) {
+            headers["Cache-Control"] = "public, max-age=31536000";
+          } else {
+            headers["Cache-Control"] = "no-cache";
+          }
+          return new Response(content, { headers });
+        } catch (err) {
+          const error = err;
+          if (error.message.includes("invalid characters") || error.message.includes("traversal attempts")) {
+            return new Response(
+              JSON.stringify({
+                error: error.message,
+                code: "INVALID_PATH"
+              }),
+              {
+                status: 400,
+                headers: { "Content-Type": "application/json" }
+              }
+            );
+          }
+          const status = error.status || 500;
+          const code = error.code || "INTERNAL_ERROR";
+          return new Response(
+            JSON.stringify({
+              error: error.message || "An unexpected error occurred",
+              code
+            }),
+            {
+              status,
+              headers: { "Content-Type": "application/json" }
+            }
+          );
+        }
+      }
+    }
+  }
+});
+const Route = createFileRoute("/api/files/delete")({
+  server: {
+    handlers: {
+      DELETE: async ({ request }) => {
+        try {
+          const url = new URL(request.url);
+          const rawPath = url.searchParams.get("path");
+          if (!rawPath) {
+            return json(
+              {
+                error: "path parameter is required",
+                code: "MISSING_PATH"
+              },
+              { status: 400 }
+            );
+          }
+          const path2 = validatePath(rawPath, "Path parameter");
+          if (path2 === "/" || path2 === "") {
+            return json(
+              {
+                error: "Cannot delete the root directory",
+                code: "FORBIDDEN_DELETE_ROOT"
+              },
+              { status: 403 }
+              // Forbidden
+            );
+          }
+          await deleteFile(path2);
+          return json({
+            ok: true,
+            message: "File deleted successfully",
+            path: path2
+          });
+        } catch (err) {
+          const error = err;
+          if (error.message.includes("invalid characters") || error.message.includes("traversal attempts") || error.message.includes("Cannot delete")) {
+            return json(
+              {
+                error: error.message,
+                code: "VALIDATION_ERROR"
+              },
+              { status: 400 }
+            );
+          }
+          const status = error.status || 500;
+          const code = error.code || "INTERNAL_ERROR";
+          return json(
+            {
+              error: error.message || "An unexpected error occurred",
+              code
+            },
+            { status }
+          );
+        }
+      }
+    }
+  }
+});
+const NewRoute = Route$o.update({
+  id: "/new",
+  path: "/new",
+  getParentRoute: () => Route$p
+});
+const FilesRoute = Route$n.update({
+  id: "/files",
+  path: "/files",
+  getParentRoute: () => Route$p
+});
+const ConnectRoute = Route$m.update({
+  id: "/connect",
+  path: "/connect",
+  getParentRoute: () => Route$p
+});
+const IndexRoute = Route$l.update({
+  id: "/",
+  path: "/",
+  getParentRoute: () => Route$p
+});
+const ChatSessionKeyRoute = Route$k.update({
+  id: "/chat/$sessionKey",
+  path: "/chat/$sessionKey",
+  getParentRoute: () => Route$p
+});
+const ApiTtsRoute = Route$j.update({
+  id: "/api/tts",
+  path: "/api/tts",
+  getParentRoute: () => Route$p
+});
+const ApiStreamRoute = Route$i.update({
+  id: "/api/stream",
+  path: "/api/stream",
+  getParentRoute: () => Route$p
+});
+const ApiSessionsRoute = Route$h.update({
+  id: "/api/sessions",
+  path: "/api/sessions",
+  getParentRoute: () => Route$p
+});
+const ApiSendRoute = Route$g.update({
+  id: "/api/send",
+  path: "/api/send",
+  getParentRoute: () => Route$p
+});
+const ApiPingRoute = Route$f.update({
+  id: "/api/ping",
+  path: "/api/ping",
+  getParentRoute: () => Route$p
+});
+const ApiPersonasRoute = Route$e.update({
+  id: "/api/personas",
+  path: "/api/personas",
+  getParentRoute: () => Route$p
+});
+const ApiPathsRoute = Route$d.update({
+  id: "/api/paths",
+  path: "/api/paths",
+  getParentRoute: () => Route$p
+});
+const ApiModelsRoute = Route$c.update({
+  id: "/api/models",
+  path: "/api/models",
+  getParentRoute: () => Route$p
+});
+const ApiLlmFeaturesRoute = Route$b.update({
+  id: "/api/llm-features",
+  path: "/api/llm-features",
+  getParentRoute: () => Route$p
+});
+const ApiHistoryRoute = Route$a.update({
+  id: "/api/history",
+  path: "/api/history",
+  getParentRoute: () => Route$p
+});
+const ApiFollowUpsRoute = Route$9.update({
+  id: "/api/follow-ups",
+  path: "/api/follow-ups",
+  getParentRoute: () => Route$p
+});
+const ApiFilesUploadRoute = Route$8.update({
+  id: "/api/files/upload",
+  path: "/api/files/upload",
+  getParentRoute: () => Route$p
+});
+const ApiFilesSaveRoute = Route$7.update({
+  id: "/api/files/save",
+  path: "/api/files/save",
+  getParentRoute: () => Route$p
+});
+const ApiFilesRenameRoute = Route$6.update({
+  id: "/api/files/rename",
+  path: "/api/files/rename",
+  getParentRoute: () => Route$p
+});
+const ApiFilesReadRoute = Route$5.update({
+  id: "/api/files/read",
+  path: "/api/files/read",
+  getParentRoute: () => Route$p
+});
+const ApiFilesMkdirRoute = Route$4.update({
+  id: "/api/files/mkdir",
+  path: "/api/files/mkdir",
+  getParentRoute: () => Route$p
+});
+const ApiFilesListRoute = Route$3.update({
+  id: "/api/files/list",
+  path: "/api/files/list",
+  getParentRoute: () => Route$p
+});
+const ApiFilesInfoRoute = Route$2.update({
+  id: "/api/files/info",
+  path: "/api/files/info",
+  getParentRoute: () => Route$p
+});
+const ApiFilesDownloadRoute = Route$1.update({
+  id: "/api/files/download",
+  path: "/api/files/download",
+  getParentRoute: () => Route$p
+});
+const ApiFilesDeleteRoute = Route.update({
+  id: "/api/files/delete",
+  path: "/api/files/delete",
+  getParentRoute: () => Route$p
+});
+const rootRouteChildren = {
+  IndexRoute,
+  ConnectRoute,
+  FilesRoute,
+  NewRoute,
+  ApiFollowUpsRoute,
+  ApiHistoryRoute,
+  ApiLlmFeaturesRoute,
+  ApiModelsRoute,
+  ApiPathsRoute,
+  ApiPersonasRoute,
+  ApiPingRoute,
+  ApiSendRoute,
+  ApiSessionsRoute,
+  ApiStreamRoute,
+  ApiTtsRoute,
+  ChatSessionKeyRoute,
+  ApiFilesDeleteRoute,
+  ApiFilesDownloadRoute,
+  ApiFilesInfoRoute,
+  ApiFilesListRoute,
+  ApiFilesMkdirRoute,
+  ApiFilesReadRoute,
+  ApiFilesRenameRoute,
+  ApiFilesSaveRoute,
+  ApiFilesUploadRoute
+};
+const routeTree = Route$p._addFileChildren(rootRouteChildren)._addFileTypes();
+const getRouter = () => {
+  const router2 = createRouter({
+    routeTree,
+    context: {},
+    scrollRestoration: true,
+    defaultPreloadStaleTime: 0
+  });
+  return router2;
+};
+const router = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getRouter
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Route$l as R,
+  Route$k as a,
+  router as r
+};