@oharness/server 0.8.0 → 0.9.1

package/dist/server.js

@@ -1,5 +1,6 @@
 import { createServer } from "node:http";
 import { randomUUID, timingSafeEqual } from "node:crypto";
+import { createReadStream } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { homedir } from "node:os";
@@ -17,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";
@@ -28,7 +29,8 @@ import { readPrefs, writePrefs } from "./prefs.js";
 import { sortModelsForDisplay } from "./model-order.js";
 import { loadModelsDev, releaseDateOf, releaseDates } from "@oharness/engine/providers/models-dev.ts";
 import { listDirectories, pickDirectory, pickFiles, revealDirectory } from "./pick.js";
-import { browseFiles, searchFiles, within } from "./files.js";
+import { TerminalHub, terminalAsset } from "./terminal.js";
+import { PREVIEW_MEDIA, browseFiles, previewFile, resolveFile, searchFiles, within } from "./files.js";
 import { analyticsState } from "./analytics.js";
 import { PAGE } from "./page.js";
 import { browserState, parseInputEvent, streamFrames } from "./browser-pane.js";
@@ -36,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.
  *
@@ -45,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.
  *
@@ -433,6 +445,7 @@ export async function startWebServer(opts) {
         broadcast(announce(entry));
         notify(entry);
     });
+    const terminals = new TerminalHub();
     const server = createServer((req, res) => {
         void handle(req, res).catch((err) => {
             send(res, 500, { error: errorMessage(err) });
@@ -449,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;
@@ -1069,6 +1082,137 @@ export async function startWebServer(opts) {
                 const result = await revealDirectory(dir);
                 return send(res, "error" in result ? 500 : 200, result);
             }
+            /*
+             * The files pane: a project's tree one folder at a time, one file's
+             * contents, and an image's bytes. Addressed by the project's folder
+             * rather than a session, because the pane opens from the sidebar's
+             * project menu too, where there may be no session in that tree at all.
+             */
+            // The embedded terminal. One shell per project folder; see terminal.ts.
+            case "POST /term/open": {
+                const body = await readJson(req);
+                const root = await projectRoot(typeof body.cwd === "string" ? body.cwd : null);
+                if (!root)
+                    return send(res, 400, { error: "not a folder" });
+                const replace = typeof body.replace === "string" ? body.replace : undefined;
+                const result = await terminals.open(root, { cols: body.cols, rows: body.rows }, replace);
+                return send(res, "error" in result ? 500 : 200, result);
+            }
+            case "GET /term/list": {
+                const root = await projectRoot(url.searchParams.get("cwd"));
+                if (!root)
+                    return send(res, 400, { error: "not a folder" });
+                return send(res, 200, { terminals: terminals.list(root) });
+            }
+            case "GET /term/stream": {
+                if (!terminals.stream(url.searchParams.get("id") ?? "", res)) {
+                    return send(res, 404, { error: "no such terminal" });
+                }
+                return;
+            }
+            case "POST /term/input": {
+                const body = await readJson(req);
+                const ok = terminals.input(String(body.id ?? ""), body.data);
+                return send(res, ok ? 200 : 404, ok ? { ok } : { error: "no such terminal" });
+            }
+            case "POST /term/resize": {
+                const body = await readJson(req);
+                const ok = terminals.resize(String(body.id ?? ""), body.cols, body.rows);
+                return send(res, ok ? 200 : 404, ok ? { ok } : { error: "no such terminal" });
+            }
+            case "POST /term/close": {
+                const body = await readJson(req);
+                terminals.close(String(body.id ?? ""));
+                return send(res, 200, { ok: true });
+            }
+            case "GET /vendor/xterm.js":
+            case "GET /vendor/xterm.css":
+            case "GET /vendor/xterm-fit.js": {
+                const file = terminalAsset(url.pathname);
+                if (!file)
+                    return send(res, 404, { error: "terminal assets are not installed" });
+                const data = await readFile(file);
+                res.writeHead(200, {
+                    "content-type": url.pathname.endsWith(".css") ? "text/css; charset=utf-8" : "text/javascript; charset=utf-8",
+                    "content-length": data.byteLength,
+                    "cache-control": "private, max-age=3600",
+                });
+                res.end(data);
+                return;
+            }
+            case "GET /files/tree": {
+                const root = await projectRoot(url.searchParams.get("cwd"));
+                if (!root)
+                    return send(res, 400, { error: "not a folder" });
+                return send(res, 200, await browseFiles(root, url.searchParams.get("dir") ?? "", { all: true }));
+            }
+            case "GET /files/read": {
+                const root = await projectRoot(url.searchParams.get("cwd"));
+                if (!root)
+                    return send(res, 400, { error: "not a folder" });
+                const result = await previewFile(root, url.searchParams.get("path") ?? "");
+                return send(res, "error" in result ? 404 : 200, result);
+            }
+            case "GET /files/raw": {
+                const root = await projectRoot(url.searchParams.get("cwd"));
+                const full = root && resolveFile(root, url.searchParams.get("path") ?? "");
+                const media = full && PREVIEW_MEDIA[path.extname(full).toLowerCase()];
+                if (!full || !media)
+                    return send(res, 415, { error: "not previewable" });
+                let size;
+                try {
+                    const info = await stat(full);
+                    if (!info.isFile())
+                        return send(res, 404, { error: "not a file" });
+                    size = info.size;
+                }
+                catch {
+                    return send(res, 404, { error: "no such file" });
+                }
+                // A video is seeked by asking for the bytes at the new position, and
+                // one too long to buffer whole would not play at all without this.
+                const range = /^bytes=(\d*)-(\d*)$/.exec(req.headers.range ?? "");
+                let first = 0;
+                let last = size - 1;
+                if (range && (range[1] || range[2])) {
+                    if (range[1]) {
+                        first = Number(range[1]);
+                        if (range[2])
+                            last = Math.min(Number(range[2]), size - 1);
+                    }
+                    else {
+                        first = Math.max(0, size - Number(range[2]));
+                    }
+                    if (first > last || first >= size) {
+                        res.writeHead(416, { "content-range": `bytes */${size}` });
+                        res.end();
+                        return;
+                    }
+                }
+                const partial = Boolean(range && (range[1] || range[2]));
+                res.writeHead(partial ? 206 : 200, {
+                    "content-type": media.type,
+                    "content-length": last - first + 1,
+                    "accept-ranges": "bytes",
+                    ...(partial ? { "content-range": `bytes ${first}-${last}/${size}` } : {}),
+                    "x-content-type-options": "nosniff",
+                    // Served inert: this is same-origin to a page that holds the session
+                    // token, and an SVG is a document that can script. A PDF is left
+                    // unsandboxed, because the browser's viewer will not open inside a
+                    // sandbox; the viewer runs in its own process, apart from the page.
+                    ...(media.kind === "pdf"
+                        ? {}
+                        : { "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox" }),
+                    "cache-control": "private, no-store",
+                });
+                if (req.method === "HEAD" || size === 0)
+                    return void res.end();
+                const stream = createReadStream(full, { start: first, end: last });
+                stream.on("error", () => res.destroy());
+                res.on("close", () => stream.destroy());
+                stream.pipe(res);
+                return;
+            }
             case "POST /pick": {
                 const body = await readJson(req);
                 // The dialog opens on this machine's desktop, which is the same
@@ -1990,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.
              *
@@ -2003,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
@@ -2010,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.
@@ -2082,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,
                     })),
@@ -3437,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()) {
@@ -3603,6 +3802,7 @@ export async function startWebServer(opts) {
                 unsubscribe();
             for (const harness of harnesses.values())
                 harness.cloudConnectors.close();
+            terminals.closeAll();
             for (const client of clients)
                 client.end();
             clients.clear();
@@ -3946,6 +4146,13 @@ async function readBody(req, limit) {
  * shape. Anything else is inlined as text under its filename — a base64 blob
  * of a zip would burn context and tell the model nothing.
  */
+/** A project folder named by the page, resolved, or undefined if it is not one. */
+async function projectRoot(dir) {
+    if (!dir)
+        return undefined;
+    const full = path.resolve(dir);
+    return (await isDirectory(full)) ? full : undefined;
+}
 /** Whether a chosen path is a folder; anything unreadable is treated as a file. */
 async function isDirectory(target) {
     try {