@oharness/server 0.7.0 → 0.8.0

package/dist/page/client/shell.js

@@ -0,0 +1,690 @@
+/**
+ * Projects, the command palette, and the boot sequence that starts it all.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export const SHELL = String.raw `
+// --- projects --------------------------------------------------------------
+
+const projectBtn = document.getElementById("project");
+let projects = [];
+
+/** The last path segment, which is what the directory is called. */
+function projectName(dir) {
+  const parts = String(dir).replace(/\/+$/, "").split("/");
+  return parts[parts.length - 1] || dir;
+}
+
+function paintProject() {
+  const active = projects.find((project) => project.current);
+  document.getElementById("project-name").textContent = active ? active.name : "—";
+  document.getElementById("project-avatar").textContent = active
+    ? active.name.slice(0, 1).toUpperCase()
+    : "?";
+  // The invitation names the project it is connected to; a switch has to reach
+  // it too, or it goes on advertising the tree the user just left.
+  const cwdEl = document.getElementById("empty-cwd");
+  if (cwdEl && active) cwdEl.textContent = active.name;
+  // A directory added while the chip was open belongs on its list.
+  refreshWorkspace();
+}
+
+/** Repaint whichever panel is on screen, if one is. */
+function repaintPanel() {
+  void refreshPluginPages();
+  if (panelView.hidden) return;
+  // Off what was opened, not off which sidebar row is lit: a sub-panel lights
+  // the row it was reached from, so asking the sidebar would answer "settings"
+  // for a page that is not settings and quietly navigate away from it.
+  if (shownPanel === "nav-artifacts") void showAllArtifacts();
+  else if (shownPanel === "nav-models") void showModels();
+  else if (shownPanel === "nav-routines") void showRoutines();
+  else if (shownPanel === "nav-settings") void showSettings();
+  else if (shownPanel === "usage") void showUsage();
+  else if (shownPanel === "audit") void showAudit();
+  else if (shownPanel === "permissions") void showPermissions();
+  else if (shownPanel?.startsWith("nav-plugin-")) void showMemoryPage(shownPanel.slice("nav-plugin-".length));
+}
+
+async function loadProjects() {
+  const body = await getJson("/projects");
+  projects = body.projects || [];
+  projectOrder = body.order || [];
+  paintProject();
+  // A project's pin and its place decide how the session list is grouped, so
+  // the two are painted together rather than waiting for the next thing that
+  // happens to reload sessions.
+  if (sessionRows.length) paintSessions();
+}
+
+async function renameProjectUi(cwd, name) {
+  const next = window.prompt(t("projects.renamePrompt"), name);
+  if (!next || next.trim() === name) return;
+  const body = await api("/project", { path: cwd, rename: next.trim() });
+  if (body && body.error) return void addNotice(body.error, "err");
+  addNotice(t("projects.renamed", { name: body.project.name }));
+  // Paths key tabs, local open/closed state and drag order. Reloading after
+  // the server has rebuilt the renamed harness drops every stale path at once.
+  window.location.reload();
+}
+
+function exportProjectUi(cwd) {
+  const link = document.createElement("a");
+  link.href = q("/project/export?path=" + encodeURIComponent(cwd));
+  link.download = "";
+  link.click();
+}
+
+function openProjectPicker() {
+  const dialog = document.getElementById("project-picker");
+  const field = document.getElementById("proj-search");
+  const listEl = document.getElementById("proj-list");
+  field.placeholder = t("projects.search");
+
+  let first = null;
+  const paint = () => {
+    const query = field.value.trim().toLowerCase();
+    listEl.replaceChildren();
+    first = null;
+    for (const project of projects) {
+      if (query && !(project.name + " " + project.path).toLowerCase().includes(query)) continue;
+      const row = el("button", "proj-item");
+      row.type = "button";
+      row.appendChild(el("span", "avatar", project.name.slice(0, 1).toUpperCase()));
+      row.appendChild(el("span", "path", project.name));
+      if (project.missing) row.appendChild(el("span", "tag", t("projects.missing")));
+      if (project.current) row.appendChild(el("span", "muted", "✓"));
+      row.addEventListener("click", () => {
+        dialog.close();
+        if (!project.current) void chooseProject(project.path);
+      });
+
+      const line = el("div", "proj-row");
+      line.appendChild(row);
+      const rename = el("button", "proj-forget", "✎");
+      rename.type = "button";
+      rename.title = t("projects.rename");
+      rename.setAttribute("aria-label", t("projects.rename") + ": " + project.name);
+      rename.addEventListener("click", (e) => {
+        e.stopPropagation();
+        dialog.close();
+        void renameProjectUi(project.path, project.name);
+      });
+      line.appendChild(rename);
+      const archive = el("button", "proj-forget", "↓");
+      archive.type = "button";
+      archive.title = t("projects.export");
+      archive.setAttribute("aria-label", t("projects.export") + ": " + project.name);
+      archive.addEventListener("click", (e) => {
+        e.stopPropagation();
+        exportProjectUi(project.path);
+      });
+      line.appendChild(archive);
+      // Not offered for the project this window is standing in: the next
+      // switch calls addProject and puts it straight back, so the control
+      // would appear to do nothing. Nothing recorded is lost either way —
+      // this forgets a path, and the sessions stay where they are.
+      if (!project.current) {
+        const forget = el("button", "proj-forget", "✕");
+        forget.type = "button";
+        forget.title = t("projects.forget");
+        forget.setAttribute("aria-label", t("projects.forget") + ": " + project.name);
+        forget.addEventListener("click", (e) => {
+          e.stopPropagation();
+          void api("/project", { path: project.path, remove: true }).then(async (body) => {
+            if (body && body.error) return void addNotice(body.error, "err");
+            await loadProjects();
+            paint();
+          });
+        });
+        line.appendChild(forget);
+      }
+      listEl.appendChild(line);
+      first = first || row;
+    }
+  };
+
+  const add = document.getElementById("proj-add");
+  add.replaceChildren(el("span", null, "+"), el("span", null, t("projects.add")));
+  add.onclick = () => {
+    dialog.close();
+    void pickFolder((path) => chooseProject(path));
+  };
+
+  field.value = "";
+  field.oninput = paint;
+  // Typing enough of the name and pressing Enter is what a list with a search
+  // box above it promises; without this the field swallows the key.
+  field.onkeydown = (e) => {
+    if (e.key !== "Enter" || !first) return;
+    e.preventDefault();
+    first.click();
+  };
+  paint();
+  dialog.showModal();
+  field.focus();
+}
+
+
+/**
+ * A directory browser, for hosts with no folder dialog.
+ *
+ * Lists directories from the server because the page cannot see the disk. Only
+ * names and only directories: this navigates to a project, it is not a file
+ * manager.
+ */
+function openBrowser(start, opts) {
+  // Whoever opened it decides what a chosen directory is for: a project to
+  // open, or the tree a session is about to start in.
+  const onPick = (opts && opts.onPick) || ((path) => chooseProject(path));
+  const dialog = document.getElementById("browse");
+  const listEl = document.getElementById("browse-list");
+  const hereEl = document.getElementById("browse-here");
+  let at = start || "";
+
+  const paint = async () => {
+    const body = await getJson("/fs" + (at ? "?path=" + encodeURIComponent(at) : ""));
+    if (body.error) return void addNotice(body.error, "err");
+    at = body.path;
+    hereEl.textContent = body.path;
+    listEl.replaceChildren();
+
+    if (body.parent) {
+      const up = el("button", "proj-item");
+      up.type = "button";
+      up.appendChild(el("span", "avatar", "↑"));
+      up.appendChild(el("span", "path", t("projects.up")));
+      up.addEventListener("click", () => {
+        at = body.parent;
+        void paint();
+      });
+      listEl.appendChild(up);
+    }
+
+    for (const entry of body.entries || []) {
+      const row = el("button", "proj-item");
+      row.type = "button";
+      row.appendChild(el("span", "avatar", entry.name.slice(0, 1).toUpperCase()));
+      row.appendChild(el("span", "path", entry.name));
+      row.addEventListener("click", () => {
+        at = entry.path;
+        void paint();
+      });
+      listEl.appendChild(row);
+    }
+  };
+
+  const pick = document.getElementById("browse-choose");
+  pick.textContent = t("projects.choose");
+  pick.onclick = () => {
+    dialog.close();
+    void onPick(at);
+  };
+  void paint();
+  dialog.showModal();
+}
+
+async function chooseProject(path) {
+  const state = await api("/project", { path });
+  if (state && state.error) return void addNotice(state.error, "err");
+  await adoptSession(state);
+}
+
+/**
+ * Take over the session a project switch landed on.
+ *
+ * A switch replaces every open tab: the old sessions belong to a different
+ * tree, and keeping them would offer transcripts whose files are no longer the
+ * ones on screen. The new session has to be adopted rather than left implicit —
+ * leaving activeId null pointed the page at a pane that had just been removed,
+ * so the first reply after a project switch rendered into nothing.
+ */
+async function adoptSession(state) {
+  for (const entry of panes.values()) entry.node.remove();
+  panes.clear();
+
+  const record = pane(state.sessionId);
+  record.title = state.title || "";
+  activeId = state.sessionId;
+  P = record;
+  record.node.hidden = false;
+  paintTabs();
+
+  const { entries } = await getJson("/history?session=" + encodeURIComponent(state.sessionId));
+  renderHistory(entries, record);
+  applyState(state);
+
+  await loadProjects();
+  await loadSessions();
+  await loadSidePanels();
+  // Settings reports the working directory, so the page that offered the
+  // switch has to show its result rather than the path that is no longer used.
+  repaintPanel();
+}
+
+projectBtn.addEventListener("click", openProjectPicker);
+
+// --- the command palette ---------------------------------------------------
+
+/**
+ * One keystroke to what the sidebar is for: start a session, reopen one,
+ * change project.
+ *
+ * Everything here is already reachable by mouse. What it adds is reach: the
+ * sidebar previews five sessions per project and folds the rest away, so the
+ * transcript from two days ago costs an unfold, a scroll and a read. Typing
+ * three letters of its title is the same answer without the hunt.
+ */
+const paletteDialog = document.getElementById("palette");
+const paletteField = document.getElementById("cmdk-search");
+const paletteListEl = document.getElementById("cmdk-list");
+
+/**
+ * Cmd on a Mac, Ctrl everywhere else — deliberately not both.
+ *
+ * Ctrl-K inside a text field on macOS deletes to the end of the line, and the
+ * composer is a text field the user is usually sitting in when they reach for
+ * this. Claiming that key would break an editing shortcut to duplicate one
+ * the same keyboard already has.
+ */
+const IS_MAC = /mac/i.test(navigator.platform || navigator.userAgent || "");
+const IS_WIN = /win/i.test(navigator.platform || navigator.userAgent || "");
+
+/** The rows the current query left on screen, in the order they are drawn. */
+let paletteRows = [];
+let paletteCursor = 0;
+
+/** A nav item's own icon, so the palette names things the way the sidebar does. */
+function navIcon(id) {
+  const source = document.querySelector("#" + id + " .ico");
+  const copy = source ? source.cloneNode(true) : svgIcon("file");
+  copy.setAttribute("class", "ico-sm");
+  return copy;
+}
+
+/**
+ * The English label for a key.
+ *
+ * A translated UI still answers to the English word: "settings" finds 设置.
+ * The alternative is a second set of strings that exist only to be searched.
+ */
+const enLabel = (key) => (STRINGS.en && STRINGS.en[key]) || "";
+
+/** Everything the palette can offer, in the order it offers it. */
+function paletteItems() {
+  const items = [];
+  const query = paletteField.value.trim();
+  const actions = t("palette.actions");
+  const here = (projects.find((project) => project.current) || {}).path || currentCwd;
+
+  items.push({
+    kind: "new",
+    group: actions,
+    icon: () => navIcon("new"),
+    label: t("nav.new"),
+    // Where it will run, because "new session" does not say in which tree and
+    // the answer is the one thing about it that changes.
+    sub: here ? projectName(here) : "",
+    keywords: enLabel("nav.new"),
+    run: () => void switchTo({ action: "new" }),
+  });
+  items.push({
+    kind: "switch",
+    group: actions,
+    icon: () => svgIcon("folder"),
+    label: t("palette.switchProject"),
+    keywords: enLabel("palette.switchProject"),
+    run: () => openProjectPicker(),
+  });
+  // Clicked rather than reimplemented: each nav item already knows how to open
+  // its own panel, and a second copy of that wiring here would drift.
+  for (const [id, key] of [
+    ["nav-artifacts", "nav.artifacts"],
+    ["nav-models", "nav.models"],
+    ["nav-routines", "nav.routines"],
+    ["nav-settings", "nav.settings"],
+  ]) {
+    items.push({
+      kind: "panel",
+      group: actions,
+      icon: () => navIcon(id),
+      label: t(key),
+      keywords: enLabel(key),
+      run: () => document.getElementById(id).click(),
+    });
+  }
+
+  // Unfiltered, the list is a preview of the most recent work and the actions
+  // above it still have to be visible. Once there is a query, every session in
+  // every tree is fair game — that is what the field is for.
+  const sessions = t("palette.sessions");
+  for (const session of query ? sessionRows : sessionRows.slice(0, 8)) {
+    items.push({
+      kind: "session",
+      group: sessions,
+      icon: () => svgIcon("chat"),
+      label: session.title || t("session.untitled"),
+      sub: [projectName(session.cwd || ""), ago(session.updatedAt)].filter(Boolean).join(" · "),
+      keywords: session.cwd || "",
+      run: () => {
+        if (session.current) return void setNav(null);
+        void openSession(session.id, session.cwd);
+      },
+    });
+  }
+
+  const named = t("palette.projects");
+  for (const project of query ? projects : projects.slice(0, 5)) {
+    items.push({
+      kind: "project",
+      group: named,
+      icon: () => svgIcon("folder"),
+      label: project.name,
+      sub: project.missing ? t("projects.missing") : "",
+      // The path, so two projects with the same last segment can be told apart
+      // by typing the part of the path that differs.
+      keywords: project.path,
+      run: () => {
+        if (!project.current) void chooseProject(project.path);
+      },
+    });
+  }
+  return items;
+}
+
+/** Same word-by-word match the pickers use, over the row's hidden aliases too. */
+const paletteMatch = (item, query) =>
+  matchesQuery(
+    { label: item.label, group: item.group, sub: (item.sub || "") + " " + (item.keywords || "") },
+    query,
+  );
+
+function paintPalette() {
+  const query = paletteField.value.trim();
+  paletteRows = paletteItems().filter((item) => paletteMatch(item, query));
+  if (paletteCursor >= paletteRows.length) paletteCursor = Math.max(0, paletteRows.length - 1);
+
+  paletteListEl.replaceChildren();
+  let lastGroup = null;
+  paletteRows.forEach((item, i) => {
+    if (item.group !== lastGroup) {
+      lastGroup = item.group;
+      paletteListEl.appendChild(el("div", "cmdk-group", item.group));
+    }
+    const row = el("button", "cmdk-item" + (i === paletteCursor ? " cursor" : ""));
+    row.type = "button";
+    row.appendChild(item.icon());
+    row.appendChild(el("span", "cmdk-label", item.label));
+    if (item.sub) row.appendChild(el("span", "cmdk-sub", item.sub));
+    // Moving the mouse over a row makes it the row Enter answers. Two separate
+    // highlights — one under the pointer, one under the keyboard — leave the
+    // user guessing which of them the next key is talking to.
+    row.addEventListener("mousemove", () => {
+      if (paletteCursor === i) return;
+      paletteCursor = i;
+      for (const other of paletteListEl.querySelectorAll(".cmdk-item.cursor")) {
+        other.classList.remove("cursor");
+      }
+      row.classList.add("cursor");
+    });
+    row.addEventListener("click", () => runPalette(item));
+    paletteListEl.appendChild(row);
+  });
+
+  if (!paletteRows.length) paletteListEl.appendChild(el("div", "cmdk-empty", t("menu.none")));
+}
+
+function runPalette(item) {
+  // Closed first: the row may open a dialog of its own, and two modals deep is
+  // one more than anything here needs.
+  paletteDialog.close();
+  // Which kind of row got used, never its title or its path — the point of the
+  // palette is which of the three it is actually for.
+  track("palette_run", { kind: item.kind });
+  item.run();
+}
+
+function movePalette(step) {
+  if (!paletteRows.length) return;
+  paletteCursor = (paletteCursor + step + paletteRows.length) % paletteRows.length;
+  paintPalette();
+  const active = paletteListEl.querySelector(".cursor");
+  if (active) active.scrollIntoView({ block: "nearest" });
+}
+
+function openPalette() {
+  // One modal at a time. A permission request is a question the agent is
+  // blocked on; a palette over it would answer neither.
+  if (document.querySelector("dialog[open]")) return;
+  closeAttachMenu();
+  closeRowMenu();
+  paletteField.value = "";
+  paletteCursor = 0;
+  paintPalette();
+  paletteDialog.showModal();
+  paletteField.focus();
+  track("palette_opened", { shell: IS_DESKTOP ? "desktop" : "browser" });
+}
+
+// The desktop shell reaches the palette through this: a menu accelerator is
+// handled before the page ever sees the keystroke, so the menu item calls the
+// same function the key would have.
+window.openCommandPalette = openPalette;
+
+paletteField.addEventListener("input", () => {
+  paletteCursor = 0;
+  paintPalette();
+  // The list keeps its scroll offset across a repaint, which leaves the first
+  // results of a new query above the visible window.
+  paletteListEl.scrollTop = 0;
+});
+
+paletteField.addEventListener("keydown", (e) => {
+  if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+    e.preventDefault();
+    return void movePalette(e.key === "ArrowDown" ? 1 : -1);
+  }
+  if (e.key !== "Enter") return;
+  e.preventDefault();
+  const picked = paletteRows[paletteCursor];
+  if (picked) runPalette(picked);
+});
+
+// A dialog's backdrop is the dialog element itself; a click on a row never
+// reaches here.
+paletteDialog.addEventListener("click", (e) => {
+  if (e.target === paletteDialog) paletteDialog.close();
+});
+
+paletteDialog.addEventListener("close", () => {
+  // A dialog hands focus back to whatever opened it, so closing this one left
+  // a focus ring sitting on the sidebar's Search button — and a ⌘K typed into
+  // the composer was never "opened from" there at all. The composer is where
+  // the next keystroke was going in either case.
+  if (!panelView.hidden) return;
+  input.focus();
+});
+
+document.addEventListener("keydown", (e) => {
+  // e.code as well as e.key: on a non-Latin layout the key is whatever letter
+  // that layout puts there, and the shortcut is the position on the keyboard.
+  if (e.code !== "KeyK" && String(e.key).toLowerCase() !== "k") return;
+  if (IS_MAC ? !e.metaKey || e.ctrlKey : !e.ctrlKey || e.metaKey) return;
+  if (e.altKey || e.shiftKey) return;
+  // Chrome gives Cmd-K to the address bar, so the page has to say no. Every
+  // app that has this shortcut does the same.
+  e.preventDefault();
+  if (paletteDialog.open) return void paletteDialog.close();
+  openPalette();
+});
+
+document.getElementById("nav-search").addEventListener("click", openPalette);
+// The chord as this machine actually spells it, in the one place a mouse user
+// will see it.
+document.getElementById("palette-hint").textContent = IS_MAC ? "⌘K" : "Ctrl K";
+
+
+// --- boot -----------------------------------------------------------------
+
+/** Fill every element that declared a string key. Runs before anything draws. */
+function applyStrings() {
+  for (const node of document.querySelectorAll("[data-t]")) node.textContent = ts(node.dataset.t);
+  for (const node of document.querySelectorAll("[data-t-placeholder]")) {
+    node.placeholder = ts(node.dataset.tPlaceholder);
+  }
+  for (const node of document.querySelectorAll("[data-t-title]")) {
+    node.title = ts(node.dataset.tTitle);
+  }
+  for (const node of document.querySelectorAll("[data-t-aria-label]")) {
+    node.setAttribute("aria-label", ts(node.dataset.tAriaLabel));
+  }
+  document.documentElement.lang = LOCALE;
+}
+
+/**
+ * What the empty state offers to do, grouped by the kind of work it is.
+ *
+ * One chip is drawn from each group, so the three on screen always span
+ * writing code, getting through the day's work, and taking the thing to
+ * market — three variations on "read my repo" would teach a new person that
+ * this is a code-reading tool and nothing else. Each id names a label and a
+ * "…prompt" string; the label is what fits on
+ * a chip, the prompt is the sentence the chip actually sends.
+ */
+const STARTERS = [
+  ["explain", "bugs", "tests", "review", "faster"],
+  ["plan", "docs", "digest", "automate", "backlog"],
+  ["landing", "launch", "pitch", "position", "changelog"],
+];
+
+/**
+ * Draw one chip per group. The sentence rides along in data-p, and the click
+ * is wired at the end of boot with the rest of them: a chip that submits before
+ * the session it would submit to has loaded is worse than one that waits.
+ */
+function paintStarters() {
+  const box = document.getElementById("starters");
+  if (!box) return;
+  box.replaceChildren();
+  for (const group of STARTERS) {
+    const id = group[Math.floor(Math.random() * group.length)];
+    const button = el("button", "", t("starter." + id));
+    button.type = "button";
+    button.dataset.p = t("starter." + id + ".prompt");
+    // The label is a chip; the title is the sentence it will actually send.
+    button.title = button.dataset.p;
+    box.appendChild(button);
+  }
+}
+
+/**
+ * The desktop shell's update hint. The state lives in the main process, which
+ * decides whether a release gets a dialog or only this row; the page draws it
+ * and passes the click back, where the right question is asked.
+ */
+function paintUpdateHint(state) {
+  const box = document.getElementById("update-hint");
+  if (!box) return;
+  const status = state && state.status;
+  if (status !== "available" && status !== "downloading" && status !== "ready" && status !== "updated") {
+    box.hidden = true;
+    box.textContent = "";
+    return;
+  }
+  box.hidden = false;
+  box.classList.toggle("important", Boolean(state.important));
+  const button = document.createElement("button");
+  button.type = "button";
+  button.disabled = status === "downloading";
+  if (state.important) button.title = t("update.important");
+  const dot = document.createElement("span");
+  dot.className = "dot";
+  const label = document.createElement("span");
+  label.className = "label";
+  label.textContent =
+    status === "updated"
+      ? t("update.updated", { version: state.version })
+      : status === "ready"
+        ? t("update.ready")
+        : status === "downloading"
+          ? t("update.downloading", { version: state.version })
+          : t("update.available", { version: state.version });
+  button.append(dot, label);
+  if (status === "downloading") {
+    const pct = document.createElement("span");
+    pct.className = "pct";
+    pct.textContent = (state.percent || 0) + "%";
+    button.append(pct);
+  }
+  button.addEventListener("click", () => window.oharness.updates.act());
+  box.replaceChildren(button);
+}
+if (IS_DESKTOP && window.oharness.updates) {
+  window.oharness.updates.onState(paintUpdateHint);
+  // Asked once as well: a release found before this page loaded (or before a
+  // reopened window) was announced to nobody.
+  window.oharness.updates.state().then(paintUpdateHint, () => {});
+}
+
+void (async () => {
+  applyStrings();
+  paintStarters();
+  // The language is here because it is the one thing that decides what to
+  // translate next, and the shell because a desktop window and a browser tab
+  // are different products to the person using them.
+  track("app_opened", { locale: LOCALE, shell: IS_DESKTOP ? "desktop" : "browser" });
+  // After the first track call, not before: the queue exists so that boot does
+  // not have to wait on a round trip to find out whether anyone is listening.
+  void startAnalytics();
+  const state = await getJson("/state");
+  if (state.error) {
+    // Nothing else will work either; saying so beats an empty shell.
+    P = pane("boot");
+    P.node.hidden = false;
+    P.node.replaceChildren(panelError(state.error));
+    return;
+  }
+
+  // Reopen whatever the server still has running, so a reload does not silently
+  // abandon turns that are still streaming in other tabs.
+  const opened = await getJson("/open");
+  const list = (opened.open || []).length ? opened.open : [{ id: state.sessionId, current: true }];
+  for (const entry of list) {
+    const record = pane(entry.id);
+    record.title = entry.title || record.title;
+    record.cwd = entry.cwd || record.cwd;
+    record.busy = Boolean(entry.busy);
+  }
+  activeId = (list.find((entry) => entry.current) || list[0]).id;
+  for (const [id, record] of panes) record.node.hidden = id !== activeId;
+  paintTabs();
+
+  P = pane(activeId);
+  await loadModels();
+  applyState(state);
+  const cwdEl = document.getElementById("empty-cwd");
+  if (cwdEl) cwdEl.textContent = projectName(state.cwd || "");
+
+  for (const [id, record] of panes) {
+    const { entries } = await getJson("/history?session=" + encodeURIComponent(id));
+    renderHistory(entries, record);
+  }
+  P = pane(activeId);
+  await loadSidePanels();
+  await loadProjects();
+
+  for (const button of document.querySelectorAll("#starters button")) {
+    button.addEventListener("click", () => {
+      input.value = button.dataset.p;
+      paintMirror();
+      document.getElementById("composer").requestSubmit();
+    });
+  }
+  await loadSessions();
+  await refreshRoutineCount();
+  await refreshPluginPages();
+  await refreshModelCount();
+  await loadAccount();
+  input.focus();
+})();`;
+//# sourceMappingURL=shell.js.map

package/dist/page/client/shell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.js","sourceRoot":"","sources":["../../../src/page/client/shell.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2qBzB,CAAC"}