@oharness/server 0.9.3 → 0.11.0

package/dist/page/client/tasks.js

@@ -0,0 +1,293 @@
+/**
+ * Background tasks: their rows over the composer, and the sheet one opens
+ * into — what the subagent was told, what it did, what it said — with a way
+ * to stop it or tell it something.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export const TASKS = String.raw `
+// --- background tasks -----------------------------------------------------
+
+const TASK_LIVE = new Set(["queued", "running"]);
+/** How many task rows sit over the composer; the sheet lists every one. */
+const TASK_ROWS = 4;
+/** The task the sheet shows, while it is open. */
+let taskOpen = null;
+let taskSheet = null;
+/** Bumped per paint, so a slow answer never draws over a newer one. */
+let taskPaintSeq = 0;
+
+/**
+ * Running ones first, then the newest. Ended tasks stay listed, quieter, so
+ * what they said is a click away and they can still be sent a follow-up.
+ */
+function sortedTasks(tasks) {
+  return (tasks || []).slice().sort((a, b) =>
+    (Number(TASK_LIVE.has(b.status)) - Number(TASK_LIVE.has(a.status))) || (b.queuedAt - a.queuedAt));
+}
+
+/** The rows over the composer, drawn by renderQueued with the queue. */
+function appendTaskRows(container, here) {
+  // Put-away tasks leave the list; the transcript's card and the sheet's
+  // chips still reach them.
+  const tasks = sortedTasks(here && here.tasks).filter((task) => !task.dismissed);
+  for (const task of tasks.slice(0, TASK_ROWS)) {
+    const row = el("div", "q task task-" + task.status);
+    row.appendChild(el("span", "tag", t("tasks.status." + task.status)));
+    const name = el("span", "n", task.description + (task.activity ? " · " + task.activity : ""));
+    row.appendChild(name);
+    const open = el("button", "go", t("tasks.open"));
+    open.type = "button";
+    open.addEventListener("click", () => openTask(activeId, task.id));
+    row.appendChild(open);
+    // One × in the same place, saying what it does: running, it stops the
+    // task; ended, it only takes the row away.
+    const live = TASK_LIVE.has(task.status);
+    const close = el("button", "x", "×");
+    close.type = "button";
+    close.title = t(live ? "tasks.stop" : "tasks.dismiss");
+    close.setAttribute("aria-label", close.title);
+    close.addEventListener("click", () => void (live ? stopTask(activeId, task.id) : dismissTask(activeId, task.id)));
+    row.appendChild(close);
+    name.addEventListener("click", () => openTask(activeId, task.id));
+    container.appendChild(row);
+  }
+  if (tasks.length > TASK_ROWS) {
+    const more = el("button", "q task-more", t("tasks.more", { n: tasks.length - TASK_ROWS }));
+    more.type = "button";
+    more.addEventListener("click", () => openTask(activeId, tasks[TASK_ROWS].id));
+    container.appendChild(more);
+  }
+}
+
+/**
+ * Background results read into the conversation, as the transcript shows them:
+ * one line per task saying how it ended, each a way into its sheet. Where it
+ * sits is where the model read them.
+ */
+function taskCard(tasks) {
+  const card = el("div", "task-card");
+  card.appendChild(el("div", "task-card-head", t("tasks.cardTitle")));
+  for (const task of tasks) {
+    const row = el("div", "task-card-row task-" + task.status);
+    row.appendChild(el("span", "tag", t("tasks.status." + task.status)));
+    row.appendChild(el("span", "n", task.description));
+    const open = el("button", "go", t("tasks.open"));
+    open.type = "button";
+    // The conversation this card is in, which need not be the one on screen.
+    const session = P.id;
+    open.addEventListener("click", () => openTask(session, task.id));
+    row.appendChild(open);
+    card.appendChild(row);
+  }
+  // In the transcript's column, so it lines up with the messages around it.
+  const row = el("div", "column task-card-row-wrap");
+  row.appendChild(card);
+  P.node.appendChild(row);
+  follow();
+}
+
+/** A conversation's tasks changed: redraw what shows them. */
+function tasksChanged(session, tasks) {
+  pane(session).tasks = tasks || [];
+  if (session === activeId) renderQueued();
+  if (taskOpen && taskOpen.session === session) void paintTask();
+}
+
+function openTask(session, id) {
+  taskOpen = { session, id, stick: true };
+  ensureTaskSheet();
+  taskSheet.hidden = false;
+  void paintTask();
+  taskSheet.querySelector(".task-input").focus();
+}
+
+function closeTask() {
+  taskOpen = null;
+  if (taskSheet) taskSheet.hidden = true;
+}
+
+async function dismissTask(session, id) {
+  const body = await api("/task", { session, id, action: "dismiss" });
+  if (body.error) addNotice(body.error, "notice err");
+}
+
+async function stopTask(session, id) {
+  const body = await api("/task", { session, id, action: "stop" });
+  if (body.error) addNotice(body.error, "notice err");
+}
+
+function ensureTaskSheet() {
+  if (taskSheet) return;
+  taskSheet = el("div");
+  taskSheet.id = "task-sheet";
+  taskSheet.hidden = true;
+  taskSheet.setAttribute("role", "dialog");
+  taskSheet.setAttribute("aria-label", t("tasks.title"));
+
+  const head = el("div", "task-head");
+  const titles = el("div", "task-titles");
+  titles.appendChild(el("div", "task-title"));
+  titles.appendChild(el("div", "task-meta"));
+  head.appendChild(titles);
+  const stop = el("button", "task-stop", t("tasks.stop"));
+  stop.type = "button";
+  stop.addEventListener("click", () => { if (taskOpen) void stopTask(taskOpen.session, taskOpen.id); });
+  head.appendChild(stop);
+  const close = el("button", "task-close", "×");
+  close.type = "button";
+  close.title = t("tasks.close");
+  close.setAttribute("aria-label", t("tasks.close"));
+  close.addEventListener("click", closeTask);
+  head.appendChild(close);
+  taskSheet.appendChild(head);
+
+  taskSheet.appendChild(el("div", "task-chips"));
+  const log = el("div", "task-log");
+  // Follow new lines only while the reader is at the bottom; scrolling up to
+  // read something earlier must not be undone by the next tool.
+  log.addEventListener("scroll", () => {
+    if (taskOpen) taskOpen.stick = log.scrollHeight - log.scrollTop - log.clientHeight < 40;
+  });
+  taskSheet.appendChild(log);
+
+  // The box is the field and its send button together, as in the composer.
+  const form = el("form", "task-form");
+  const box = el("div", "task-box");
+  const input = el("textarea", "task-input");
+  input.rows = 2;
+  input.setAttribute("aria-label", t("tasks.messageLabel"));
+  const send = el("button", "primary task-send");
+  send.type = "submit";
+  send.title = t("tasks.send");
+  send.setAttribute("aria-label", t("tasks.send"));
+  send.appendChild(svgIcon("send"));
+  box.appendChild(input);
+  box.appendChild(send);
+  form.appendChild(box);
+  form.addEventListener("submit", (e) => {
+    e.preventDefault();
+    void sendTask(input);
+  });
+  input.addEventListener("keydown", (e) => {
+    if (e.key === "Enter" && !e.shiftKey && !e.isComposing) {
+      e.preventDefault();
+      void sendTask(input);
+    }
+  });
+  taskSheet.appendChild(form);
+
+  taskSheet.addEventListener("keydown", (e) => {
+    if (e.key === "Escape") closeTask();
+  });
+  document.body.appendChild(taskSheet);
+}
+
+async function sendTask(input) {
+  const text = input.value.trim();
+  if (!text || !taskOpen) return;
+  const { session, id } = taskOpen;
+  input.disabled = true;
+  const body = await api("/task", { session, id, action: "message", text });
+  input.disabled = false;
+  if (body.error) {
+    taskSheet.querySelector(".task-log").appendChild(el("div", "task-error", body.error));
+    return;
+  }
+  input.value = "";
+  input.focus();
+  if (taskOpen) taskOpen.stick = true;
+  void paintTask();
+}
+
+function taskElapsed(task) {
+  if (!task.startedAt) return "";
+  const seconds = Math.max(0, Math.round(((task.endedAt || Date.now()) - task.startedAt) / 1000));
+  return seconds < 60 ? seconds + "s" : Math.floor(seconds / 60) + "m" + (seconds % 60) + "s";
+}
+
+async function paintTask() {
+  if (!taskOpen || !taskSheet) return;
+  const { session, id } = taskOpen;
+  const seq = ++taskPaintSeq;
+  const body = await getJson("/task?session=" + encodeURIComponent(session) + "&id=" + encodeURIComponent(id));
+  if (!taskOpen || taskOpen.id !== id || taskOpen.session !== session || seq !== taskPaintSeq) return;
+  const log = taskSheet.querySelector(".task-log");
+  // Tool rows the reader opened stay open across a redraw: a running task
+  // redraws on every step, and an expanded result snapping shut is unreadable.
+  // Only for the task already on screen: another task's rows are other rows.
+  const opened = new Set();
+  if (taskSheet.dataset.painted === id) {
+    log.querySelectorAll(".task-tool").forEach((node, index) => { if (node.open) opened.add(index); });
+  }
+  taskSheet.dataset.painted = id;
+  if (body.error) {
+    log.replaceChildren(el("div", "task-error", body.error));
+    return;
+  }
+  const task = body.task;
+
+  taskSheet.querySelector(".task-title").textContent = task.description;
+  const meta = [t("tasks.status." + task.status), task.agentType, t("tasks.turns", { n: task.turns }), taskElapsed(task)];
+  if (task.activity) meta.push(task.activity);
+  taskSheet.querySelector(".task-meta").textContent = meta.filter(Boolean).join(" · ");
+  taskSheet.querySelector(".task-stop").hidden = !TASK_LIVE.has(task.status);
+
+  // Every task of this conversation, so a sheet opened on one reaches the rest.
+  // One row that scrolls sideways: rebuilt on every change, so it keeps
+  // where it was scrolled to, and brings the open task's chip into view.
+  const chips = taskSheet.querySelector(".task-chips");
+  const scrolled = chips.scrollLeft;
+  chips.replaceChildren();
+  const all = sortedTasks(pane(session).tasks);
+  chips.hidden = all.length < 2;
+  let current = null;
+  for (const other of all) {
+    const chip = el("button", "task-chip task-" + other.status + (other.id === id ? " on" : ""), other.description);
+    chip.type = "button";
+    chip.addEventListener("click", () => openTask(session, other.id));
+    chips.appendChild(chip);
+    if (other.id === id) current = chip;
+  }
+  chips.scrollLeft = scrolled;
+  if (current && (current.offsetLeft < chips.scrollLeft || current.offsetLeft + current.offsetWidth > chips.scrollLeft + chips.clientWidth)) {
+    chips.scrollLeft = current.offsetLeft - 16;
+  }
+
+  log.replaceChildren();
+  for (const entry of body.transcript || []) {
+    if (entry.role === "tool") {
+      const tool = el("details", "task-tool" + (entry.isError ? " err" : ""));
+      const summary = el("summary");
+      summary.appendChild(el("span", "task-tool-name", entry.name));
+      summary.appendChild(el("span", "task-tool-input", entry.text));
+      tool.appendChild(summary);
+      if (entry.result) tool.appendChild(el("pre", "task-tool-result", entry.result));
+      if (opened.has(log.querySelectorAll(".task-tool").length)) tool.open = true;
+      log.appendChild(tool);
+    } else if (entry.role === "assistant") {
+      const msg = el("div", "task-msg assistant");
+      msg.appendChild(renderMarkdown(entry.text));
+      log.appendChild(msg);
+    } else {
+      log.appendChild(el("div", "task-msg user", entry.text));
+    }
+  }
+  if (!log.childElementCount) log.appendChild(el("div", "task-empty", t("tasks.empty")));
+  if (task.worktree) log.appendChild(el("div", "task-note", task.worktree));
+  if (task.error) log.appendChild(el("div", "task-error", task.error));
+  if (TASK_LIVE.has(task.status)) {
+    const working = el("div", "task-working");
+    working.appendChild(el("span", "spinner"));
+    log.appendChild(working);
+  }
+  if (taskOpen.stick) log.scrollTop = log.scrollHeight;
+
+  const input = taskSheet.querySelector(".task-input");
+  const stopped = task.status === "cancelled";
+  input.disabled = stopped;
+  taskSheet.querySelector(".task-send").disabled = stopped;
+  input.placeholder = t(stopped ? "tasks.placeholder.stopped" : TASK_LIVE.has(task.status) ? "tasks.placeholder.running" : "tasks.placeholder.ended");
+}
+`;
+//# sourceMappingURL=tasks.js.map

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

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

package/dist/page/client/terminal.js

@@ -84,7 +84,7 @@ function terminalActive() {
  * Asked again for the project already on show it hides, which is what the
  * tab's button wants; force keeps it open, for the menus.
  */
-async function openTerminalIn(cwd, force) {
+async function openTerminalIn(cwd, force, opts) {
   if (!cwd) return;
   if (terminalShownFor(cwd) && !force) return hideTerminal();
   track("panel_opened", { panel: "terminal" });
@@ -115,12 +115,28 @@ async function openTerminalIn(cwd, force) {
       const entry = terminalCreate(lib, cwd);
       void terminalAttach(entry, found, true);
     }
-    if (!group.tabs.length) await terminalNew(cwd);
-    else group.active = group.tabs[group.tabs.length - 1];
-  } else if (!group.tabs.length) {
+    if (!group.tabs.length && !(opts && opts.bare)) await terminalNew(cwd);
+    else if (group.tabs.length) group.active = group.tabs[group.tabs.length - 1];
+  } else if (!group.tabs.length && !(opts && opts.bare)) {
     await terminalNew(cwd);
   }
-  if (terminalCwd === cwd) terminalSelect(group.active);
+  if (terminalCwd === cwd && group.active) terminalSelect(group.active);
+}
+
+/**
+ * Hand the project to Claude Code: a new terminal tab running the user's own
+ * claude, signed in however they signed it in. OHarness starts it and stays
+ * out of the way — no login of ours, no token read — which is what keeps a
+ * Claude plan usable from here at all.
+ */
+async function openClaudeCode(cwd, resume) {
+  if (!cwd) return;
+  track("panel_opened", { panel: "claude-code" });
+  // bare: the panel without the plain shell it would otherwise start, since
+  // the tab being opened is the one that was asked for.
+  await openTerminalIn(cwd, true, { bare: true });
+  // resume: a session an @claude reply ran in, opened in Claude Code itself.
+  if (terminalCwd === cwd) await terminalNew(cwd, "claude", resume);
 }
 
 function hideTerminal() {
@@ -135,9 +151,13 @@ function terminalFollow(cwd) {
 }
 
 /** Another shell in the project on show, as a new tab in front. */
-async function terminalNew(cwd) {
+async function terminalNew(cwd, run, resume) {
   const lib = await loadTerminalLib();
   const entry = terminalCreate(lib, cwd);
+  // Only the first shell runs it: a tab restarted by typing after an exit is
+  // an ordinary shell, not a second Claude Code the user did not ask for.
+  if (run) entry.run = run;
+  if (run && resume) entry.resume = resume;
   terminalGroup(cwd).active = entry;
   terminalSelect(entry);
   await terminalStart(entry);
@@ -266,8 +286,15 @@ async function terminalStart(entry) {
   entry.id = null;
   if (replace) entry.term.reset();
   terminalFit(entry);
+  const run = entry.run;
+  const resume = entry.resume;
+  entry.run = undefined;
+  entry.resume = undefined;
   const body = await api("/term/open", {
-    cwd: entry.cwd, cols: entry.term.cols, rows: entry.term.rows, ...(replace ? { replace } : {}),
+    cwd: entry.cwd, cols: entry.term.cols, rows: entry.term.rows,
+    ...(replace ? { replace } : {}),
+    ...(run ? { run } : {}),
+    ...(resume ? { resume } : {}),
   });
   entry.starting = false;
   if (!body || body.error) {

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

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

package/dist/page/client/theme.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Themes the agent proposes, and the one in use.
+ *
+ * A proposal arrives as a card in the conversation that asked for it. Nothing
+ * changes until the person acts on the card: Preview tries it on this page
+ * only, Apply makes it the theme everywhere, Discard drops it. The applied
+ * theme is printed into the page by the server and replaced here when another
+ * window changes it.
+ *
+ * Safe mode is the way out of a theme that made the page unreadable, so it is
+ * the one thing here that needs no theme, no card and no conversation: the
+ * page loaded with ?theme=default, or the shortcut below, and custom colours
+ * are off in this window until it is pressed again.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export declare const THEME: string;