@oharness/server 0.7.1 → 0.9.0

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

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

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

@@ -0,0 +1,7 @@
+/**
+ * The event stream. Everything the server says happened arrives here and is
+ * turned into a change on screen.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export declare const EVENTS: string;

package/dist/page/client/events.js

@@ -0,0 +1,288 @@
+/**
+ * The event stream. Everything the server says happened arrives here and is
+ * turned into a change on screen.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export const EVENTS = String.raw `
+// --- events ---------------------------------------------------------------
+
+const events = new EventSource(q("/events"));
+events.onerror = () => { ctxText.textContent = "offline"; };
+events.onmessage = (message) => {
+  const event = JSON.parse(message.data);
+
+  // Session-scoped events render into their own pane; the rest (model lists,
+  // notices about discovery) apply to the page.
+  if (event.session) {
+    P = pane(event.session);
+    if (!panes.has(activeId)) activeId = event.session;
+  }
+
+  switch (event.type) {
+    case "connection_card":
+      connectionCard(event.card);
+      break;
+    case "prompt": {
+      // The previews this tab made a moment ago, so a message just sent looks
+      // like the same message will after a reload — the transcript has not
+      // been written yet, so there is nothing at /attachment to ask for.
+      const sent = sentPreviews.get(event.session) || [];
+      sentPreviews.delete(event.session);
+      addUser(event.text || "", sent);
+      startWorking(t("work.thinking"));
+      const unshown = (event.attachments || []).filter(
+        (name) => !sent.some((image) => image.name === name),
+      );
+      if (unshown.length) addNotice("attached: " + unshown.join(", "));
+      // Without this a turn that reads three files looks like it went and
+      // found them by itself, rather than being pointed at them.
+      if (event.references && event.references.length) {
+        addNotice("referenced: " + event.references.map((ref) => ref.value).join(", "));
+      }
+      setBusy(true);
+      break;
+    }
+
+    case "text_delta":
+      sealThinking();
+      stopWorking();
+      if (!P.streaming) { P.streaming = { text: "", node: el("div") }; assistantTurn().appendChild(P.streaming.node); }
+      P.streaming.text += event.text;
+      // Re-render the whole block: markdown is not incremental, and a half
+      // fence rendered as literal text then rewritten looks worse than this.
+      P.streaming.node.replaceChildren(renderMarkdown(P.streaming.text));
+      follow();
+      break;
+
+    case "thinking_delta": {
+      // Tracked on the turn rather than found with :last-child, which stopped
+      // matching the moment anything else was appended after it.
+      let block = P.turn && P.turn.__thinking;
+      if (!block) {
+        // The reasoning block carries its own spinner and streams visible text,
+        // so the waiting row above it would be a second "Thinking" saying less.
+        stopWorking();
+        block = el("details", "thinking");
+        block.open = true;
+        const summary = el("summary");
+        summary.appendChild(el("span", "spinner"));
+        summary.appendChild(el("span", "t-label", t("work.thinking")));
+        block.appendChild(summary);
+        block.appendChild(el("div", "thinking-body"));
+        assistantTurn().appendChild(block);
+        P.turn.__thinking = block;
+        P.turn.__thinkingStart = Date.now();
+      }
+      block.querySelector(".thinking-body").textContent += event.text;
+      follow();
+      break;
+    }
+
+    // One event carrying the whole list rather than add/remove pairs: the
+    // page redraws from it, so a dropped event cannot leave a chip behind for
+    // a message that was sent ten minutes ago.
+    case "queue":
+      P.queued = event.queued || [];
+      renderQueued();
+      break;
+
+    case "assistant_message": P.streaming = null; break;
+    case "turn_start": dropPendingTools(); break;
+    // A session named from its first prompt, or renamed: the tab and the
+    // sidebar row both carry the name.
+    case "title":
+      P.title = event.title;
+      paintTabs();
+      void loadSessions();
+      break;
+    case "tool_pending":
+      sealThinking();
+      pendingToolCard(event.toolCallId, event.toolName);
+      startWorking(toolTitle(event.toolName));
+      break;
+    case "tool_start":
+      sealThinking();
+      browserToolStarted(event.session, event.toolName);
+      toolCard(event.toolCallId, event.title, event.toolName, event.input);
+      startWorking(event.toolName);
+      break;
+    case "tool_end":
+      finishTool(event.toolCallId, event.result && event.result.content, event.durationMs,
+        event.result && event.result.isError);
+      // Back to waiting on the model until the next tool or the next token.
+      startWorking(t("work.thinking"));
+      break;
+
+    case "artifact": {
+      // A revision the user typed, in a canvas they are looking at right now.
+      // It gets neither a card nor a redraw: the transcript records what
+      // happened in the conversation and this did not happen there, and
+      // rebuilding the frame would reload the editor under the hands of the
+      // person using it — losing their viewport, their selection and their
+      // undo history at the exact moment they pressed Save.
+      void refreshArtifactCount();
+      if (event.artifact.author === "user") {
+        const mine = artifacts.findIndex((a) => a.id === event.artifact.id);
+        if (mine >= 0) artifacts[mine] = event.artifact;
+        artifactVersion.delete(event.artifact.id);
+        if (selectedArtifact === event.artifact.id) refreshArtifactBar(event.artifact);
+        break;
+      }
+
+      // A card in the conversation, not only a row in the drawer. The drawer
+      // is a place you have to know to look; the transcript is where the user
+      // already is, and an artifact is a thing that happened in it.
+      artifactCard(event.artifact);
+      // The descriptor carries no body, so the list is patched from it and only
+      // the visible artifact is refetched. A revision of something the user is
+      // not looking at costs nothing.
+      const at = artifacts.findIndex((a) => a.id === event.artifact.id);
+      const before = at >= 0 ? artifacts[at] : null;
+      if (at >= 0) artifacts[at] = event.artifact;
+      else artifacts = artifacts.concat([event.artifact]);
+      // A new revision moves the view back to the latest: the user is watching
+      // the model work, and pinning them to v3 while it writes v4 is wrong.
+      // Only a revision, though — this event also fires when an artifact is
+      // published or withdrawn, and that must not yank the reader off the
+      // version they deliberately went back to.
+      if (!before || before.version !== event.artifact.version) {
+        artifactVersion.delete(event.artifact.id);
+      }
+      const wasSelected = selectedArtifact === event.artifact.id;
+      renderArtifacts(artifacts);
+      repaintPanel();
+      if (wasSelected) void showArtifact(event.artifact.id);
+      // First artifact of the session opens the drawer, the way the first file
+      // change makes the review button appear. Later ones do not steal focus.
+      // Not on a phone, where the drawer is the whole screen: it would cover
+      // the reply that produced the artifact.
+      if (artifacts.length === 1 && !isPhone()) shelf.classList.add("open");
+      break;
+    }
+
+    case "permission_request": showAsk(event); break;
+    case "question_request": questionCard(event); break;
+    case "question_result": settleQuestion(event); break;
+    // Sent once per (re)connect, after the replay: a card this page still
+    // shows as open but the server no longer holds closed while we were away.
+    case "pending_interactions":
+      for (const entry of questionCards.values()) {
+        if ((entry.status === "open" || entry.status === "sending") && !event.ids.includes(entry.id)) closeQuestion(entry.id);
+      }
+      break;
+    // Answered in another window, or the turn waiting on it stopped.
+    case "interaction_closed":
+      withdrawAsk(event.id);
+      closeQuestion(event.id);
+      break;
+    case "permission_result":
+      if (!event.allowed) addNotice("denied: " + (event.reason || ""), "err");
+      else if (event.remembered) addNotice("remembered: " + event.remembered);
+      break;
+
+    case "compacted":
+      addNotice("compacted " + event.droppedMessages + " messages (" +
+        event.tokensBefore + " → " + event.tokensAfter + " tokens)");
+      break;
+
+    case "model_changed": addNotice(event.from + " → " + event.to); break;
+    case "memory_recall":
+      addNotice(t("memory.recalled", { count: event.notes.length, list: event.notes.map((note) => note.summary).join("; ") }));
+      break;
+    case "memory_extracted":
+      addNotice(t("memory.extracted", { count: event.notes.length, list: event.notes.map((note) => note.summary).join("; ") }));
+      break;
+    case "notice": addNotice(event.message); break;
+    // A routine ran: its session is new, and the Routines page, if open, has
+    // a result to show.
+    case "sessions":
+      void loadSessions();
+      if (shownPanel === "nav-routines") void showRoutines();
+      break;
+    case "error":
+      P.streaming = null;
+      // A 402 is not an error to print, it is a screen to open. What the
+      // gateway sends back is an HTTP body — a true sentence, in English,
+      // with nothing in it to click — and printing that was the whole of the
+      // old behaviour on the one failure the user can actually fix.
+      if (event.status === 402) { openPaywall(); break; }
+      // A 401 is the other status worth reading rather than printing. The
+      // credential the request went out with was refused, which means the
+      // panel's belief that this vendor is connected is now known to be
+      // wrong — and the vendor's own JSON, pasted into the transcript, tells
+      // the user neither that nor what to do about it.
+      if (event.status === 401 && event.provider) { openReconnect(event.provider); break; }
+      // Never signed in at all. It carries no status — nothing was sent — but
+      // it is the same screen as a refused key, and the engine's sentence ends
+      // at "or sign in" precisely because where that is done differs per
+      // frontend. Here it is a dialog, one click away.
+      if (event.code === "no_credentials" && event.provider) { openSignIn(event.provider); break; }
+      addNotice("✗ " + event.error, "err");
+      break;
+    case "done": {
+      sealThinking();
+      stopWorking();
+      dropPendingTools();
+      // The fork point comes from the server: one reply can span several
+      // stored messages, and a client-side count would drift the moment tool
+      // results land in a message of their own.
+      const finished = P.turn;
+      P.streaming = null;
+      P.turn = null;
+      if (finished) {
+        void getJson("/history")
+          .then((body) => {
+            const last = (body.entries || []).at(-1);
+            if (last) turnActions(finished, last.keepMessages);
+          })
+          .catch(() => {});
+      }
+      break;
+    }
+    case "idle":
+      applyState(event.state);
+      renderChanges(event.changes);
+      void loadSessions();
+      break;
+    case "state": applyState(event.state); break;
+    case "connectors_changed":
+      if (authorizing === event.connector) authorizing = null;
+      offer = { connectors: event.connectors, plugins: event.plugins || [], skills: event.skills || [] };
+      // The failure already said what went wrong; this only announces the
+      // half that is worth celebrating.
+      if (event.authorized) addNotice(t("market.authorized", { name: event.connector }));
+      paintMarket();
+      break;
+    case "models_changed":
+      void loadModels().then(() => {
+        addNotice("discovered " + event.discovered + " models from " + event.provider);
+        // A sign-in that finished in a browser tab lands here, not in the
+        // click that started it — so whatever was waiting on it is told now.
+        const waiting = signedInWaiters.get(event.provider);
+        if (waiting) {
+          signedInWaiters.delete(event.provider);
+          waiting();
+          return;
+        }
+        if (document.getElementById("nav-models").classList.contains("active")) void showModels();
+      });
+      break;
+    // Also fired when another window switches the project, which moves the
+    // working directory out from under whatever panel is open here.
+    case "session_changed":
+      applyState(event.state);
+      renderHistory(event.entries);
+      // Artifacts are per-session, so the shelf has to be rebuilt rather than
+      // left showing the previous session's work under the new transcript.
+      selectedArtifact = null;
+      artifactVersion.clear();
+      shelf.classList.remove("open", "full");
+      document.body.classList.remove("shelf-full");
+      void loadArtifacts();
+      void loadProjects().then(repaintPanel);
+      break;
+  }
+};
+`;
+//# sourceMappingURL=events.js.map

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

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

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

@@ -0,0 +1,7 @@
+/**
+ * The files pane — a project's tree beside the file picked from it — and the
+ * terminal that opens in the same folder.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export declare const FILES: string;