@oharness/server 0.10.0 → 0.11.0

package/dist/page/client/routines.js

@@ -275,8 +275,8 @@ async function showRoutines() {
 
         const remove = el("button", "ghost", t("routines.remove"));
         remove.type = "button";
-        remove.addEventListener("click", () => {
-          if (!confirm(t("routines.removeConfirm", { name: routine.name }))) return;
+        remove.addEventListener("click", async () => {
+          if (!(await askConfirm({ body: t("routines.removeConfirm", { name: routine.name }), ok: t("routines.remove"), danger: true }))) return;
           remove.disabled = true;
           void api("/routine/remove", { name: routine.name }).then((result) => {
             pushNotice(result);
@@ -315,7 +315,10 @@ async function showRoutines() {
  * because a switch you have to open a row to reach is a switch that has been
  * hidden rather than tidied.
  */
-async function showSettings() {
+async function showSettings(opts) {
+  // A row whose controls live inside it is reopened after a change redraws
+  // the page; called from a click handler, opts is the event, and opens none.
+  const opened = opts && typeof opts.open === "string" ? opts.open : undefined;
   const settings = await getJson("/settings");
   panelBody.replaceChildren();
   if (settings.error) return void panelBody.appendChild(panelError(settings.error));
@@ -439,6 +442,7 @@ async function showSettings() {
   change.addEventListener("click", openProjectPicker);
   field(t("settings.cwd"), settings.cwd || "—", t("settings.cwdHint"), change);
   permissionsField(settings);
+  claudeAgentField(settings.claudeAgent || { on: false, available: false });
 
   // A door, not a report: the numbers live on a page of their own, and the row
   // here carries no total of its own because working one out means walking
@@ -588,6 +592,34 @@ async function showSettings() {
    * and a "Show trail" you had to find after that was one click too many for
    * the only thing anybody opens this row to see.
    */
+  /**
+   * Claude Agent: the user's own Claude Code, on their own Claude account, as
+   * a subagent and as @claude.
+   *
+   * Off until switched on here, because it spends someone's Claude plan and
+   * that is theirs to decide — the hint says so in so many words before the
+   * switch is flipped, not after. With no Claude Code on this machine the
+   * switch is shown but shut, and the row says where to get it.
+   */
+  function claudeAgentField(status) {
+    const value = !status.available
+      ? t("settings.claudeAgentMissingValue")
+      : t(status.on ? "settings.claudeAgentOnValue" : "settings.claudeAgentOffValue");
+    const body = field(
+      t("settings.claudeAgent"),
+      value,
+      t("settings.claudeAgentHint"),
+      toggle(status.on, t("settings.claudeAgent"), (next) => {
+        void api("/settings/claude-agent", { enabled: next }).then((result) => {
+          if (result && result.error) addNotice(result.error, "err");
+          void showSettings();
+        });
+      }, !status.available && !status.on),
+    );
+    if (!status.available) body.appendChild(el("div", "muted small", t("settings.claudeAgentMissing")));
+    else if (status.unavailable) body.appendChild(el("div", "muted small", status.unavailable));
+  }
+
   function auditField(audit) {
     const mine = audit.source !== "project";
 
@@ -792,7 +824,9 @@ async function showSettings() {
   // a switch a browser tab cannot honour would be one that lies.
   const keepAwake = await getJson("/keep-awake");
   if (keepAwake && !keepAwake.error && keepAwake.available) {
-    target = groups.workspace;
+    // Set once, if ever: under Advanced, folded away with the other rows
+    // nobody comes to Settings to change.
+    target = groups.advanced;
     field(
       t("settings.keepAwake"),
       t(keepAwake.enabled ? "settings.keepAwakeOn" : "settings.keepAwakeOff"),
@@ -890,44 +924,9 @@ async function showSettings() {
     }
     body.appendChild(phones);
   }
-  // Computer use: only in the desktop app, which ships the helper. The switch
-  // is whether it may ever take the real mouse and keyboard; the list below
-  // it is the person's own additions to the apps it refuses.
+  // Computer use: only in the desktop app, which ships the helper. Read here,
+  // drawn after the browser row, its neighbour in kind.
   const computer = await getJson("/computer-use/settings");
-  if (computer && !computer.error && computer.available) {
-    target = groups.workspace;
-    const takeover = computer.takeover !== "never";
-    const body = field(
-      t("settings.computerTakeover"),
-      t(takeover ? "settings.computerTakeoverAsk" : "settings.computerTakeoverNever"),
-      t("settings.computerTakeoverHint"),
-      toggle(takeover, t("settings.computerTakeover"), (next) => {
-        void api("/computer-use/settings", { takeover: next ? "ask" : "never" }).then(showSettings);
-      }),
-    );
-    const blocked = el("div", "setting-list");
-    blocked.appendChild(el("div", "muted small", t("settings.computerBlocked")));
-    const box = el("textarea", "boxed");
-    box.value = (computer.blockedApps || []).join("\n");
-    box.rows = Math.max(2, (computer.blockedApps || []).length + 1);
-    box.spellcheck = false;
-    box.style.width = "100%";
-    box.placeholder = t("settings.computerBlockedPlaceholder");
-    blocked.appendChild(box);
-    const save = el("button", "ghost", t("perms.save"));
-    save.type = "button";
-    save.addEventListener("click", () => {
-      save.disabled = true;
-      const apps = box.value.split("\n").map((line) => line.trim()).filter(Boolean);
-      void api("/computer-use/settings", { blockedApps: apps }).then((result) => {
-        save.disabled = false;
-        if (result && result.error) return void addNotice(result.error, "err");
-        addNotice(t("perms.saved"));
-      });
-    });
-    blocked.appendChild(save);
-    body.appendChild(blocked);
-  }
   // Which browsers the agent may use. Three choices, so a segmented control
   // rather than a switch; absent when the browser tools are off altogether,
   // since then there is nothing for it to move.
@@ -961,6 +960,105 @@ async function showSettings() {
     body.appendChild(status);
     body.appendChild(extensionHelp(ext));
   }
+  // Computer use, as one row: the row says how it gets switched on, and opens
+  // onto the three things a person owns about it — whether the agent may
+  // switch it on itself, whether it may ever take the real mouse and
+  // keyboard, and their own additions to the apps it refuses.
+  if (computer && !computer.error && computer.available) {
+    target = groups.workspace;
+    const enableModes = ["ask", "auto", "off"];
+    const enable = enableModes.includes(computer.enable) ? computer.enable : "ask";
+    const body = field(t("settings.computer"), t("settings.computerEnable." + enable), "");
+    const sub = (label, control, hint) => {
+      const part = el("div", "setting-part");
+      const line = el("div", "setting-part-line");
+      line.appendChild(el("div", "setting-part-name", label));
+      line.appendChild(control);
+      part.appendChild(line);
+      if (hint) part.appendChild(el("div", "muted small", hint));
+      body.appendChild(part);
+    };
+
+    const enableSeg = el("div", "seg setting-seg");
+    enableSeg.setAttribute("role", "radiogroup");
+    enableSeg.setAttribute("aria-label", t("settings.computerEnable"));
+    for (const mode of enableModes) {
+      const chosen = mode === enable;
+      const button = el("button", "seg-item" + (chosen ? " on" : ""), t("settings.computerEnable." + mode));
+      button.type = "button";
+      button.setAttribute("role", "radio");
+      button.setAttribute("aria-checked", chosen ? "true" : "false");
+      button.addEventListener("click", () => {
+        if (chosen) return;
+        enableSeg.querySelectorAll("button").forEach((b) => (b.disabled = true));
+        void api("/computer-use/settings", { enable: mode }).then(() => showSettings({ open: "computer" }));
+      });
+      enableSeg.appendChild(button);
+    }
+    sub(t("settings.computerEnable"), enableSeg, t("settings.computerEnableHint." + enable));
+
+    const takeover = computer.takeover !== "never";
+    sub(
+      t("settings.computerTakeover"),
+      toggle(takeover, t("settings.computerTakeover"), (next) => {
+        void api("/computer-use/settings", { takeover: next ? "ask" : "never" }).then(() => showSettings({ open: "computer" }));
+      }),
+      t("settings.computerTakeoverHint"),
+    );
+
+    const blocked = el("div", "setting-list setting-part");
+    blocked.appendChild(el("div", "setting-part-name", t("settings.computerBlockedTitle")));
+    blocked.appendChild(el("div", "muted small", t("settings.computerBlocked")));
+    const box = el("textarea", "boxed");
+    box.value = (computer.blockedApps || []).join("\n");
+    box.rows = Math.max(2, (computer.blockedApps || []).length + 1);
+    box.spellcheck = false;
+    box.style.width = "100%";
+    box.placeholder = t("settings.computerBlockedPlaceholder");
+    blocked.appendChild(box);
+    const save = el("button", "ghost", t("perms.save"));
+    save.type = "button";
+    save.addEventListener("click", () => {
+      save.disabled = true;
+      const apps = box.value.split("\n").map((line) => line.trim()).filter(Boolean);
+      void api("/computer-use/settings", { blockedApps: apps }).then((result) => {
+        save.disabled = false;
+        if (result && result.error) return void addNotice(result.error, "err");
+        addNotice(t("perms.saved"));
+      });
+    });
+    blocked.appendChild(save);
+    body.appendChild(blocked);
+    body.parentElement.dataset.row = "computer";
+    if (opened === "computer") body.parentElement.open = true;
+  }
+  // One switch for both: the pictures of what a turn left in the browser and
+  // on the computer, under its reply. Shown wherever either can run.
+  const shots = await getJson("/turn-shots");
+  if (shots && !shots.error && (browserModes.includes(settings.browserMode) || (computer && computer.available))) {
+    target = groups.advanced;
+    field(
+      t("settings.turnShots"),
+      t(shots.enabled ? "settings.keepAwakeOn" : "settings.keepAwakeOff"),
+      t("settings.turnShotsHint"),
+      toggle(shots.enabled, t("settings.turnShots"), (next) => {
+        void api("/turn-shots", { enabled: next }).then(showSettings);
+      }),
+    );
+  }
+  // The grey next message in the empty composer, written after each turn.
+  const suggestions = await getJson("/suggestions");
+  if (suggestions && !suggestions.error) {
+    target = groups.workspace;
+    field(
+      t("settings.suggestions"),
+      t(suggestions.enabled ? "settings.keepAwakeOn" : "settings.keepAwakeOff"),
+      t("settings.suggestionsHint"),
+      toggle(suggestions.enabled, t("settings.suggestions"), (next) => {
+        void api("/suggestions", { enabled: next }).then(showSettings);
+      }),
+    );
+  }
   // The desktop app's version, with its release notes beside it. A row that
   // is always there, because the menu bar is not where people look and the
   // post-update hint is gone after one click.
@@ -988,12 +1086,46 @@ async function showSettings() {
   ];
   for (const [title, parts] of sections) {
     if (!parts.some((part) => part.childNodes.length)) continue;
+    if (title === "settings.section.advanced") {
+      panel.appendChild(advancedSection(parts));
+      continue;
+    }
     panel.appendChild(el("div", "section-title", t(title)));
     for (const part of parts) panel.appendChild(part);
   }
   panelBody.appendChild(panel);
 }
 
+/**
+ * Advanced: the rows nobody opens Settings to change, folded under their
+ * heading so the ones people do are the page. Shut until opened, and then
+ * open on every visit in this browser until shut again — a person who went
+ * looking once is likely to go looking again.
+ */
+const ADVANCED_OPEN_KEY = "oh.settings.advancedOpen";
+
+function advancedSection(parts) {
+  const section = el("details", "settings-advanced");
+  const head = el("summary", "section-title");
+  head.appendChild(el("span", "chev"));
+  head.appendChild(document.createTextNode(t("settings.section.advanced")));
+  section.appendChild(head);
+  for (const part of parts) section.appendChild(part);
+  try {
+    section.open = localStorage.getItem(ADVANCED_OPEN_KEY) === "1";
+  } catch {
+    // Storage refused: shut, as on a first visit.
+  }
+  section.addEventListener("toggle", () => {
+    try {
+      localStorage.setItem(ADVANCED_OPEN_KEY, section.open ? "1" : "0");
+    } catch {
+      // Not remembered, which costs one click next time.
+    }
+  });
+  return section;
+}
+
 /**
  * Where the money went, and on which model.
  *

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

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

package/dist/page/client/shell.js

@@ -8,6 +8,8 @@ export const SHELL = String.raw `
 
 const projectBtn = document.getElementById("project");
 let projects = [];
+/** The server's home directory, which the picker writes as ~. */
+let projectHome = "";
 /** Session directories that are worktrees, each naming the project it came from. */
 let worktrees = [];
 const worktreeAt = (cwd) => worktrees.find((one) => one.path === cwd);
@@ -54,6 +56,7 @@ function repaintPanel() {
 async function loadProjects() {
   const body = await getJson("/projects");
   projects = body.projects || [];
+  projectHome = body.home || "";
   worktrees = body.worktrees || [];
   projectOrder = body.order || [];
   paintProject();
@@ -64,9 +67,9 @@ async function loadProjects() {
 }
 
 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() });
+  const next = await askText({ title: t("projects.rename"), body: t("projects.renamePrompt"), value: name, ok: t("dialog.save") });
+  if (!next || next === name) return;
+  const body = await api("/project", { path: cwd, rename: next });
   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
@@ -81,73 +84,124 @@ function exportProjectUi(cwd) {
   link.click();
 }
 
+/** A project's directory as people say it: under home, from ~. */
+function projectDir(path) {
+  const home = projectHome.replace(/[\\/]+$/, "");
+  if (home && (path === home || path.startsWith(home + "/") || path.startsWith(home + "\\"))) return "~" + path.slice(home.length);
+  return path;
+}
+
 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;
+  // The row menu lives in <body>, which a modal dialog makes inert: while the
+  // picker is open the menu is moved inside it, and put back when it closes.
+  const menuHome = rowMenu.parentNode;
+  dialog.appendChild(rowMenu);
+  dialog.addEventListener("close", () => {
+    closeRowMenu();
+    menuHome.appendChild(rowMenu);
+  }, { once: true });
+
+  /** The rows that open a project, in order, and which one Enter opens. */
+  let rows = [];
+  let active = 0;
+  const light = (index, scroll) => {
+    if (!rows.length) return;
+    active = (index + rows.length) % rows.length;
+    rows.forEach((row, i) => row.parentNode.classList.toggle("active", i === active));
+    if (scroll) rows[active].scrollIntoView({ block: "nearest" });
+  };
+
+  const menuFor = (project, more, line) => {
+    const items = [
+      menuItem(t("projects.rename"), {
+        key: "r",
+        run: () => {
+          dialog.close();
+          void renameProjectUi(project.path, project.name);
+        },
+      }),
+      menuItem(t("projects.export"), {
+        key: "e",
+        run: () => {
+          closeRowMenu();
+          exportProjectUi(project.path);
+        },
+      }),
+    ];
+    // 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) {
+      items.push(
+        menuSep(),
+        menuItem(t("projects.forget"), {
+          danger: true,
+          run: () => {
+            closeRowMenu();
+            void api("/project", { path: project.path, remove: true }).then(async (body) => {
+              if (body && body.error) return void addNotice(body.error, "err");
+              await loadProjects();
+              paint();
+            });
+          },
+        }),
+      );
+    }
+    openRowMenu(more, line, items);
+  };
+
   const paint = () => {
     const query = field.value.trim().toLowerCase();
     listEl.replaceChildren();
-    first = null;
+    rows = [];
+    let here = 0;
     for (const project of projects) {
       if (query && !(project.name + " " + project.path).toLowerCase().includes(query)) continue;
+      const line = el("div", "proj-row" + (project.current ? " current" : ""));
       const row = el("button", "proj-item");
       row.type = "button";
+      row.title = project.path;
       row.appendChild(el("span", "avatar", project.name.slice(0, 1).toUpperCase()));
-      row.appendChild(el("span", "path", project.name));
+      const text = el("span", "proj-text");
+      text.appendChild(el("span", "path", project.name));
+      text.appendChild(el("span", "proj-dir", projectDir(project.path)));
+      row.appendChild(text);
       if (project.missing) row.appendChild(el("span", "tag", t("projects.missing")));
-      if (project.current) row.appendChild(el("span", "muted", "✓"));
+      const tick = el("span", "proj-check");
+      if (project.current) tick.appendChild(svgIcon("check"));
+      row.appendChild(tick);
       row.addEventListener("click", () => {
         dialog.close();
         if (!project.current) void chooseProject(project.path);
       });
-
-      const line = el("div", "proj-row");
+      const index = rows.length;
+      row.addEventListener("mousemove", () => { if (active !== index) light(index); });
       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) => {
+
+      const more = el("button", "proj-more");
+      more.type = "button";
+      more.title = t("session.more");
+      more.setAttribute("aria-label", t("session.more") + ": " + project.name);
+      more.appendChild(svgIcon("more"));
+      more.addEventListener("click", (e) => {
         e.stopPropagation();
-        exportProjectUi(project.path);
+        if (menuRow === line) return closeRowMenu();
+        menuFor(project, more, line);
       });
-      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);
-      }
+      line.appendChild(more);
       listEl.appendChild(line);
-      first = first || row;
+      if (project.current && !query) here = rows.length;
+      rows.push(row);
     }
+    if (!rows.length) listEl.appendChild(el("div", "proj-empty", t("projects.none")));
+    // Searching starts from the first match; an empty query from where you are.
+    light(here, true);
   };
 
   const add = document.getElementById("proj-add");
@@ -158,20 +212,38 @@ function openProjectPicker() {
   };
 
   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.oninput = () => {
+    closeRowMenu();
+    paint();
+  };
+  // A list with a search box above it promises the keys of one: arrows move
+  // through what matched, Enter opens it, Escape shuts a menu before the picker.
   field.onkeydown = (e) => {
-    if (e.key !== "Enter" || !first) return;
-    e.preventDefault();
-    first.click();
+    if (e.isComposing) return;
+    if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+      e.preventDefault();
+      closeRowMenu();
+      light(active + (e.key === "ArrowDown" ? 1 : -1), true);
+    } else if (e.key === "Enter" && rows[active]) {
+      e.preventDefault();
+      rows[active].click();
+    }
+  };
+  dialog.onkeydown = (e) => {
+    if (e.key === "Escape" && !rowMenu.hidden) {
+      e.preventDefault();
+      e.stopPropagation();
+      closeRowMenu();
+      field.focus();
+    }
   };
   paint();
   dialog.showModal();
   field.focus();
+  // Again now that it has a size: before showModal there is nothing to scroll.
+  light(active, true);
 }
 
-
 /**
  * A directory browser, for hosts with no folder dialog.
  *
@@ -753,6 +825,80 @@ if (IS_DESKTOP && window.oharness.updates) {
   // 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, () => {});
+  if (window.oharness.updates.onPrompt) window.oharness.updates.onPrompt(showUpdatePrompt);
+}
+
+/**
+ * The update questions, asked in the app's own dialog rather than the OS's.
+ * The main process decides when to ask and what a button does; the page only
+ * words the question and hands back which button it was — 0 is the one that
+ * acts, and Escape answers -1, the same as Later.
+ */
+function showUpdatePrompt(prompt) {
+  const kind = prompt && prompt.kind;
+  const vars = { version: prompt.version || "", current: prompt.current || "" };
+  const dialog = el("dialog", "upd-dialog");
+  if (prompt.important) dialog.classList.add("important");
+  const head = el("div", "upd-head");
+  head.appendChild(el("span", "upd-mark", kind === "error" ? "!" : "↑"));
+  const title =
+    kind === "download"
+      ? t(prompt.important ? "update.prompt.importantTitle" : "update.prompt.availableTitle", vars)
+      : kind === "restart"
+        ? t("update.prompt.readyTitle", vars)
+        : kind === "current"
+          ? t("update.prompt.currentTitle")
+          : kind === "error"
+            ? t("update.prompt.errorTitle")
+            : t("update.prompt.devTitle");
+  head.appendChild(el("div", "upd-title", title));
+  dialog.appendChild(head);
+
+  if (kind === "download" && prompt.notes) dialog.appendChild(el("div", "upd-notes", prompt.notes));
+  const body =
+    kind === "download"
+      ? t("update.prompt.availableBody", vars)
+      : kind === "restart"
+        ? t("update.prompt.readyBody")
+        : kind === "current"
+          ? t("update.prompt.currentBody", vars)
+          : kind === "error"
+            ? prompt.detail || ""
+            : t("update.prompt.devBody");
+  if (body) dialog.appendChild(el("div", kind === "error" ? "upd-body mono" : "upd-body", body));
+
+  const actions = el("div", "dlg-actions");
+  const finish = (response) => {
+    window.oharness.updates.answer(prompt.id, response);
+    if (dialog.open) dialog.close();
+    dialog.remove();
+  };
+  let main;
+  let focus;
+  if (kind === "download" || kind === "restart") {
+    const later = el("button", "quiet", t("update.prompt.later"));
+    main = el("button", "approve", t(kind === "download" ? "update.prompt.download" : "update.prompt.restart"));
+    later.type = main.type = "button";
+    later.onclick = () => finish(1);
+    main.onclick = () => finish(0);
+    actions.append(later, main);
+    // Restarting ends whatever is running, so Enter must not do it by accident.
+    focus = kind === "restart" ? later : main;
+  } else {
+    main = el("button", "approve", t("update.prompt.ok"));
+    main.type = "button";
+    main.onclick = () => finish(0);
+    actions.append(main);
+    focus = main;
+  }
+  dialog.appendChild(actions);
+  dialog.addEventListener("cancel", (e) => {
+    e.preventDefault();
+    finish(-1);
+  });
+  document.body.appendChild(dialog);
+  dialog.showModal();
+  focus.focus();
 }
 
 /**
@@ -785,7 +931,7 @@ async function takeDeepLink() {
   }
   if (typeof text !== "string" || !text) return;
   const draft = input.value.trim();
-  if (draft && draft !== text && !confirm(t("deepLink.replaceDraft"))) return;
+  if (draft && draft !== text && !(await askConfirm({ body: t("deepLink.replaceDraft"), ok: t("dialog.replace") }))) return;
   await switchTo({ action: "new" });
   input.value = text;
   // Called rather than an input event, which would also open the command

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAy2BzB,CAAC"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2/BzB,CAAC"}

package/dist/page/client/state.js

@@ -460,6 +460,10 @@ function projectHead(cwd, name, count, open) {
         closeRowMenu();
         void openTerminalIn(cwd, true);
       } }),
+      menuItem(t("projects.claudeCode"), { key: "c", run: () => {
+        closeRowMenu();
+        void openClaudeCode(cwd);
+      } }),
       menuItem(t(IS_MAC ? "projects.revealMac" : IS_WIN ? "projects.revealWin" : "projects.reveal"), { key: "f", run: () => {
         closeRowMenu();
         void api("/reveal", { path: cwd }).then((body) => {
@@ -968,11 +972,11 @@ async function showWorktreeFinish(cwd, anchor, head) {
 async function finishWorktreeUi(wt, action, name, clean) {
   const body = { path: wt.path, action };
   if (action === "commit") {
-    const message = window.prompt(t("worktree.commitPrompt"), wt.task || "");
+    const message = await askText({ title: t("worktree.commitPrompt"), value: wt.task || "", ok: t("dialog.ok") });
     if (!message) return;
     body.message = message;
   }
-  if (action === "discard" && !clean && !window.confirm(t("worktree.discardConfirm", { name }))) return;
+  if (action === "discard" && !clean && !(await askConfirm({ body: t("worktree.discardConfirm", { name }), ok: t("dialog.discard"), danger: true }))) return;
   const answer = await api("/worktree/finish", body, 5 * 60_000);
   if (!answer || answer.error) return void addNotice((answer && answer.error) || t("worktree.failed"), "notice err");
   addNotice(answer.result.message);
@@ -1487,6 +1491,7 @@ function renderHistory(entries, into) {
       if (card) assistantTurn().appendChild(card);
     }
     if (entry.shots) turnShots(assistantTurn(), entry.shots);
+    if (entry.agent) agentReply(assistantTurn(), entry.agent);
     if (P.turn) turnActions(P.turn, entry.keepMessages);
   }
   for (const card of connectionCards.values()) {