@oharness/server 0.6.0 → 0.7.1

package/dist/server.js

@@ -9,22 +9,27 @@ import { connectorConfig, officialConnectors } from "@oharness/engine/mcp/regist
 import { missingSecrets } from "@oharness/engine/mcp/secrets.ts";
 import { connectorIcon, providerSites, siteIcon } from "./icons.js";
 import { checkAnswer } from "@oharness/engine/tools/questions.ts";
+import { isFree } from "@oharness/engine/providers/types.ts";
 import { PERMISSION_MODES } from "@oharness/engine/agent/permissions.ts";
 import { canDisableThinking, effectiveEffort, isEffortChoice, thinkingFor, } from "@oharness/engine/providers/types.ts";
 import { isReadable } from "@oharness/engine/agent/workspace.ts";
 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 { updateUserConfig } from "@oharness/engine/config.ts";
+import { loadUserConfig, updateUserConfig } from "@oharness/engine/config.ts";
+import { RoutineRunner } from "@oharness/engine/schedule/runner.ts";
 import { accountsConfigured, browserKeyUrl, browserSignInUrl, exchangeHandoff, siteUrl, } from "@oharness/engine/auth/providers/account.ts";
 import { ChangeLedger } from "./changes.js";
-import { addProject, ensureProject, listProjects, removeProject } from "./projects.js";
+import { addProject, ensureProject, listProjects, removeProject, renameProject } from "./projects.js";
 import { readPrefs, writePrefs } from "./prefs.js";
-import { listDirectories, pickDirectory, pickFiles } from "./pick.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 { analyticsState } from "./analytics.js";
 import { PAGE } from "./page.js";
 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";
 /**
@@ -163,6 +168,21 @@ function tokensOf(usage) {
         cacheWrite: usage.cacheWriteTokens || 0,
     };
 }
+/**
+ * Release dates from the bundled models.dev snapshot, read once.
+ *
+ * Its date wins over a model's own: a listing's `created` is sometimes the
+ * time it was listed, or a constant, and the snapshot knows most of the models
+ * a gateway or an aggregator relays under the same name.
+ */
+let knownDates;
+async function withReleaseDates(models) {
+    const dates = await (knownDates ??= loadModelsDev().then(releaseDates));
+    return models.map((model) => {
+        const known = releaseDateOf(dates, model.model);
+        return known === undefined || known === model.releasedAt ? model : { ...model, releasedAt: known };
+    });
+}
 export async function startWebServer(opts) {
     const token = randomUUID();
     /**
@@ -184,7 +204,7 @@ export async function startWebServer(opts) {
     const makeRunner = (session, harness) => {
         const ledger = new ChangeLedger(session.cwd);
         ledger.attach(harness.hooks);
-        return { session, agent: harness.agent(session), harness, ledger };
+        return { session, agent: harness.agent(session), harness, ledger, queue: [] };
     };
     /** The runner a request names, or the most recently focused one. */
     let focused = opts.session.id;
@@ -824,6 +844,16 @@ export async function startWebServer(opts) {
                 await writePrefs({ sessionOrder: order });
                 return send(res, 200, { order: ids });
             }
+            case "POST /reveal": {
+                const body = await readJson(req);
+                // A folder, and only one that exists: this opens a window on the
+                // desktop the agent runs on, and a stale path would open nothing.
+                const dir = typeof body.path === "string" && body.path ? path.resolve(body.path) : "";
+                if (!dir || !(await isDirectory(dir)))
+                    return send(res, 400, { error: "not a folder" });
+                const result = await revealDirectory(dir);
+                return send(res, "error" in result ? 500 : 200, result);
+            }
             case "POST /pick": {
                 const body = await readJson(req);
                 // The dialog opens on this machine's desktop, which is the same
@@ -1101,6 +1131,40 @@ export async function startWebServer(opts) {
                 // Any tab: switching projects rebuilds the harness under every runner.
                 if (anyRunning())
                     return send(res, 409, { error: "a turn is running" });
+                if (typeof body.rename === "string") {
+                    const oldPath = path.resolve(dir);
+                    const oldSession = current.session.cwd === oldPath ? current.session.id : undefined;
+                    const oldHarness = harnesses.get(oldPath);
+                    const store = oldHarness?.store ?? current.harness.store;
+                    let reopenAt = oldPath;
+                    try {
+                        if (oldHarness)
+                            await oldHarness.close();
+                        harnesses.delete(oldPath);
+                        const renamed = await renameProject(oldPath, body.rename);
+                        reopenAt = renamed.project.path;
+                        const relocated = await store.relocateProject(renamed.project.id, oldPath, renamed.project.path);
+                        for (const [id, runner] of [...runners]) {
+                            if (runner.session.cwd === oldPath)
+                                runners.delete(id);
+                        }
+                        cachedLogs = undefined;
+                        const moved = oldSession ? await switchProject(renamed.project.path, oldSession) : undefined;
+                        return send(res, 200, {
+                            project: renamed.project,
+                            relocated,
+                            open: [...runners.keys()],
+                            ...(moved ? { state: moved } : {}),
+                        });
+                    }
+                    catch (err) {
+                        // If preparation closed the current harness but the rename failed,
+                        // rebuild it so the window is not left attached to a dead runtime.
+                        if (oldSession && !harnesses.has(reopenAt))
+                            await switchProject(reopenAt, oldSession).catch(() => { });
+                        return send(res, 400, { error: errorMessage(err) });
+                    }
+                }
                 if (body.remove === true) {
                     return send(res, 200, { removed: await removeProject(dir) });
                 }
@@ -1180,10 +1244,98 @@ export async function startWebServer(opts) {
                     return send(res, 400, { error: errorMessage(err) });
                 }
             }
+            case "GET /project/export": {
+                const dir = path.resolve(url.searchParams.get("path") ?? current.session.cwd);
+                const project = (await listProjects()).find((one) => one.path === dir);
+                if (!project || project.missing)
+                    return send(res, 404, { error: "project not found" });
+                try {
+                    await sendProjectExport(res, project.path, project.name);
+                }
+                catch (err) {
+                    if (!res.headersSent)
+                        return send(res, 400, { error: errorMessage(err) });
+                    res.destroy(err instanceof Error ? err : new Error(String(err)));
+                }
+                return;
+            }
             case "GET /routines":
                 // The scheduler is real machinery; a panel that invented its own list
                 // would drift from what actually fires.
-                return send(res, 200, { routines: await current.harness.scheduler.status() });
+                {
+                    // Which ones this machine's config holds: those are the ones the
+                    // panel can delete. A project's are the repository's to change.
+                    // A routine the agent added in another project's session is in the
+                    // file but not yet in this project's scheduler.
+                    await current.harness.syncUserSchedules();
+                    const user = (await loadUserConfig()).schedules ?? [];
+                    const mine = new Map(user.map((one) => [one.name, one]));
+                    const list = (await current.harness.scheduler.status()).map((one) => ({
+                        ...one,
+                        removable: mine.has(one.name),
+                        // Where it runs: the directory it was made for, or this project
+                        // for one that names none.
+                        cwd: mine.get(one.name)?.cwd ?? current.harness.cwd,
+                    }));
+                    return send(res, 200, { routines: list });
+                }
+            /** Pause a routine, or resume it. The user's own only. */
+            case "POST /routine/enabled": {
+                const body = await readJson(req);
+                const name = typeof body.name === "string" ? body.name : "";
+                if (!name || typeof body.enabled !== "boolean") {
+                    return send(res, 400, { error: "name and enabled are required" });
+                }
+                try {
+                    await current.harness.setScheduleEnabled(name, body.enabled);
+                    for (const harness of harnesses.values()) {
+                        const held = harness.scheduler.list().find((one) => one.name === name);
+                        if (held)
+                            harness.scheduler.add({ ...held, enabled: body.enabled });
+                    }
+                    return send(res, 200, { name, enabled: body.enabled });
+                }
+                catch (err) {
+                    return send(res, 400, { error: errorMessage(err) });
+                }
+            }
+            /** A routine's runs and skipped times, newest first. */
+            case "GET /routine/history": {
+                const name = url.searchParams.get("name") ?? "";
+                if (!name)
+                    return send(res, 400, { error: "name is required" });
+                return send(res, 200, { runs: await current.harness.scheduler.history(name, 30) });
+            }
+            case "GET /keep-awake":
+                return send(res, 200, {
+                    available: !!opts.onKeepAwake,
+                    enabled: (await readPrefs()).keepAwake === true,
+                });
+            case "POST /keep-awake": {
+                if (!opts.onKeepAwake)
+                    return send(res, 404, { error: "not available here" });
+                const body = await readJson(req);
+                if (typeof body.enabled !== "boolean")
+                    return send(res, 400, { error: "enabled must be a boolean" });
+                await writePrefs({ keepAwake: body.enabled });
+                opts.onKeepAwake(body.enabled);
+                return send(res, 200, { available: true, enabled: body.enabled });
+            }
+            case "POST /routine/remove": {
+                const body = await readJson(req);
+                const name = typeof body.name === "string" ? body.name : "";
+                if (!name)
+                    return send(res, 400, { error: "name is required" });
+                try {
+                    await current.harness.removeSchedule(name);
+                    for (const harness of harnesses.values())
+                        harness.scheduler.remove(name);
+                    return send(res, 200, { removed: name });
+                }
+                catch (err) {
+                    return send(res, 400, { error: errorMessage(err) });
+                }
+            }
             case "POST /routine": {
                 const body = await readJson(req);
                 const name = typeof body.name === "string" ? body.name : "";
@@ -1192,11 +1344,14 @@ export async function startWebServer(opts) {
                 if (anyRunning())
                     return send(res, 409, { error: "a turn is running" });
                 try {
-                    const run = await current.harness.scheduler.runNow(name);
-                    broadcast({
-                        type: "notice",
-                        message: `routine ${name} ${run.ok ? "finished" : "failed"} in ${run.turns} turns`,
-                    });
+                    // In the routine's own project, the same as when the clock fires it.
+                    const target = await routines.find(name, current.harness.cwd);
+                    if (!target)
+                        return send(res, 400, { error: `no routine named "${name}"` });
+                    const run = await routines.run(target);
+                    if (!run)
+                        return send(res, 409, { error: `routine ${name} is already running` });
+                    reportRoutineRun(run, target.cwd);
                     return send(res, 200, { run });
                 }
                 catch (err) {
@@ -1590,6 +1745,8 @@ export async function startWebServer(opts) {
                         costUsd: meta.costUsd,
                         current: meta.id === current.session.id,
                         forkedFrom: meta.forkedFrom,
+                        // A routine's run, which the sidebar keeps in a group of its own.
+                        routine: meta.routine,
                         // Sessions are stored per home, not per project, so this list spans
                         // every tree opened here. The page groups by it rather than showing
                         // one project's transcripts as another's history.
@@ -1785,12 +1942,22 @@ export async function startWebServer(opts) {
                     // Where to go for a key. Has a default even on a build that knows no
                     // account project, which is exactly the build that needs the link.
                     site: siteUrl(),
-                    models: current.harness.listModels().map((model) => ({
+                    // Newest release first within each provider. See model-order.ts;
+                    // the picker and the Models page both keep this order.
+                    models: sortModelsForDisplay(await withReleaseDates(current.harness.listModels())).map((model) => ({
                         id: model.id,
                         provider: model.provider,
                         contextWindow: model.contextWindow,
                         configured: configured.has(model.provider),
                         current: model.id === current.session.model.id,
+                        // The fact, not the two numbers it is derived from. This panel has
+                        // no price column and is not getting one — a rate belongs on the
+                        // rate card, where the markup that applies to it is known — so
+                        // shipping the pair here would be shipping something only a second
+                        // copy of `isFree` could read correctly. Present only when true,
+                        // because the list runs to nine hundred entries and an absent key
+                        // and a false one say the same thing to the one reader there is.
+                        ...(isFree(model) ? { free: true } : {}),
                     })),
                     providers: current.harness.listCatalogProviders().map((entry) => ({
                         id: entry.id,
@@ -2236,9 +2403,6 @@ export async function startWebServer(opts) {
                 if (!prompt && !ids.length && !references.length) {
                     return send(res, 400, { error: "prompt is required" });
                 }
-                // Per runner, not global: a turn in one tab must not block another.
-                if (runner.running)
-                    return send(res, 409, { error: "a turn is already running" });
                 const staged = ids
                     .map((id) => (typeof id === "string" ? attachments.get(id) : undefined))
                     .filter((entry) => Boolean(entry));
@@ -2249,6 +2413,19 @@ export async function startWebServer(opts) {
                 // a composer is known to have moved on, so it is a good moment to ask
                 // what else has been abandoned.
                 sweepAttachments();
+                // Per runner, not global: a turn in one tab must not block another.
+                // A second prompt into a busy runner waits, and is shown waiting. It
+                // is not handed to the running turn on its own: putting words in front
+                // of a model mid-thought is a thing to choose, not a thing that
+                // happens because you typed fast. /sendnow is that choice.
+                //
+                // This used to 409, and the page discarded the reply, so an impatient
+                // Enter cleared the composer and lost what had been typed.
+                if (runner.running) {
+                    runner.queue.push({ id: randomUUID(), prompt, staged, references });
+                    broadcastQueue(runner);
+                    return send(res, 202, { ok: true, queued: true });
+                }
                 void runTurn(runner, prompt, staged, references);
                 return send(res, 202, { ok: true, attached: staged.length, referenced: references.length });
             }
@@ -2284,6 +2461,84 @@ export async function startWebServer(opts) {
                     runnerFor(body.session)?.running?.abort();
                 }
                 return send(res, 200, { ok: true });
+            case "POST /unqueue": {
+                const body = await readJson(req);
+                const runner = runnerFor(body.session);
+                if (!runner)
+                    return send(res, 404, { error: "no such session" });
+                // Either kind: one handed to the running turn but not yet read, or
+                // one still waiting for the turn to end.
+                if (typeof body.id === "string" && runner.agent.retract(body.id)) {
+                    broadcastQueue(runner);
+                    return send(res, 200, { ok: true });
+                }
+                const at = runner.queue.findIndex((entry) => entry.id === body.id);
+                if (at >= 0) {
+                    // The bytes came out of the staging map when this was queued, so
+                    // they are held by the entry alone and go when it does.
+                    runner.queue.splice(at, 1);
+                    broadcastQueue(runner);
+                }
+                return send(res, 200, { ok: true });
+            }
+            /**
+             * One waiting message, now, without waiting for its place in the queue.
+             *
+             * While a turn runs that means handing it to the turn — the same path a
+             * prompt typed mid-turn takes — so it is read at the next gap rather
+             * than after the whole thing. Nothing is interrupted: "now" here is as
+             * soon as the conversation has a place to put it.
+             *
+             * A message carrying files cannot ride the inbox, so it moves to the
+             * head of the queue instead and the reply says so.
+             */
+            case "POST /sendnow": {
+                const body = await readJson(req);
+                const runner = runnerFor(body.session);
+                if (!runner)
+                    return send(res, 404, { error: "no such session" });
+                const at = runner.queue.findIndex((entry) => entry.id === body.id);
+                if (at < 0)
+                    return send(res, 404, { error: "no such queued message" });
+                const entry = runner.queue[at];
+                if (!runner.running) {
+                    runner.queue.splice(at, 1);
+                    broadcastQueue(runner);
+                    void runTurn(runner, entry.prompt, entry.staged, entry.references);
+                    return send(res, 202, { ok: true, sent: true });
+                }
+                const plain = entry.prompt && !entry.staged.length && !entry.references.length;
+                if (plain && runner.agent.interject(entry.prompt)) {
+                    runner.queue.splice(at, 1);
+                    broadcastQueue(runner);
+                    return send(res, 202, { ok: true, interjected: true });
+                }
+                // Cannot be handed over, so the most that can be done is to put it
+                // first in line for when the turn ends.
+                runner.queue.splice(at, 1);
+                runner.queue.unshift(entry);
+                broadcastQueue(runner);
+                return send(res, 200, { ok: true, moved: true });
+            }
+            /**
+             * Send what is waiting, now.
+             *
+             * The queue drains itself after a turn that ends on its own, but not
+             * after an interrupt or an error — stopping means stop, and a message
+             * typed before the failure should not fire into whatever caused it.
+             * This is how the page restarts a queue left standing that way.
+             */
+            case "POST /flush": {
+                const body = await readJson(req);
+                const runner = runnerFor(body.session);
+                if (!runner)
+                    return send(res, 404, { error: "no such session" });
+                if (runner.running)
+                    return send(res, 409, { error: "a turn is already running" });
+                if (!drainQueue(runner))
+                    return send(res, 200, { ok: true, sent: false });
+                return send(res, 202, { ok: true, sent: true });
+            }
             default:
                 return send(res, 404, { error: "not found" });
         }
@@ -2502,6 +2757,9 @@ export async function startWebServer(opts) {
             contextWindow: model.contextWindow,
             contextUsed: model.contextWindow ? Math.min(1, used / model.contextWindow) : undefined,
             busy: Boolean(runner.running),
+            // So a reload, or a second tab, sees what is still waiting. The queue
+            // lives on the runner rather than in the page for exactly this reason.
+            queued: queueView(runner),
         };
     }
     /**
@@ -2598,6 +2856,44 @@ export async function startWebServer(opts) {
         watchConnections(harness);
         return harness;
     }
+    /*
+     * Routines: which exist, where each runs, and — when this server was asked
+     * to — the clock that fires them. A run lands in the page as a notice and,
+     * through onRoutineRun, wherever the desktop can reach someone who is not
+     * looking at the page.
+     */
+    const routines = new RoutineRunner({
+        defaultCwd: opts.session.cwd,
+        openHarnesses: () => harnesses.values(),
+        createHarness: (cwd) => opts.openProject
+            ? opts.openProject(cwd)
+            : Harness.create({
+                cwd,
+                permissionPrompt: async () => false,
+                questionPrompt: async () => ({ outcome: "unavailable" }),
+            }),
+        onStart: (routine, meta) => {
+            if (meta.catchUp)
+                broadcast({ type: "notice", message: `routine ${routine.def.name} is catching up on a run it missed` });
+            opts.onRoutineStart?.(routine.def.name, meta);
+        },
+        onRun: (run, routine) => reportRoutineRun(run, routine.cwd),
+        onError: (routine, error) => broadcast({ type: "notice", message: `routine ${routine.def.name} could not start: ${error}` }),
+    });
+    function reportRoutineRun(run, cwd) {
+        broadcast({
+            type: "notice",
+            message: `routine ${run.schedule} ${run.ok ? "finished" : "failed"} in ${run.turns} turns`,
+        });
+        // The run's session is new, and the sidebar has a group for it.
+        broadcast({ type: "sessions" });
+        try {
+            opts.onRoutineRun?.(run, cwd);
+        }
+        catch {
+            // A notifier that throws must not lose the run it was told about.
+        }
+    }
     /**
      * Open a different project.
      *
@@ -2680,6 +2976,46 @@ export async function startWebServer(opts) {
         });
         return snapshot;
     }
+    /**
+     * What the page needs to draw the waiting chips, without the bytes.
+     *
+     * Interjections first, and marked as such: they reach the model during the
+     * running turn, while the queue waits for it to finish. Drawn as one list
+     * because that is the order the conversation will read them in.
+     */
+    const queueView = (runner) => [
+        ...runner.agent.pendingInterjections.map((entry) => ({
+            id: entry.id,
+            text: entry.text,
+            attachments: [],
+            references: [],
+            soon: true,
+        })),
+        ...runner.queue.map((entry) => ({
+            id: entry.id,
+            text: entry.prompt,
+            attachments: entry.staged.map((file) => file.name),
+            references: entry.references,
+            soon: false,
+        })),
+    ];
+    const broadcastQueue = (runner) => {
+        broadcast({ type: "queue", session: runner.session.id, queued: queueView(runner) });
+    };
+    /**
+     * Start the next waiting prompt, if there is one.
+     *
+     * Returns whether a turn was started, so a caller can tell an empty queue
+     * from one that is now running.
+     */
+    function drainQueue(runner) {
+        const next = runner.queue.shift();
+        if (!next)
+            return false;
+        broadcastQueue(runner);
+        void runTurn(runner, next.prompt, next.staged, next.references);
+        return true;
+    }
     async function runTurn(runner, prompt, staged = [], references = []) {
         const controller = new AbortController();
         runner.running = controller;
@@ -2702,6 +3038,7 @@ export async function startWebServer(opts) {
         const note = referenceNote(references);
         const text = note ? `${note}\n\n${prompt}` : prompt;
         const input = staged.length ? buildMessage(text, staged) : text;
+        let failed = false;
         try {
             for await (const event of runner.agent.run(input, { signal: controller.signal })) {
                 // The agent's own question_request is not forwarded: the page draws
@@ -2710,10 +3047,25 @@ export async function startWebServer(opts) {
                 // the copy without that id could only ever 404.
                 if (event.type === "question_request")
                     continue;
+                // The agent reports a provider failure as an event and breaks its own
+                // loop rather than throwing, so the catch below never sees it — and a
+                // queue that drained into a dead provider would replay the failure
+                // once per waiting message.
+                if (event.type === "error" && event.fatal)
+                    failed = true;
+                // Read into the conversation: the chip goes, and the words appear in
+                // the transcript where the model saw them rather than where they were
+                // typed. `prompt` is what the page draws a user message from.
+                if (event.type === "interjected") {
+                    broadcastQueue(runner);
+                    broadcast({ type: "prompt", session: id, text: event.text, interjected: true });
+                    continue;
+                }
                 broadcast({ ...event, session: id });
             }
         }
         catch (err) {
+            failed = true;
             broadcast({
                 type: "error",
                 session: id,
@@ -2737,12 +3089,24 @@ export async function startWebServer(opts) {
         }
         finally {
             runner.running = undefined;
+            // The window between the loop's last read of the inbox and the run
+            // admitting it is over. Whatever landed in it is put at the head of the
+            // queue rather than left unread inside a finished agent.
+            const unread = runner.agent.takeUnread();
+            for (let i = unread.length - 1; i >= 0; i--) {
+                runner.queue.unshift({ id: unread[i].id, prompt: unread[i].text, staged: [], references: [] });
+            }
             broadcast({
                 type: "idle",
                 session: id,
                 state: state(runner),
                 changes: runner.ledger.list(),
             });
+            // Only after a turn that ended on its own. An interrupt means stop, and
+            // an error would usually meet the next prompt with the same error, so
+            // both leave the queue standing for the person to send or drop.
+            if (!controller.signal.aborted && !failed)
+                drainQueue(runner);
         }
     }
     function stream(res) {
@@ -2930,6 +3294,27 @@ export async function startWebServer(opts) {
         return a.length === b.length && timingSafeEqual(a, b);
     }
     await listenPreferring(server, opts.port, host);
+    // The model list goes stale as vendors withdraw models, and is otherwise
+    // only re-fetched on sign-in or a press of refresh. Checked at start and
+    // every six hours after, it is fetched again once it is three days old — so
+    // a window left open for a week still catches up. Never while a turn runs:
+    // the sweep swaps the catalog the turn is resolving its model from.
+    const refreshStale = () => {
+        if (anyRunning())
+            return;
+        void current.harness.refreshStaleModels().catch(() => {
+            // Offline, or a vendor down: the saved list still works; try next tick.
+        });
+    };
+    refreshStale();
+    const staleTimer = setInterval(refreshStale, 6 * 60 * 60 * 1000);
+    staleTimer.unref?.();
+    if (opts.routines)
+        routines.start();
+    if (opts.onKeepAwake) {
+        const keepAwake = opts.onKeepAwake;
+        void readPrefs().then((prefs) => keepAwake(prefs.keepAwake === true)).catch(() => { });
+    }
     const address = server.address();
     const port = typeof address === "object" && address ? address.port : opts.port;
     return {
@@ -2938,6 +3323,8 @@ export async function startWebServer(opts) {
         permissionPrompt,
         questionPrompt,
         async close() {
+            clearInterval(staleTimer);
+            await routines.close();
             for (const unsubscribe of connectionSubscriptions)
                 unsubscribe();
             for (const harness of harnesses.values())