@oharness/server 0.5.1 → 0.7.0

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();
     /**
@@ -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,
@@ -2598,6 +2765,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.
      *
@@ -2930,6 +3135,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 +3164,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())