openclacky 1.0.0 → 1.0.2

data/lib/clacky/web/trash.js

@@ -0,0 +1,343 @@
+// trash.js — Recently Deleted panel
+//
+// Top-level sidebar panel that lists files moved to trash by the agent
+// across every project-scoped trash dir under ~/.clacky/trash/.
+//
+// Each card shows the original path, project, size and deleted-at,
+// plus Restore / Delete buttons. Bulk actions at the top:
+// refresh, empty files older than 7 days, empty everything.
+//
+// Load order: after app.js modules (I18n, Modal), before app.js boot.
+
+const Trash = (() => {
+  // ── Private state ────────────────────────────────────────────────────
+  let _files      = [];
+  let _totals     = { count: 0, size: 0 };
+  let _loading    = false;
+  let _wired      = false;
+
+  // ── Helpers ──────────────────────────────────────────────────────────
+
+  function $(id) { return document.getElementById(id); }
+
+  function escapeHtml(s) {
+    return String(s ?? "")
+      .replace(/&/g, "&amp;").replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+
+  function _t(key) {
+    return I18n.t ? I18n.t(key) : key;
+  }
+
+  function _humanBytes(n) {
+    if (!n || n < 0) return "0 B";
+    const units = ["B", "KB", "MB", "GB"];
+    let i = 0;
+    while (n >= 1024 && i < units.length - 1) { n /= 1024; i++; }
+    return (i === 0 ? n.toFixed(0) : n.toFixed(2)) + " " + units[i];
+  }
+
+  function _humanTime(iso) {
+    if (!iso) return "";
+    const d = new Date(iso);
+    if (isNaN(d.getTime())) return iso;
+    const now   = new Date();
+    const ms    = now - d;
+    const mins  = Math.floor(ms / 60000);
+    const hours = Math.floor(ms / 3600000);
+    const days  = Math.floor(ms / 86400000);
+    const zh    = I18n.lang() === "zh";
+    if (mins < 1)   return zh ? "刚刚"        : "just now";
+    if (mins < 60)  return zh ? `${mins} 分钟前`  : `${mins}m ago`;
+    if (hours < 24) return zh ? `${hours} 小时前` : `${hours}h ago`;
+    if (days < 7)   return zh ? `${days} 天前`    : `${days}d ago`;
+    return d.toLocaleDateString();
+  }
+
+  // ── Data loading ─────────────────────────────────────────────────────
+
+  async function _load() {
+    if (_loading) return;
+    _loading = true;
+    const list = $("trash-list");
+    if (list) list.innerHTML =
+      `<div class="creator-loading">${_t("trash.loading")}</div>`;
+    try {
+      const res  = await fetch("/api/trash");
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || "Load failed");
+      _files  = data.files  || [];
+      _totals = { count: data.total_count || 0, size: data.total_size || 0 };
+      _render();
+    } catch (e) {
+      console.error("[Trash] load failed", e);
+      if (list) list.innerHTML =
+        `<div class="creator-empty creator-error">${escapeHtml(e.message)}</div>`;
+    } finally {
+      _loading = false;
+    }
+  }
+
+  function _render() {
+    const list        = $("trash-list");
+    const summary     = $("trash-summary");
+    const btnOld      = $("btn-trash-empty-old");
+    const btnOrphans  = $("btn-trash-empty-orphans");
+    const btnAll      = $("btn-trash-empty-all");
+    if (!list) return;
+
+    const orphanCount = _files.filter(f => {
+      const root = f.project_root || "";
+      return /^\/(?:var\/folders|tmp|private\/var\/folders)\b/.test(root) ||
+             /\/d\d{8}-\d+-[a-z0-9]+(?:\/|$)/.test(root);
+    }).length;
+
+    if (summary) {
+      summary.textContent = _files.length
+        ? I18n.t("trash.summary", {
+            count: _totals.count,
+            size:  _humanBytes(_totals.size)
+          }) + (orphanCount > 0 ? "  •  " + I18n.t("trash.summaryOrphans", { count: orphanCount }) : "")
+        : "";
+    }
+    if (btnOld)     btnOld.disabled     = _files.length === 0;
+    if (btnOrphans) btnOrphans.disabled = orphanCount === 0;
+    if (btnAll)     btnAll.disabled     = _files.length === 0;
+
+    if (_files.length === 0) {
+      list.innerHTML = `<div class="creator-empty">${_t("trash.empty")}</div>`;
+      return;
+    }
+
+    list.innerHTML = "";
+    _files.forEach(f => list.appendChild(_buildCard(f)));
+  }
+
+  function _buildCard(file) {
+    const card = document.createElement("div");
+    card.className = "trash-card";
+    card.dataset.project = file.project_root;
+    card.dataset.path    = file.original_path;
+
+    const original = file.original_path || "";
+    const basename = original.split("/").pop() || original;
+    // Show last two path segments after basename to give agents context when
+    // many files share the same basename (very common: "package.json", "index.js").
+    const parts    = original.split("/").filter(Boolean);
+    const shortPath = parts.length > 3
+      ? ".../" + parts.slice(-3).join("/")
+      : original;
+    const sizeStr  = _humanBytes(file.file_size || 0);
+    const whenStr  = _humanTime(file.deleted_at);
+    // Heuristic: if project_root starts with /var/folders or /tmp, or contains
+    // a tempdir-style name (d20260502-...), the original project is gone.
+    // We still show it, but mark it so the user can clean it up confidently.
+    const orphan = /^\/(?:var\/folders|tmp|private\/var\/folders)\b/.test(file.project_root || "") ||
+                   /\/d\d{8}-\d+-[a-z0-9]+(?:\/|$)/.test(file.project_root || "");
+
+    card.innerHTML = `
+      <div class="trash-card-info">
+        <div class="trash-card-title" title="${escapeHtml(original)}">${escapeHtml(basename)}</div>
+        <div class="trash-card-path" title="${escapeHtml(original)}">${escapeHtml(shortPath)}</div>
+        <div class="trash-card-meta">
+          <span class="trash-project" title="${escapeHtml(file.project_root)}">
+            <svg xmlns="http://www.w3.org/2000/svg" width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+              <path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"/>
+            </svg>
+            ${escapeHtml(file.project_name || "")}
+          </span>
+          <span>${sizeStr}</span>
+          <span title="${escapeHtml(file.deleted_at || "")}">${escapeHtml(whenStr)}</span>
+          ${orphan ? `<span class="trash-missing" title="${_t("trash.orphanHint")}">⚠ ${_t("trash.orphan")}</span>` : ""}
+        </div>
+      </div>
+      <div class="trash-card-actions">
+        <button class="btn-trash-restore" title="${_t("trash.restore")}" ${orphan ? "disabled" : ""}>
+          <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <polyline points="1 4 1 10 7 10"/>
+            <path d="M3.51 15a9 9 0 1 0 2.13-9.36L1 10"/>
+          </svg>
+          ${_t("trash.restore")}
+        </button>
+        <button class="btn-trash-delete" title="${_t("trash.delete")}">
+          <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <polyline points="3 6 5 6 21 6"/>
+            <path d="M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6"/>
+            <path d="M10 11v6"/><path d="M14 11v6"/>
+          </svg>
+        </button>
+      </div>`;
+
+    card.querySelector(".btn-trash-restore").addEventListener("click", () =>
+      _restoreOne(file, card));
+    card.querySelector(".btn-trash-delete").addEventListener("click", () =>
+      _deleteOne(file, card));
+
+    return card;
+  }
+
+  async function _restoreOne(file, card) {
+    const btn = card.querySelector(".btn-trash-restore");
+    btn.disabled = true;
+    try {
+      const res = await fetch("/api/trash/restore", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          project_root:  file.project_root,
+          original_path: file.original_path
+        })
+      });
+      const data = await res.json();
+      if (!res.ok || !data.ok) {
+        alert(I18n.t("trash.restoreFail", {
+          msg: data.error || res.statusText
+        }));
+      } else {
+        // Remove card, update totals locally for instant feedback.
+        _files = _files.filter(f =>
+          !(f.project_root === file.project_root && f.original_path === file.original_path));
+        _totals = {
+          count: Math.max(0, _totals.count - 1),
+          size:  Math.max(0, _totals.size - (file.file_size || 0))
+        };
+        _render();
+      }
+    } catch (e) {
+      alert(I18n.t("trash.restoreFail", { msg: e.message }));
+    } finally {
+      btn.disabled = false;
+    }
+  }
+
+  async function _deleteOne(file, card) {
+    const basename = (file.original_path || "").split("/").pop() || file.original_path;
+    const confirmed = await Modal.confirm(
+      I18n.t("trash.confirmDeleteOne", { name: basename })
+    );
+    if (!confirmed) return;
+
+    const url = "/api/trash?" + new URLSearchParams({
+      project: file.project_root,
+      file:    file.original_path
+    }).toString();
+
+    try {
+      const res  = await fetch(url, { method: "DELETE" });
+      const data = await res.json();
+      if (!res.ok || !data.ok) {
+        alert(data.error || res.statusText);
+        return;
+      }
+      _files = _files.filter(f =>
+        !(f.project_root === file.project_root && f.original_path === file.original_path));
+      _totals = {
+        count: Math.max(0, _totals.count - 1),
+        size:  Math.max(0, _totals.size - (file.file_size || 0))
+      };
+      _render();
+    } catch (e) {
+      alert(e.message);
+    }
+  }
+
+  async function _emptyBulk(daysOld, confirmKey) {
+    const confirmed = await Modal.confirm(_t(confirmKey));
+    if (!confirmed) return;
+
+    const qs  = new URLSearchParams();
+    qs.set("days_old", String(daysOld));
+    const url = "/api/trash?" + qs.toString();
+
+    try {
+      const res  = await fetch(url, { method: "DELETE" });
+      const data = await res.json();
+      if (!res.ok || !data.ok) {
+        alert(data.error || res.statusText);
+        return;
+      }
+      if (data.deleted_count === 0 && daysOld > 0) {
+        alert(_t("trash.nothingOld"));
+      } else {
+        alert(I18n.t("trash.emptied", {
+          count: data.deleted_count || 0,
+          size:  _humanBytes(data.freed_size || 0)
+        }));
+      }
+      await _load();
+    } catch (e) {
+      alert(e.message);
+    }
+  }
+
+  // Detects trash entries whose original project_root clearly no longer
+  // exists (test temp dirs under /var/folders, /tmp, or dir-format "dYYYYMMDD-...").
+  // The delete API does permanent deletion on a per-file basis.
+  async function _emptyOrphans() {
+    const orphans = _files.filter(f => {
+      const root = f.project_root || "";
+      return /^\/(?:var\/folders|tmp|private\/var\/folders)\b/.test(root) ||
+             /\/d\d{8}-\d+-[a-z0-9]+(?:\/|$)/.test(root);
+    });
+    if (orphans.length === 0) {
+      alert(_t("trash.noOrphans"));
+      return;
+    }
+    const confirmed = await Modal.confirm(
+      I18n.t("trash.confirmEmptyOrphans", { count: orphans.length })
+    );
+    if (!confirmed) return;
+
+    let deleted = 0, freed = 0, failed = 0;
+    for (const f of orphans) {
+      const url = "/api/trash?" + new URLSearchParams({
+        project: f.project_root,
+        file:    f.original_path
+      }).toString();
+      try {
+        const r = await fetch(url, { method: "DELETE" });
+        const d = await r.json();
+        if (r.ok && d.ok) {
+          deleted += 1;
+          freed   += d.freed_size || 0;
+        } else {
+          failed += 1;
+        }
+      } catch (_e) {
+        failed += 1;
+      }
+    }
+    alert(I18n.t("trash.orphansCleaned", {
+      count:  deleted,
+      size:   _humanBytes(freed),
+      failed: failed
+    }));
+    await _load();
+  }
+
+  function _wire() {
+    if (_wired) return;
+    _wired = true;
+    const btnRefresh = $("btn-trash-refresh");
+    const btnOld     = $("btn-trash-empty-old");
+    const btnOrphans = $("btn-trash-empty-orphans");
+    const btnAll     = $("btn-trash-empty-all");
+    if (btnRefresh) btnRefresh.addEventListener("click", () => _load());
+    if (btnOld)     btnOld.addEventListener("click",
+      () => _emptyBulk(7, "trash.confirmEmptyOld"));
+    if (btnOrphans) btnOrphans.addEventListener("click", () => _emptyOrphans());
+    if (btnAll)     btnAll.addEventListener("click",
+      () => _emptyBulk(0, "trash.confirmEmptyAll"));
+  }
+
+  // ── Public API ────────────────────────────────────────────────────────
+
+  return {
+    /** Called by Router when the trash panel becomes active. */
+    onPanelShow() {
+      _wire();
+      _load();
+    },
+  };
+})();

data/lib/clacky/web/ws-dispatcher.js

@@ -0,0 +1,255 @@
+// ── WS event dispatcher ───────────────────────────────────────────────────
+//
+// Consumes events emitted by WS (ws.js) and dispatches them to the right
+// business module (Sessions, Tasks, Skills, Channels, Settings, Brand, ...).
+//
+// Kept as a separate file from ws.js on purpose:
+//   - ws.js is a pure transport layer (connect / send / subscribe / reconnect)
+//   - this file is the application-level router that knows about every
+//     business module. Mixing the two would force ws.js to depend on every
+//     other module, breaking layering.
+//
+// Depends on: WS (ws.js), Sessions, Tasks, Skills, Channels, Settings, Brand,
+//             Router, I18n, global $ / escapeHtml / showConfirmModal helpers.
+// ─────────────────────────────────────────────────────────────────────────
+(function() {
+  // Guard: restore hash routing only once after initial session_list arrives.
+  let _initialRestoreDone = false;
+
+
+WS.onEvent(ev => {
+  console.log("[DEBUG] WS event received:", ev.type, ev);
+  switch (ev.type) {
+
+    // ── Internal WS lifecycle ──────────────────────────────────────────
+    case "_ws_connected": {
+      const banner = document.getElementById("offline-banner");
+      if (banner) banner.style.display = "none";
+      const hint = $("ws-disconnect-hint");
+      if (hint) hint.style.display = "none";
+      break;
+    }
+
+    case "_ws_disconnected": {
+      const banner = document.getElementById("offline-banner");
+      if (banner) {
+        banner.textContent = I18n.t("offline.banner");
+        banner.style.display = "block";
+      }
+      // Do NOT force status bar to "idle" here — on a brief WS hiccup the
+      // agent may still be running, and reconnect will deliver a fresh
+      // session snapshot that patches the real status. Forcing idle here
+      // caused stuck UI after reconnect when the snapshot logic wasn't
+      // re-asserting status on every reconnect.
+      Sessions.clearAllProgress();
+      break;
+    }
+
+    // ── Session list ───────────────────────────────────────────────────
+    case "session_list": {
+      Sessions.setAll(ev.sessions || [], !!ev.has_more);
+      Sessions.renderList();
+
+      // Restore URL hash once on initial connect; ignore subsequent session_list events.
+      // Skip if we are already on a session view (e.g. onboard flow navigated there
+      // before WS connected) — restoreFromHash would wrongly redirect to "welcome"
+      // because there is no hash set during onboarding.
+      if (!_initialRestoreDone) {
+        _initialRestoreDone = true;
+        if (Router.current !== "session") {
+          Router.restoreFromHash();
+        }
+      } else {
+        // If active session was deleted, go to welcome
+        if (Sessions.activeId && !Sessions.find(Sessions.activeId)) {
+          Router.navigate("welcome");
+        }
+      }
+      break;
+    }
+
+    // ── Session lifecycle ──────────────────────────────────────────────
+    case "subscribed": {
+      // Re-enable send button now that the server has confirmed the subscription.
+      $("btn-send").disabled = false;
+      $("user-input").focus();
+      // If this session was created by Tasks.run(), fire the agent now that
+      // we're guaranteed to receive its broadcasts.
+      const pendingId = Sessions.takePendingRunTask();
+      if (pendingId && pendingId === ev.session_id) {
+        WS.send({ type: "run_task", session_id: pendingId });
+      }
+      // If a slash-command was queued (e.g. /onboard from first-boot flow),
+      // send it now — after restoreFromHash has settled — so appendMsg won't be wiped.
+      const pendingMsg = Sessions.takePendingMessage();
+      if (pendingMsg && pendingMsg.session_id === ev.session_id) {
+        Sessions.appendMsg("user", escapeHtml(pendingMsg.content), { time: new Date() });
+        WS.send({ type: "message", session_id: pendingMsg.session_id, content: pendingMsg.content });
+      }
+      break;
+    }
+
+    case "session_update": {
+      // Two shapes arrive under this type:
+      //   (1) Full session object from http_server broadcast_session_update:
+      //       { type, session: { id, name, status, total_cost, total_tasks, ... } }
+      //   (2) Partial real-time update from web_ui_controller (cost/tasks/status):
+      //       { type, session_id, cost?, tasks?, status? }
+      let sid, patch;
+      if (ev.session) {
+        // Shape (1): full session — use as-is
+        sid   = ev.session.id;
+        patch = ev.session;
+      } else {
+        // Shape (2): partial update — build patch from top-level fields
+        sid   = ev.session_id;
+        patch = {};
+        if (ev.cost    !== undefined) patch.total_cost     = ev.cost;
+        if (ev.tasks   !== undefined) patch.total_tasks    = ev.tasks;
+        if (ev.status  !== undefined) patch.status         = ev.status;
+        // Latency pushed by Agent after each LLM call (see update_sessionbar).
+        // Stored under latest_latency — same field name the HTTP /api/sessions
+        // list returns, so updateInfoBar doesn't need to branch on the source.
+        if (ev.latency !== undefined) patch.latest_latency = ev.latency;
+      }
+      if (!sid) break;
+      Sessions.patch(sid, patch);
+      Sessions.renderList();
+      if (sid === Sessions.activeId) {
+        const current = Sessions.find(sid);
+        if (patch.status !== undefined) Sessions.updateStatusBar(patch.status);
+        Sessions.updateInfoBar(current);
+        // Update chat title/subtitle in case session was renamed or working_dir changed
+        Sessions.updateChatHeader(current);
+      }
+      // When a session finishes, refresh tasks and skills, and clear any progress state
+      if (patch.status === "idle") {
+        Tasks.load();
+        Skills.load();
+        // Clear progress state for this session (even if not currently active)
+        Sessions.clearProgress(sid);
+      }
+      break;
+    }
+
+    case "session_renamed": {
+      Sessions.patch(ev.session_id, { name: ev.name });
+      Sessions.renderList();
+      // Title is now shown only in the sidebar; chat-header element was removed.
+      break;
+    }
+
+    case "session_deleted":
+      Sessions.remove(ev.session_id);
+      if (ev.session_id === Sessions.activeId) Router.navigate("welcome");
+      Sessions.renderList();
+      break;
+
+    // ── Chat messages ──────────────────────────────────────────────────
+    case "history_user_message":
+      // Emitted only during history replay — never from live WS.
+      // Rendered by Sessions._fetchHistory; nothing to do here.
+      break;
+
+    case "assistant_message":
+      if (ev.session_id !== Sessions.activeId) break;
+      Sessions.clearProgress();
+      Sessions.appendMsg("assistant", ev.content);
+      break;
+
+    case "tool_call":
+      if (ev.session_id !== Sessions.activeId) break;
+      Sessions.clearProgress();
+      Sessions.appendToolCall(ev.name, ev.args, ev.summary);
+      break;
+
+    case "tool_result":
+      if (ev.session_id !== Sessions.activeId) break;
+      Sessions.appendToolResult(ev.result);
+      break;
+
+    case "tool_stdout":
+      if (ev.session_id !== Sessions.activeId) break;
+      Sessions.appendToolStdout(ev.lines);
+      break;
+
+    case "tool_error":
+      if (ev.session_id !== Sessions.activeId) break;
+      Sessions.appendMsg("info", `⚠ Tool error: ${escapeHtml(ev.error)}`);
+      break;
+
+    case "token_usage":
+      if (ev.session_id !== Sessions.activeId) break;
+      Sessions.appendTokenUsage(ev);
+      break;
+
+    case "progress":
+      console.log("[DEBUG] progress event:", ev);
+      if (ev.session_id !== Sessions.activeId) break;
+      if (ev.phase === "active" || ev.status === "start") {
+        const progress_type = ev.progress_type || "thinking";
+        const metadata = ev.metadata || {};
+        console.log("[DEBUG] calling showProgress:", { message: ev.message, progress_type, metadata, started_at: ev.started_at });
+        Sessions.showProgress(ev.message, progress_type, metadata, ev.started_at || null);
+      } else {
+        console.log("[DEBUG] calling clearProgress:", ev.message);
+        Sessions.clearProgress(ev.message);
+      }
+      break;
+
+    case "complete":
+      if (ev.session_id !== Sessions.activeId) break;
+      Sessions.clearProgress();
+      Sessions.collapseToolGroup();
+      {
+        const costSource = ev.cost_source;
+        const costDisplay = (!costSource || costSource === "estimated")
+          ? "N/A"
+          : `$${(ev.cost || 0).toFixed(4)}`;
+        Sessions.appendInfo(`✓ ${I18n.t("chat.done", { n: ev.iterations, cost: costDisplay })}`);
+      }
+      break;
+
+    case "request_feedback":
+      if (ev.session_id !== Sessions.activeId) break;
+      Sessions.showFeedbackRequest(ev.question, ev.context, ev.options);
+      break;
+
+    case "request_confirmation":
+      if (ev.session_id !== Sessions.activeId) break;
+      showConfirmModal(ev.id, ev.message);
+      break;
+
+    case "interrupted":
+      if (ev.session_id !== Sessions.activeId) break;
+      Sessions.clearProgress();
+      Sessions.collapseToolGroup();
+      Sessions.appendInfo(I18n.t("chat.interrupted"));
+      break;
+
+    // ── Info / errors ──────────────────────────────────────────────────
+    case "info":
+      Sessions.appendInfo(ev.message);
+      break;
+
+    case "warning":
+      // Optimize retry messages for better UX
+      const friendlyWarning = _transformRetryWarning(ev.message);
+      if (friendlyWarning) {
+        Sessions.appendInfo(friendlyWarning);
+      }
+      break;
+
+    case "success":
+      Sessions.appendMsg("success", "✓ " + escapeHtml(ev.message));
+      break;
+
+    case "error":
+      if (!ev.session_id || ev.session_id === Sessions.activeId)
+        Sessions.appendMsg("error", escapeHtml(ev.message));
+      break;
+  }
+});
+
+
+})();

data/lib/clacky.rb

@@ -74,9 +74,6 @@ require_relative "clacky/message_history"
 require_relative "clacky/agent_config"
 require_relative "clacky/agent_profile"
 require_relative "clacky/providers"
-require_relative "clacky/clacky_auth_client"
-require_relative "clacky/clacky_cloud_config"
-require_relative "clacky/cloud_project_client"
 require_relative "clacky/session_manager"
 require_relative "clacky/idle_compression_timer"
 
@@ -136,6 +133,11 @@ module Clacky
   class AgentError < StandardError; end
   class BadRequestError < AgentError; end  # 400 errors — our request was malformed, history should be rolled back
   class RetryableError < StandardError; end  # Transient errors that should be retried (5xx, HTML response, rate limit)
+  # Upstream (model/router like OpenRouter/Bedrock) returned finish_reason="stop" together with
+  # one or more tool_calls whose `arguments` JSON was truncated (empty, "{}" placeholder, or
+  # otherwise unparseable). Subclass of RetryableError so it flows through the existing
+  # retry/fallback pipeline in LlmCaller#call_llm.
+  class UpstreamTruncatedError < RetryableError; end
   class ToolCallError < AgentError; end  # Raised when tool call fails due to invalid parameters
   class BrowserNotReachableError < AgentError; end  # Chrome/Edge not running or remote debugging disabled
   # BrowserManager singleton: Clacky::BrowserManager.instance