@poncho-ai/cli 0.2.0

package/dist/chunk-TWQDGVLI.js

@@ -0,0 +1,1323 @@
+// src/web-ui.ts
+import { createHash, randomUUID, timingSafeEqual } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { basename, dirname, resolve } from "path";
+import { homedir } from "os";
+var DEFAULT_OWNER = "local-owner";
+var FileConversationStore = class {
+  filePath;
+  conversations = /* @__PURE__ */ new Map();
+  loaded = false;
+  writing = Promise.resolve();
+  constructor(workingDir) {
+    const projectName = basename(workingDir).replace(/[^a-zA-Z0-9_-]+/g, "-") || "project";
+    const projectHash = createHash("sha256").update(workingDir).digest("hex").slice(0, 12);
+    this.filePath = resolve(
+      homedir(),
+      ".agentl",
+      "state",
+      `${projectName}-${projectHash}-web-ui-state.json`
+    );
+  }
+  async ensureLoaded() {
+    if (this.loaded) {
+      return;
+    }
+    this.loaded = true;
+    try {
+      const content = await readFile(this.filePath, "utf8");
+      const parsed = JSON.parse(content);
+      for (const conversation of parsed.conversations ?? []) {
+        this.conversations.set(conversation.conversationId, conversation);
+      }
+    } catch {
+    }
+  }
+  async persist() {
+    const payload = {
+      conversations: Array.from(this.conversations.values())
+    };
+    this.writing = this.writing.then(async () => {
+      await mkdir(dirname(this.filePath), { recursive: true });
+      await writeFile(this.filePath, JSON.stringify(payload, null, 2), "utf8");
+    });
+    await this.writing;
+  }
+  async list(ownerId = DEFAULT_OWNER) {
+    await this.ensureLoaded();
+    return Array.from(this.conversations.values()).filter((conversation) => conversation.ownerId === ownerId).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async get(conversationId) {
+    await this.ensureLoaded();
+    return this.conversations.get(conversationId);
+  }
+  async create(ownerId = DEFAULT_OWNER, title) {
+    await this.ensureLoaded();
+    const now = Date.now();
+    const conversation = {
+      conversationId: randomUUID(),
+      title: title && title.trim().length > 0 ? title.trim() : "New conversation",
+      messages: [],
+      ownerId,
+      tenantId: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.conversations.set(conversation.conversationId, conversation);
+    await this.persist();
+    return conversation;
+  }
+  async update(conversation) {
+    await this.ensureLoaded();
+    this.conversations.set(conversation.conversationId, {
+      ...conversation,
+      updatedAt: Date.now()
+    });
+    await this.persist();
+  }
+  async rename(conversationId, title) {
+    await this.ensureLoaded();
+    const existing = this.conversations.get(conversationId);
+    if (!existing) {
+      return void 0;
+    }
+    const updated = {
+      ...existing,
+      title: title.trim().length > 0 ? title.trim() : existing.title,
+      updatedAt: Date.now()
+    };
+    this.conversations.set(conversationId, updated);
+    await this.persist();
+    return updated;
+  }
+  async delete(conversationId) {
+    await this.ensureLoaded();
+    const removed = this.conversations.delete(conversationId);
+    if (removed) {
+      await this.persist();
+    }
+    return removed;
+  }
+};
+var SessionStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(ttlMs = 1e3 * 60 * 60 * 8) {
+    this.ttlMs = ttlMs;
+  }
+  create(ownerId = DEFAULT_OWNER) {
+    const now = Date.now();
+    const session = {
+      sessionId: randomUUID(),
+      ownerId,
+      csrfToken: randomUUID(),
+      createdAt: now,
+      expiresAt: now + this.ttlMs,
+      lastSeenAt: now
+    };
+    this.sessions.set(session.sessionId, session);
+    return session;
+  }
+  get(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return void 0;
+    }
+    if (Date.now() > session.expiresAt) {
+      this.sessions.delete(sessionId);
+      return void 0;
+    }
+    session.lastSeenAt = Date.now();
+    return session;
+  }
+  delete(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+};
+var LoginRateLimiter = class {
+  constructor(maxAttempts = 5, windowMs = 1e3 * 60 * 5, lockoutMs = 1e3 * 60 * 10) {
+    this.maxAttempts = maxAttempts;
+    this.windowMs = windowMs;
+    this.lockoutMs = lockoutMs;
+  }
+  attempts = /* @__PURE__ */ new Map();
+  canAttempt(key) {
+    const current = this.attempts.get(key);
+    if (!current) {
+      return { allowed: true };
+    }
+    if (current.lockedUntil && Date.now() < current.lockedUntil) {
+      return {
+        allowed: false,
+        retryAfterSeconds: Math.ceil((current.lockedUntil - Date.now()) / 1e3)
+      };
+    }
+    return { allowed: true };
+  }
+  registerFailure(key) {
+    const now = Date.now();
+    const current = this.attempts.get(key);
+    if (!current || now - current.firstFailureAt > this.windowMs) {
+      this.attempts.set(key, { count: 1, firstFailureAt: now });
+      return { locked: false };
+    }
+    const count = current.count + 1;
+    const next = {
+      ...current,
+      count
+    };
+    if (count >= this.maxAttempts) {
+      next.lockedUntil = now + this.lockoutMs;
+      this.attempts.set(key, next);
+      return { locked: true, retryAfterSeconds: Math.ceil(this.lockoutMs / 1e3) };
+    }
+    this.attempts.set(key, next);
+    return { locked: false };
+  }
+  registerSuccess(key) {
+    this.attempts.delete(key);
+  }
+};
+var parseCookies = (request) => {
+  const cookieHeader = request.headers.cookie ?? "";
+  const pairs = cookieHeader.split(";").map((part) => part.trim()).filter(Boolean);
+  const cookies = {};
+  for (const pair of pairs) {
+    const index = pair.indexOf("=");
+    if (index <= 0) {
+      continue;
+    }
+    const key = pair.slice(0, index);
+    const value = pair.slice(index + 1);
+    try {
+      cookies[key] = decodeURIComponent(value);
+    } catch {
+      cookies[key] = value;
+    }
+  }
+  return cookies;
+};
+var setCookie = (response, name, value, options) => {
+  const segments = [`${name}=${encodeURIComponent(value)}`];
+  segments.push(`Path=${options.path ?? "/"}`);
+  if (typeof options.maxAge === "number") {
+    segments.push(`Max-Age=${Math.max(0, Math.floor(options.maxAge))}`);
+  }
+  if (options.httpOnly) {
+    segments.push("HttpOnly");
+  }
+  if (options.secure) {
+    segments.push("Secure");
+  }
+  if (options.sameSite) {
+    segments.push(`SameSite=${options.sameSite}`);
+  }
+  const previous = response.getHeader("Set-Cookie");
+  const serialized = segments.join("; ");
+  if (!previous) {
+    response.setHeader("Set-Cookie", serialized);
+    return;
+  }
+  if (Array.isArray(previous)) {
+    response.setHeader("Set-Cookie", [...previous, serialized]);
+    return;
+  }
+  response.setHeader("Set-Cookie", [String(previous), serialized]);
+};
+var verifyPassphrase = (provided, expected) => {
+  const providedBuffer = Buffer.from(provided);
+  const expectedBuffer = Buffer.from(expected);
+  if (providedBuffer.length !== expectedBuffer.length) {
+    const zero = Buffer.alloc(expectedBuffer.length);
+    return timingSafeEqual(expectedBuffer, zero) && false;
+  }
+  return timingSafeEqual(providedBuffer, expectedBuffer);
+};
+var getRequestIp = (request) => {
+  return request.socket.remoteAddress ?? "unknown";
+};
+var inferConversationTitle = (text) => {
+  const normalized = text.trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    return "New conversation";
+  }
+  return normalized.length <= 48 ? normalized : `${normalized.slice(0, 48)}...`;
+};
+var renderWebUiHtml = () => `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>AgentL Web UI</title>
+    <style>
+      :root {
+        color-scheme: dark;
+        --bg-main: #212121;
+        --bg-sidebar: #171717;
+        --bg-hover: #2f2f2f;
+        --bg-soft: rgba(255, 255, 255, 0.05);
+        --text-main: #eeeeee;
+        --text-muted: #b4b4b4;
+        --text-subtle: #cdcdcd;
+        --danger: #cc5d62;
+      }
+      * { box-sizing: border-box; }
+      html, body { margin: 0; padding: 0; height: 100%; }
+      body {
+        font-family: "Soehne", "Inter", system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+        background: var(--bg-main);
+        color: var(--text-main);
+      }
+      button, input, textarea { font: inherit; }
+      .hidden { display: none !important; }
+
+      .auth {
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+        padding: 20px;
+        background: var(--bg-main);
+      }
+      .auth-shell {
+        width: min(420px, 95vw);
+        display: grid;
+        gap: 14px;
+        justify-items: center;
+      }
+      .auth-avatar {
+        width: 52px;
+        height: 52px;
+        border-radius: 50%;
+        background: rgba(255, 255, 255, 0.06);
+        border: 1px solid rgba(255, 255, 255, 0.12);
+        display: grid;
+        place-items: center;
+        color: var(--text-main);
+        font-weight: 700;
+      }
+      .auth-card {
+        width: 100%;
+        border-radius: 16px;
+        background: #1f1f1f;
+        padding: 22px;
+        display: grid;
+        gap: 12px;
+        box-shadow: 0 16px 48px rgba(0, 0, 0, 0.32);
+      }
+      .auth-title { margin: 0; font-size: 21px; font-weight: 600; }
+      .auth-text { margin: 0; color: var(--text-muted); font-size: 13px; line-height: 1.4; }
+      .auth-input {
+        width: 100%;
+        border: 0;
+        border-radius: 12px;
+        background: var(--bg-soft);
+        color: var(--text-main);
+        padding: 12px 14px;
+        outline: none;
+      }
+      .auth-input:focus { background: rgba(255, 255, 255, 0.08); }
+      .auth-submit {
+        border: 0;
+        border-radius: 24px;
+        background: #ffffff;
+        color: #111111;
+        padding: 10px 16px;
+        font-weight: 600;
+        cursor: pointer;
+        transition: opacity 150ms ease, transform 150ms ease;
+      }
+      .auth-submit:hover { opacity: 0.94; transform: translateY(-1px); }
+      .error { color: #ff9ea4; font-size: 12px; min-height: 16px; }
+
+      .shell { min-height: 100vh; display: flex; background: var(--bg-main); }
+      .sidebar {
+        width: 260px;
+        background: var(--bg-sidebar);
+        display: flex;
+        flex-direction: column;
+        gap: 12px;
+        padding: 14px 10px;
+        position: relative;
+        z-index: 30;
+      }
+      .sidebar-header {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+      }
+      .icon-btn, .menu-btn {
+        border: 0;
+        background: transparent;
+        color: var(--text-muted);
+        width: 34px;
+        height: 34px;
+        border-radius: 10px;
+        cursor: pointer;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        transition: background 150ms ease, color 150ms ease;
+      }
+      .icon-btn:hover, .menu-btn:hover { background: var(--bg-hover); color: var(--text-main); }
+      .new-chat-btn {
+        border: 0;
+        background: transparent;
+        color: var(--text-main);
+        border-radius: 12px;
+        height: 36px;
+        padding: 0 10px;
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+        cursor: pointer;
+        transition: background 150ms ease;
+      }
+      .new-chat-btn:hover { background: var(--bg-hover); }
+      .conversation-list {
+        flex: 1;
+        min-height: 0;
+        overflow: auto;
+        display: flex;
+        flex-direction: column;
+        gap: 2px;
+        padding-right: 2px;
+      }
+      .conversation-empty {
+        color: var(--text-muted);
+        font-size: 13px;
+        padding: 10px;
+      }
+      .conversation-item {
+        position: relative;
+        border-radius: 8px;
+        padding: 8px 8px 8px 10px;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        transition: background 150ms ease;
+      }
+      .conversation-item:hover,
+      .conversation-item.active {
+        background: var(--bg-hover);
+      }
+      .conversation-label-wrap {
+        flex: 1;
+        min-width: 0;
+      }
+      .conversation-title {
+        font-size: 13px;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+      .conversation-meta {
+        margin-top: 2px;
+        font-size: 11px;
+        color: var(--text-muted);
+      }
+      .conversation-item .menu-btn {
+        opacity: 0;
+      }
+      .conversation-item:hover .menu-btn,
+      .conversation-item.menu-open .menu-btn {
+        opacity: 1;
+      }
+      .conversation-menu {
+        position: absolute;
+        top: 36px;
+        right: 8px;
+        width: 140px;
+        border-radius: 12px;
+        background: #2a2a2a;
+        box-shadow: 0 4px 16px rgba(0, 0, 0, 0.34);
+        overflow: hidden;
+        z-index: 20;
+      }
+      .conversation-menu button {
+        width: 100%;
+        border: 0;
+        background: transparent;
+        color: var(--text-main);
+        text-align: left;
+        padding: 9px 10px;
+        cursor: pointer;
+        transition: background 150ms ease;
+      }
+      .conversation-menu button:hover { background: #3a3a3a; }
+      .conversation-menu button.danger { color: var(--danger); }
+      .sidebar-footer {
+        padding-top: 8px;
+      }
+      .logout-btn {
+        border: 0;
+        background: transparent;
+        color: var(--text-muted);
+        border-radius: 10px;
+        width: 100%;
+        height: 36px;
+        text-align: left;
+        padding: 0 10px;
+        cursor: pointer;
+        transition: background 150ms ease, color 150ms ease;
+      }
+      .logout-btn:hover { background: var(--bg-hover); color: var(--text-main); }
+
+      .main {
+        min-width: 0;
+        flex: 1;
+        display: grid;
+        grid-template-rows: auto 1fr auto;
+      }
+      .topbar {
+        height: 56px;
+        display: grid;
+        grid-template-columns: auto 1fr auto;
+        align-items: center;
+        padding: 0 14px;
+      }
+      .topbar-title {
+        justify-self: center;
+        color: var(--text-subtle);
+        font-size: 14px;
+        max-width: 620px;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+      .topbar-spacer { width: 34px; height: 34px; }
+      .sidebar-toggle { display: none; }
+      .typing-indicator {
+        display: inline-flex;
+        gap: 4px;
+        align-items: center;
+        justify-content: center;
+        width: 26px;
+        height: 18px;
+      }
+      .typing-indicator span {
+        width: 4px;
+        height: 4px;
+        border-radius: 50%;
+        background: var(--text-muted);
+        animation: pulse 1s infinite ease-in-out;
+      }
+      .typing-indicator span:nth-child(2) { animation-delay: 0.12s; }
+      .typing-indicator span:nth-child(3) { animation-delay: 0.24s; }
+      @keyframes pulse {
+        0%, 80%, 100% { opacity: 0.2; transform: scale(0.8); }
+        40% { opacity: 1; transform: scale(1); }
+      }
+
+      .messages {
+        min-height: 0;
+        overflow: auto;
+        padding: 12px 20px 0;
+      }
+      .messages-column {
+        max-width: 768px;
+        margin: 0 auto;
+        width: 100%;
+        display: flex;
+        flex-direction: column;
+        gap: 20px;
+        padding-bottom: 22px;
+      }
+      .message-row {
+        display: flex;
+        width: 100%;
+      }
+      .message-row.user { justify-content: flex-end; }
+      .message-row.assistant { justify-content: flex-start; }
+      .assistant-wrap {
+        display: grid;
+        grid-template-columns: 32px minmax(0, 1fr);
+        gap: 12px;
+        width: 100%;
+      }
+      .assistant-avatar {
+        width: 32px;
+        height: 32px;
+        border-radius: 50%;
+        background: rgba(255, 255, 255, 0.06);
+        border: 1px solid rgba(255, 255, 255, 0.15);
+        color: var(--text-main);
+        display: grid;
+        place-items: center;
+        font-size: 12px;
+        font-weight: 700;
+      }
+      .assistant-content {
+        color: var(--text-main);
+        line-height: 1.6;
+        word-break: break-word;
+      }
+      .assistant-content p {
+        margin: 0;
+      }
+      .assistant-content p + p {
+        margin-top: 12px;
+      }
+      .assistant-content ul {
+        margin: 10px 0 0;
+        padding-left: 18px;
+      }
+      .assistant-content li + li {
+        margin-top: 4px;
+      }
+      .assistant-content code {
+        background: rgba(255, 255, 255, 0.08);
+        border-radius: 6px;
+        padding: 1px 6px;
+        font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+        font-size: 0.92em;
+      }
+      .assistant-content pre {
+        margin: 10px 0 0;
+        border-radius: 12px;
+        background: rgba(255, 255, 255, 0.05);
+        padding: 12px;
+        overflow: auto;
+      }
+      .assistant-content pre code {
+        background: transparent;
+        border-radius: 0;
+        padding: 0;
+        font-size: 12px;
+        line-height: 1.5;
+      }
+      .user-bubble {
+        max-width: min(80%, 720px);
+        border-radius: 20px;
+        background: var(--bg-soft);
+        padding: 10px 14px;
+        line-height: 1.5;
+        white-space: pre-wrap;
+        word-break: break-word;
+      }
+      .empty-state {
+        min-height: min(56vh, 520px);
+        display: grid;
+        place-items: center;
+        text-align: center;
+      }
+      .empty-state-inner {
+        display: grid;
+        gap: 12px;
+        justify-items: center;
+      }
+      .empty-state-title {
+        margin: 0;
+        font-size: clamp(26px, 3.6vw, 36px);
+        font-weight: 600;
+        color: var(--text-main);
+      }
+
+      .composer {
+        padding: 0 16px 10px;
+      }
+      .composer-inner {
+        max-width: 768px;
+        margin: 0 auto;
+      }
+      .composer-shell {
+        border-radius: 24px;
+        background: var(--bg-soft);
+        display: flex;
+        align-items: flex-end;
+        gap: 10px;
+        padding: 8px 8px 8px 12px;
+        transition: background 150ms ease;
+      }
+      .composer-shell:focus-within { background: rgba(255, 255, 255, 0.08); }
+      .composer-input {
+        border: 0;
+        outline: none;
+        background: transparent;
+        color: var(--text-main);
+        width: 100%;
+        min-height: 40px;
+        max-height: 200px;
+        resize: none;
+        line-height: 1.45;
+        padding: 9px 2px 8px;
+      }
+      .composer-input::placeholder { color: var(--text-muted); }
+      .send-btn {
+        border: 0;
+        width: 32px;
+        height: 32px;
+        border-radius: 50%;
+        background: #ffffff;
+        color: #111111;
+        font-size: 18px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        cursor: pointer;
+        transition: opacity 150ms ease, transform 150ms ease;
+      }
+      .send-btn:disabled {
+        opacity: 0.3;
+        cursor: default;
+        transform: none;
+      }
+      .send-btn:not(:disabled):hover { opacity: 0.94; transform: translateY(-1px); }
+      .disclaimer {
+        text-align: center;
+        color: var(--text-subtle);
+        font-size: 12px;
+        margin-top: 10px;
+      }
+
+      ::-webkit-scrollbar { width: 10px; height: 10px; }
+      ::-webkit-scrollbar-track { background: transparent; }
+      ::-webkit-scrollbar-thumb {
+        background: #4a4a4a;
+        border-radius: 4px;
+        border: 2px solid transparent;
+        background-clip: padding-box;
+      }
+      ::-webkit-scrollbar-thumb:hover { background: #5d5d5d; }
+
+      .sidebar-backdrop {
+        display: none;
+      }
+
+      @media (max-width: 900px) {
+        .shell { position: relative; }
+        .sidebar {
+          position: fixed;
+          inset: 0 auto 0 0;
+          transform: translateX(-100%);
+          transition: transform 180ms ease;
+          box-shadow: 12px 0 40px rgba(0, 0, 0, 0.45);
+        }
+        .shell.sidebar-open .sidebar { transform: translateX(0); }
+        .sidebar-toggle { display: inline-flex; }
+        .topbar-spacer { display: none; }
+        .sidebar-backdrop {
+          display: block;
+          position: fixed;
+          inset: 0;
+          background: rgba(0, 0, 0, 0.35);
+          z-index: 15;
+        }
+        .shell:not(.sidebar-open) .sidebar-backdrop { display: none; }
+        .messages { padding: 8px 14px 0; }
+        .composer { padding: 0 12px 8px; }
+      }
+    </style>
+  </head>
+  <body>
+    <div id="auth" class="auth hidden">
+      <div class="auth-shell">
+        <div class="auth-avatar">A</div>
+        <form id="login-form" class="auth-card">
+          <h2 class="auth-title">AgentL</h2>
+          <p class="auth-text">Enter the configured passphrase to use this workspace.</p>
+          <input id="passphrase" class="auth-input" type="password" autocomplete="current-password" placeholder="Passphrase" required />
+          <button class="auth-submit" type="submit">Sign in</button>
+          <div id="login-error" class="error"></div>
+        </form>
+      </div>
+    </div>
+
+    <div id="app" class="shell hidden">
+      <aside class="sidebar">
+        <div class="sidebar-header">
+          <button id="mobile-close" class="icon-btn hidden" type="button" aria-label="Close sidebar">\u2715</button>
+          <button id="new-chat" class="new-chat-btn" type="button" aria-label="Create new chat">\u270E New chat</button>
+        </div>
+        <div id="conversation-list" class="conversation-list"></div>
+        <div class="sidebar-footer">
+          <button id="logout" class="logout-btn" type="button">Log out</button>
+        </div>
+      </aside>
+      <div id="sidebar-backdrop" class="sidebar-backdrop hidden"></div>
+
+      <section class="main">
+        <div class="topbar">
+          <button id="sidebar-toggle" class="icon-btn sidebar-toggle" type="button" aria-label="Open sidebar">\u2630</button>
+          <div id="chat-title" class="topbar-title">AgentL</div>
+          <div class="topbar-spacer">
+            <span id="connection-status" class="typing-indicator hidden"><span></span><span></span><span></span></span>
+          </div>
+        </div>
+        <div id="messages" class="messages">
+          <div class="empty-state">
+            <div class="empty-state-inner">
+              <div class="assistant-avatar">A</div>
+              <h1 class="empty-state-title">How can I help you today?</h1>
+            </div>
+          </div>
+        </div>
+        <form id="composer" class="composer">
+          <div class="composer-inner">
+            <div class="composer-shell">
+              <textarea id="prompt" class="composer-input" placeholder="Message AgentL..." rows="1"></textarea>
+              <button id="send" class="send-btn" type="submit" aria-label="Send message">\u2191</button>
+            </div>
+            <div class="disclaimer">AgentL can make mistakes. Check important info.</div>
+          </div>
+        </form>
+      </section>
+    </div>
+
+    <script>
+      const state = {
+        csrfToken: "",
+        conversations: [],
+        activeConversationId: null,
+        isStreaming: false,
+        openMenuConversationId: null
+      };
+
+      const elements = {
+        auth: document.getElementById("auth"),
+        app: document.getElementById("app"),
+        loginForm: document.getElementById("login-form"),
+        passphrase: document.getElementById("passphrase"),
+        loginError: document.getElementById("login-error"),
+        list: document.getElementById("conversation-list"),
+        newChat: document.getElementById("new-chat"),
+        messages: document.getElementById("messages"),
+        chatTitle: document.getElementById("chat-title"),
+        logout: document.getElementById("logout"),
+        composer: document.getElementById("composer"),
+        prompt: document.getElementById("prompt"),
+        send: document.getElementById("send"),
+        connectionStatus: document.getElementById("connection-status"),
+        shell: document.getElementById("app"),
+        sidebarToggle: document.getElementById("sidebar-toggle"),
+        mobileClose: document.getElementById("mobile-close"),
+        sidebarBackdrop: document.getElementById("sidebar-backdrop")
+      };
+
+      const mutatingMethods = new Set(["POST", "PATCH", "PUT", "DELETE"]);
+
+      const api = async (path, options = {}) => {
+        const method = (options.method || "GET").toUpperCase();
+        const headers = { ...(options.headers || {}) };
+        if (mutatingMethods.has(method) && state.csrfToken) {
+          headers["x-csrf-token"] = state.csrfToken;
+        }
+        if (options.body && !headers["Content-Type"]) {
+          headers["Content-Type"] = "application/json";
+        }
+        const response = await fetch(path, { credentials: "include", ...options, method, headers });
+        if (!response.ok) {
+          let payload = {};
+          try { payload = await response.json(); } catch {}
+          const error = new Error(payload.message || ("Request failed: " + response.status));
+          error.status = response.status;
+          error.payload = payload;
+          throw error;
+        }
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+          return await response.json();
+        }
+        return await response.text();
+      };
+
+      const escapeHtml = (value) =>
+        String(value || "")
+          .replace(/&/g, "&amp;")
+          .replace(/</g, "&lt;")
+          .replace(/>/g, "&gt;")
+          .replace(/"/g, "&quot;")
+          .replace(/'/g, "&#39;");
+
+      const renderInlineMarkdown = (value) => {
+        let html = escapeHtml(value);
+        html = html.replace(/\\*\\*([^*]+)\\*\\*/g, "<strong>$1</strong>");
+        html = html.replace(/\\x60([^\\x60]+)\\x60/g, "<code>$1</code>");
+        return html;
+      };
+
+      const renderMarkdownBlock = (value) => {
+        const lines = String(value || "").split("\\n");
+        let html = "";
+        let inList = false;
+
+        for (const rawLine of lines) {
+          const line = rawLine.trimEnd();
+          if (/^\\s*-\\s+/.test(line)) {
+            if (!inList) {
+              html += "<ul>";
+              inList = true;
+            }
+            html += "<li>" + renderInlineMarkdown(line.replace(/^\\s*-\\s+/, "")) + "</li>";
+            continue;
+          }
+          if (inList) {
+            html += "</ul>";
+            inList = false;
+          }
+          if (line.trim().length === 0) {
+            continue;
+          }
+          html += "<p>" + renderInlineMarkdown(line) + "</p>";
+        }
+
+        if (inList) {
+          html += "</ul>";
+        }
+        return html;
+      };
+
+      const renderAssistantMarkdown = (value) => {
+        const source = String(value || "");
+        const fenceRegex = /\\x60\\x60\\x60([\\s\\S]*?)\\x60\\x60\\x60/g;
+        let html = "";
+        let lastIndex = 0;
+        let match;
+
+        while ((match = fenceRegex.exec(source))) {
+          const before = source.slice(lastIndex, match.index);
+          html += renderMarkdownBlock(before);
+          const codeText = String(match[1] || "").replace(/^\\n+|\\n+$/g, "");
+          html += "<pre><code>" + escapeHtml(codeText) + "</code></pre>";
+          lastIndex = match.index + match[0].length;
+        }
+
+        html += renderMarkdownBlock(source.slice(lastIndex));
+        return html || "<p></p>";
+      };
+
+      const formatDate = (epoch) => {
+        try {
+          return new Date(epoch).toLocaleDateString(undefined, { month: "short", day: "numeric" });
+        } catch {
+          return "";
+        }
+      };
+
+      const isMobile = () => window.matchMedia("(max-width: 900px)").matches;
+
+      const setSidebarOpen = (open) => {
+        if (!isMobile()) {
+          elements.shell.classList.remove("sidebar-open");
+          elements.sidebarBackdrop.classList.add("hidden");
+          elements.mobileClose.classList.add("hidden");
+          return;
+        }
+        if (open) {
+          elements.shell.classList.add("sidebar-open");
+          elements.sidebarBackdrop.classList.remove("hidden");
+        } else {
+          elements.shell.classList.remove("sidebar-open");
+          elements.sidebarBackdrop.classList.add("hidden");
+        }
+        elements.mobileClose.classList.remove("hidden");
+      };
+
+      const closeConversationMenu = () => {
+        state.openMenuConversationId = null;
+        renderConversationList();
+      };
+
+      const renderConversationList = () => {
+        elements.list.innerHTML = "";
+        if (state.conversations.length === 0) {
+          const empty = document.createElement("div");
+          empty.className = "conversation-empty";
+          empty.textContent = "No conversations yet.";
+          elements.list.appendChild(empty);
+          return;
+        }
+
+        for (const conversation of state.conversations) {
+          const item = document.createElement("div");
+          item.className =
+            "conversation-item" +
+            (conversation.conversationId === state.activeConversationId ? " active" : "") +
+            (conversation.conversationId === state.openMenuConversationId ? " menu-open" : "");
+
+          const labelWrap = document.createElement("div");
+          labelWrap.className = "conversation-label-wrap";
+          const title = document.createElement("div");
+          title.className = "conversation-title";
+          title.textContent = conversation.title;
+          const meta = document.createElement("div");
+          meta.className = "conversation-meta";
+          meta.textContent = formatDate(conversation.updatedAt);
+          labelWrap.appendChild(title);
+          labelWrap.appendChild(meta);
+
+          const menuButton = document.createElement("button");
+          menuButton.type = "button";
+          menuButton.className = "menu-btn";
+          menuButton.textContent = "\u22EF";
+          menuButton.setAttribute("aria-label", "Conversation actions");
+
+          menuButton.addEventListener("click", (event) => {
+            event.stopPropagation();
+            state.openMenuConversationId =
+              state.openMenuConversationId === conversation.conversationId ? null : conversation.conversationId;
+            renderConversationList();
+          });
+
+          item.appendChild(labelWrap);
+          item.appendChild(menuButton);
+
+          item.addEventListener("click", async () => {
+            state.activeConversationId = conversation.conversationId;
+            state.openMenuConversationId = null;
+            renderConversationList();
+            await loadConversation(conversation.conversationId);
+            if (isMobile()) {
+              setSidebarOpen(false);
+            }
+          });
+
+          if (state.openMenuConversationId === conversation.conversationId) {
+            const menu = document.createElement("div");
+            menu.className = "conversation-menu";
+
+            const rename = document.createElement("button");
+            rename.type = "button";
+            rename.textContent = "Rename";
+            rename.addEventListener("click", async (event) => {
+              event.stopPropagation();
+              const nextTitle = window.prompt("Rename conversation", conversation.title);
+              if (!nextTitle) {
+                return;
+              }
+              await api("/api/conversations/" + encodeURIComponent(conversation.conversationId), {
+                method: "PATCH",
+                body: JSON.stringify({ title: nextTitle })
+              });
+              state.openMenuConversationId = null;
+              await loadConversations();
+              if (state.activeConversationId === conversation.conversationId) {
+                await loadConversation(conversation.conversationId);
+              }
+            });
+
+            const remove = document.createElement("button");
+            remove.type = "button";
+            remove.className = "danger";
+            remove.textContent = "Delete";
+            remove.addEventListener("click", async (event) => {
+              event.stopPropagation();
+              if (!window.confirm("Delete this conversation?")) {
+                return;
+              }
+              await api("/api/conversations/" + encodeURIComponent(conversation.conversationId), {
+                method: "DELETE"
+              });
+              if (state.activeConversationId === conversation.conversationId) {
+                state.activeConversationId = null;
+                elements.chatTitle.textContent = "AgentL";
+                renderMessages([]);
+              }
+              state.openMenuConversationId = null;
+              await loadConversations();
+            });
+
+            menu.appendChild(rename);
+            menu.appendChild(remove);
+            item.appendChild(menu);
+          }
+
+          elements.list.appendChild(item);
+        }
+      };
+
+      const renderMessages = (messages) => {
+        elements.messages.innerHTML = "";
+        if (!messages || messages.length === 0) {
+          const empty = document.createElement("div");
+          empty.className = "empty-state";
+          empty.innerHTML =
+            '<div class="empty-state-inner"><div class="assistant-avatar">A</div><h1 class="empty-state-title">How can I help you today?</h1></div>';
+          elements.messages.appendChild(empty);
+          return;
+        }
+
+        const column = document.createElement("div");
+        column.className = "messages-column";
+
+        for (const message of messages) {
+          const row = document.createElement("div");
+          row.className = "message-row " + (message.role === "assistant" ? "assistant" : "user");
+
+          if (message.role === "assistant") {
+            const wrapper = document.createElement("div");
+            wrapper.className = "assistant-wrap";
+            const avatar = document.createElement("div");
+            avatar.className = "assistant-avatar";
+            avatar.textContent = "A";
+            const content = document.createElement("div");
+            content.className = "assistant-content";
+            content.innerHTML = renderAssistantMarkdown(message.content);
+            wrapper.appendChild(avatar);
+            wrapper.appendChild(content);
+            row.appendChild(wrapper);
+          } else {
+            const bubble = document.createElement("div");
+            bubble.className = "user-bubble";
+            bubble.textContent = String(message.content || "");
+            row.appendChild(bubble);
+          }
+
+          column.appendChild(row);
+        }
+
+        elements.messages.appendChild(column);
+        elements.messages.scrollTop = elements.messages.scrollHeight;
+      };
+
+      const loadConversations = async () => {
+        const payload = await api("/api/conversations");
+        state.conversations = payload.conversations || [];
+        renderConversationList();
+      };
+
+      const loadConversation = async (conversationId) => {
+        const payload = await api("/api/conversations/" + encodeURIComponent(conversationId));
+        elements.chatTitle.textContent = payload.conversation.title;
+        renderMessages(payload.conversation.messages);
+      };
+
+      const createConversation = async (title) => {
+        const payload = await api("/api/conversations", {
+          method: "POST",
+          body: JSON.stringify(title ? { title } : {})
+        });
+        state.activeConversationId = payload.conversation.conversationId;
+        state.openMenuConversationId = null;
+        await loadConversations();
+        await loadConversation(state.activeConversationId);
+        return state.activeConversationId;
+      };
+
+      const parseSseChunk = (buffer, onEvent) => {
+        let rest = buffer;
+        while (true) {
+          const index = rest.indexOf("\\n\\n");
+          if (index < 0) {
+            return rest;
+          }
+          const raw = rest.slice(0, index);
+          rest = rest.slice(index + 2);
+          const lines = raw.split("\\n");
+          let eventName = "message";
+          let data = "";
+          for (const line of lines) {
+            if (line.startsWith("event:")) {
+              eventName = line.slice(6).trim();
+            } else if (line.startsWith("data:")) {
+              data += line.slice(5).trim();
+            }
+          }
+          if (data) {
+            try {
+              onEvent(eventName, JSON.parse(data));
+            } catch {}
+          }
+        }
+      };
+
+      const setStreaming = (value) => {
+        state.isStreaming = value;
+        elements.send.disabled = value;
+        elements.connectionStatus.classList.toggle("hidden", !value);
+      };
+
+      const autoResizePrompt = () => {
+        elements.prompt.style.height = "auto";
+        const nextHeight = Math.min(elements.prompt.scrollHeight, 200);
+        elements.prompt.style.height = String(nextHeight) + "px";
+      };
+
+      const sendMessage = async (text) => {
+        const messageText = (text || "").trim();
+        if (!messageText || state.isStreaming) {
+          return;
+        }
+        let conversationId = state.activeConversationId;
+        if (!conversationId) {
+          conversationId = await createConversation(messageText);
+        }
+        const existingPayload = await api("/api/conversations/" + encodeURIComponent(conversationId));
+        const localMessages = [...(existingPayload.conversation.messages || []), { role: "user", content: messageText }];
+        let assistantMessage = { role: "assistant", content: "" };
+        localMessages.push(assistantMessage);
+        renderMessages(localMessages);
+        setStreaming(true);
+        try {
+          const response = await fetch("/api/conversations/" + encodeURIComponent(conversationId) + "/messages", {
+            method: "POST",
+            credentials: "include",
+            headers: { "Content-Type": "application/json", "x-csrf-token": state.csrfToken },
+            body: JSON.stringify({ message: messageText })
+          });
+          if (!response.ok || !response.body) {
+            throw new Error("Failed to stream response");
+          }
+          const reader = response.body.getReader();
+          const decoder = new TextDecoder();
+          let buffer = "";
+          while (true) {
+            const { value, done } = await reader.read();
+            if (done) {
+              break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            buffer = parseSseChunk(buffer, (eventName, payload) => {
+              if (eventName === "model:chunk") {
+                assistantMessage.content += String(payload.content || "");
+                renderMessages(localMessages);
+              }
+              if (eventName === "run:completed" && (!assistantMessage.content || assistantMessage.content.length === 0)) {
+                assistantMessage.content = String(payload.result?.response || "");
+                renderMessages(localMessages);
+              }
+            });
+          }
+          await loadConversations();
+          await loadConversation(conversationId);
+        } finally {
+          setStreaming(false);
+          elements.prompt.focus();
+        }
+      };
+
+      const requireAuth = async () => {
+        try {
+          const session = await api("/api/auth/session");
+          if (!session.authenticated) {
+            elements.auth.classList.remove("hidden");
+            elements.app.classList.add("hidden");
+            return false;
+          }
+          state.csrfToken = session.csrfToken || "";
+          elements.auth.classList.add("hidden");
+          elements.app.classList.remove("hidden");
+          return true;
+        } catch {
+          elements.auth.classList.remove("hidden");
+          elements.app.classList.add("hidden");
+          return false;
+        }
+      };
+
+      elements.loginForm.addEventListener("submit", async (event) => {
+        event.preventDefault();
+        elements.loginError.textContent = "";
+        try {
+          const result = await api("/api/auth/login", {
+            method: "POST",
+            body: JSON.stringify({ passphrase: elements.passphrase.value || "" })
+          });
+          state.csrfToken = result.csrfToken || "";
+          elements.passphrase.value = "";
+          elements.auth.classList.add("hidden");
+          elements.app.classList.remove("hidden");
+          await loadConversations();
+          if (state.conversations[0]) {
+            state.activeConversationId = state.conversations[0].conversationId;
+            await loadConversation(state.activeConversationId);
+          }
+        } catch (error) {
+          elements.loginError.textContent = error.message || "Login failed";
+        }
+      });
+
+      elements.newChat.addEventListener("click", async () => {
+        await createConversation();
+        if (isMobile()) {
+          setSidebarOpen(false);
+        }
+      });
+
+      elements.prompt.addEventListener("input", () => {
+        autoResizePrompt();
+      });
+
+      elements.prompt.addEventListener("keydown", (event) => {
+        if (event.key === "Enter" && !event.shiftKey) {
+          event.preventDefault();
+          elements.composer.requestSubmit();
+        }
+      });
+
+      elements.sidebarToggle.addEventListener("click", () => {
+        if (!isMobile()) {
+          return;
+        }
+        const shouldOpen = !elements.shell.classList.contains("sidebar-open");
+        setSidebarOpen(shouldOpen);
+      });
+
+      elements.mobileClose.addEventListener("click", () => {
+        setSidebarOpen(false);
+      });
+
+      elements.sidebarBackdrop.addEventListener("click", () => {
+        setSidebarOpen(false);
+      });
+
+      elements.logout.addEventListener("click", async () => {
+        await api("/api/auth/logout", { method: "POST" });
+        state.activeConversationId = null;
+        state.openMenuConversationId = null;
+        state.conversations = [];
+        state.csrfToken = "";
+        await requireAuth();
+      });
+
+      elements.composer.addEventListener("submit", async (event) => {
+        event.preventDefault();
+        const value = elements.prompt.value;
+        elements.prompt.value = "";
+        autoResizePrompt();
+        await sendMessage(value);
+      });
+
+      document.addEventListener("click", (event) => {
+        if (!(event.target instanceof Node)) {
+          return;
+        }
+        if (!event.target.closest(".conversation-item")) {
+          if (state.openMenuConversationId) {
+            closeConversationMenu();
+          }
+        }
+      });
+
+      window.addEventListener("resize", () => {
+        setSidebarOpen(false);
+      });
+
+      (async () => {
+        const authenticated = await requireAuth();
+        if (!authenticated) {
+          return;
+        }
+        await loadConversations();
+        if (state.conversations[0]) {
+          state.activeConversationId = state.conversations[0].conversationId;
+          await loadConversation(state.activeConversationId);
+          renderConversationList();
+        }
+        autoResizePrompt();
+      })();
+    </script>
+  </body>
+</html>`;
+
+export {
+  FileConversationStore,
+  SessionStore,
+  LoginRateLimiter,
+  parseCookies,
+  setCookie,
+  verifyPassphrase,
+  getRequestIp,
+  inferConversationTitle,
+  renderWebUiHtml
+};