@oharness/server 0.9.0 → 0.9.1

package/dist/server.js

@@ -18,7 +18,7 @@ import { visibleText } from "@oharness/engine/core/types.ts";
 import { errorMessage } from "@oharness/engine/core/errors.ts";
 import { officialBaseUrl, officialTeam } from "@oharness/engine/auth/providers/official.ts";
 import { loadUserConfig, updateUserConfig } from "@oharness/engine/config.ts";
-import { EXTENSION_ID, EXTENSION_INSTALL_URL } from "@oharness/engine/browser/host-manifest.ts";
+import { EXTENSION_IDS, EXTENSION_INSTALL_URL } from "@oharness/engine/browser/host-manifest.ts";
 import { announcePresence } from "@oharness/engine/browser/presence.ts";
 import { extensionHostReachable } from "@oharness/engine/browser/socket.ts";
 import { RoutineRunner } from "@oharness/engine/schedule/runner.ts";
@@ -38,6 +38,7 @@ import { artifactDocument, sendArtifact } from "./artifacts.js";
 import { sendProjectExport } from "./project-export.js";
 import { ArtifactStore, getArtifactStore, isCanvas, isValidArtifactId, restoreArtifacts, } from "@oharness/engine/artifacts/store.ts";
 import { accountTeams, publishArtifact, unpublishArtifact } from "@oharness/engine/artifacts/publish.ts";
+import { accountUsage } from "./account-usage.js";
 /**
  * How many stored sessions the usage page counts.
  *
@@ -47,6 +48,15 @@ import { accountTeams, publishArtifact, unpublishArtifact } from "@oharness/engi
  * stops short says so rather than reading as the whole history.
  */
 const USAGE_SESSION_SCAN = 200;
+/**
+ * How far back the sessions page reads, and how many rows it sends at a time.
+ *
+ * The page is "every session that spent something", so it reads further back
+ * than the usage summary does — but still a bounded number, and it says when
+ * it stopped. A page at a time because the list is drawn as it is scrolled.
+ */
+const USAGE_SESSIONS_SCAN = 5000;
+const USAGE_SESSIONS_PAGE = 50;
 /**
  * How many trail entries one read of every session may return.
  *
@@ -452,7 +462,7 @@ export async function startWebServer(opts) {
                 "content-type": "text/html; charset=utf-8",
                 // Framed by itself and by the OHarness extension's side panel, and by
                 // nothing else: a page that drives a shell is not one to embed.
-                "content-security-policy": `frame-ancestors 'self' chrome-extension://${EXTENSION_ID}`,
+                "content-security-policy": `frame-ancestors 'self' ${EXTENSION_IDS.map((id) => `chrome-extension://${id}`).join(" ")}`,
             });
             res.end(PAGE);
             return;
@@ -2124,6 +2134,22 @@ export async function startWebServer(opts) {
                     })),
                 });
             }
+            /**
+             * The account's spend, from the site's ledger rather than this machine.
+             *
+             * What `GET /usage` cannot see: chat from other devices, and every image,
+             * video and clip of audio, which are billed by the gateway and settled
+             * after the call that started them. Answers `signedIn: false` for a
+             * machine with no account, so the page falls back to its own figures.
+             */
+            case "GET /usage/account": {
+                return send(res, 200, await accountUsage({
+                    token: await current.harness.accountToken(),
+                    team: officialTeam(),
+                    site: siteUrl(),
+                    query: url.searchParams,
+                }));
+            }
             /**
              * What has been spent on this machine, and on what.
              *
@@ -2137,6 +2163,33 @@ export async function startWebServer(opts) {
              * mid-turn has already spent money its metadata will not know about
              * until the turn lands, and the page asking is the page that spent it.
              */
+            /**
+             * Every session that spent something, newest first, a page at a time.
+             *
+             * The usage page lists the latest few; this is the rest of them, with a
+             * search over the title and the model. Filtered here rather than in the
+             * page so a search reaches sessions the page has not loaded yet.
+             */
+            case "GET /usage/sessions": {
+                const { stored, rows } = await usageRows(USAGE_SESSIONS_SCAN);
+                const query = (url.searchParams.get("q") || "").trim().toLowerCase();
+                const offset = Math.max(0, Number(url.searchParams.get("offset")) || 0);
+                const limit = Math.min(200, Math.max(1, Number(url.searchParams.get("limit")) || USAGE_SESSIONS_PAGE));
+                const list = [...rows.values()]
+                    .filter((row) => row.costUsd > 0 || row.input || row.output || row.cacheRead || row.cacheWrite)
+                    .filter((row) => !query || (row.title || "").toLowerCase().includes(query) || row.model.toLowerCase().includes(query))
+                    .sort((a, b) => b.updatedAt - a.updatedAt);
+                return send(res, 200, {
+                    sessions: list.slice(offset, offset + limit).map((row) => ({
+                        ...row,
+                        current: row.id === current.session.id,
+                    })),
+                    total: list.length,
+                    offset,
+                    more: offset + limit < list.length,
+                    truncated: stored.length >= USAGE_SESSIONS_SCAN,
+                });
+            }
             case "GET /usage": {
                 // How far back the page is asking about. Everything below — the
                 // totals, the models, the sessions and the curve — is that window and
@@ -2144,33 +2197,7 @@ export async function startWebServer(opts) {
                 // from the chart under it is worse than no figure.
                 const window = usageWindow(url.searchParams.get("range"), url.searchParams.get("from"), url.searchParams.get("to"));
                 const { since, until } = window;
-                const stored = await current.harness.listSessions(USAGE_SESSION_SCAN);
-                const rows = new Map();
-                for (const meta of stored) {
-                    rows.set(meta.id, {
-                        id: meta.id,
-                        title: meta.title,
-                        model: meta.model,
-                        updatedAt: meta.updatedAt,
-                        turns: meta.turns,
-                        costUsd: meta.costUsd || 0,
-                        ...tokensOf(meta.usage),
-                    });
-                }
-                for (const runner of runners.values()) {
-                    const sess = runner.session;
-                    rows.set(sess.id, {
-                        id: sess.id,
-                        title: sess.title,
-                        model: sess.model.id,
-                        // A session opened but not yet spoken to has no stored copy and no
-                        // last-updated time of its own; it is here, so it is now.
-                        updatedAt: rows.get(sess.id)?.updatedAt ?? Date.now(),
-                        turns: sess.turns,
-                        costUsd: sess.costUsd,
-                        ...tokensOf(sess.usage),
-                    });
-                }
+                const { stored, rows } = await usageRows(USAGE_SESSION_SCAN);
                 // Sessions that never sent anything are dropped: they contribute zero
                 // to every total here, and a page about what was spent that opens with
                 // a screen of "$0.0000 · 0 tokens" buries the ones that cost money.
@@ -2216,7 +2243,7 @@ export async function startWebServer(opts) {
                     models: [...byModel.values()].sort((a, b) => b.costUsd - a.costUsd),
                     // A page of them is a page nobody reads. The rest are counted in the
                     // totals above, which is where a number that large belongs.
-                    sessions: list.slice(0, 20).map((row) => ({
+                    sessions: list.slice(0, 10).map((row) => ({
                         ...row,
                         current: row.id === current.session.id,
                     })),
@@ -3571,6 +3598,44 @@ export async function startWebServer(opts) {
      * log carries. Everything else is folded from the revision logs, which is
      * what makes the panel's answer independent of which tabs are open.
      */
+    /**
+     * One row per session: the stored ones, with the open ones laid over their
+     * stored copy. A session mid-turn has already spent money its metadata will
+     * not know about until the turn lands, and the page asking is the page that
+     * spent it.
+     */
+    async function usageRows(scan) {
+        const stored = await current.harness.listSessions(scan);
+        const rows = new Map();
+        for (const meta of stored) {
+            rows.set(meta.id, {
+                id: meta.id,
+                cwd: meta.cwd,
+                title: meta.title,
+                model: meta.model,
+                updatedAt: meta.updatedAt,
+                turns: meta.turns,
+                costUsd: meta.costUsd || 0,
+                ...tokensOf(meta.usage),
+            });
+        }
+        for (const runner of runners.values()) {
+            const sess = runner.session;
+            rows.set(sess.id, {
+                id: sess.id,
+                cwd: rows.get(sess.id)?.cwd ?? runner.harness.cwd,
+                title: sess.title,
+                model: sess.model.id,
+                // A session opened but not yet spoken to has no stored copy and no
+                // last-updated time of its own; it is here, so it is now.
+                updatedAt: rows.get(sess.id)?.updatedAt ?? Date.now(),
+                turns: sess.turns,
+                costUsd: sess.costUsd,
+                ...tokensOf(sess.usage),
+            });
+        }
+        return { stored, rows };
+    }
     async function artifactCatalogue() {
         const groups = [];
         for (const runner of runners.values()) {