@openagt/dashboard 0.37.0 → 0.39.0

package/dist/module-types/dashboard/module/index.d.ts

@@ -1,7 +1,10 @@
+import type { Health } from '../../src/health.js';
+import type { CardWidth } from '../../src/overview-layout.js';
 import { type ComponentType } from 'react';
 import type { AgentStatus } from '../../src/index.js';
+import type { ModuleAgent, ModuleAgentsWanted } from '../../src/dashboard/module-agents.js';
 import type { ModuleCommandResult, ModuleReadResult } from '../rpc/modules.js';
-export type { ModuleCommandResult, ModuleReadResult, AgentStatus };
+export type { ModuleCommandResult, ModuleReadResult, AgentStatus, CardWidth, Health, ModuleAgent, ModuleAgentsWanted };
 /** A registered project that has the module's package, as a page gets it. */
 export interface ModuleProject {
     id: string;
@@ -113,6 +116,12 @@ export interface ModuleCardProps {
 export interface ModuleCard {
     /** Which card this is, for the shell's key and its error line; never shown as a title. */
     id: string;
+    /** Its name where the person arranges the Overview's cards: what its title says ("Hot tickets"). */
+    label: string;
+    /** How wide it stands until the person picks: half the Overview when unsaid. */
+    width?: CardWidth;
+    /** The narrowest it fits: a third of the Overview when unsaid. */
+    minWidth?: CardWidth;
     /** Its place among every installed package's cards, lower first; 50 when unsaid, ties by package name. */
     order?: number;
     /** The card itself. */
@@ -294,18 +303,6 @@ export interface ModuleDefinition {
 }
 /** Type the default export: `export default defineModule({ ... })`. */
 export declare function defineModule(definition: ModuleDefinition): ModuleDefinition;
-/** A run of a project as the dashboard knows it (#1774): enough for a page to name one and link to it. */
-export interface ModuleAgent {
-    /** The run's id, the one {@link ModuleHost.openAgent} takes. */
-    id: string;
-    /** The run's branch, the name the agent gave its work, when its record carries one. */
-    name?: string;
-    /** What the run was asked, as typed or as queued; absent when its record carries none. */
-    ask?: string;
-    status: AgentStatus;
-    /** ISO 8601. */
-    startedAt: string;
-}
 /** What starting a run answered: the run's id, or in words why there is none. */
 export type StartRunResult = {
     ok: true;
@@ -362,6 +359,13 @@ export interface ModuleHost {
     openPage(segment: string, path?: string[], projectId?: string): void;
     /** The address of a page a module adds, with the project picked in the dashboard: a link's `href`, for a link that also opens in a new tab. */
     pageHref(segment: string): string;
+    /** Open an entry of Settings over the page, by its id: `openSettings('devices')`. */
+    openSettings(entry: string): void;
+    /**
+     * The accounts behind a project's commit emails at its git host, each with its login and picture:
+     * an email the host knows nobody for, or a project with no git host, is left out. Kept a day.
+     */
+    gitHostPeople(projectId: string, emails: string[]): Promise<ModuleHostPerson[]>;
     /**
      * Start a run in one project with this prompt, with the person's own picks (which tool, which
      * model, where it runs), and land on it, unless `land` is false: then the dashboard stays where
@@ -372,8 +376,12 @@ export interface ModuleHost {
     }): Promise<StartRunResult>;
     /** Open the project's launcher with this prompt drafted in, to set it up before sending: "Configure first, then run". */
     configureRun(projectId: string, prompt: string): void;
-    /** The project's runs the dashboard knows: the ones running, and the recorded ones when the project records them. */
-    agents(projectId: string): Promise<ModuleAgent[]>;
+    /**
+     * The project's runs the dashboard knows: the ones running, and the recorded ones when the
+     * project records them. `wanted` narrows them to the ones a card shows (those holding a claim,
+     * the last 30 days): a project keeps hundreds, and a phone downloads every one asked for.
+     */
+    agents(projectId: string, wanted?: ModuleAgentsWanted): Promise<ModuleAgent[]>;
     /**
      * The other computers a run can be sent to, as saved on this one, each with the OpenAgent it
      * runs, beside this computer's own: how a page tells that a machine fell behind this computer.
@@ -415,6 +423,11 @@ export interface ModuleHost {
      * it said is another computer's data, to read as such; `unknown` for a machine that does not say.
      */
     machinePerson(machineId: string): Promise<ModuleMachinePerson>;
+    /**
+     * A saved server of the person's uses this computer's logins from now on: each account this
+     * computer is logged in to gets a login of the server's own there, as Settings › Accounts says.
+     */
+    useLoginsOn(machineId: string): Promise<MachineAdded>;
     /** Take one of that person's devices out at the machine, by its id there; answers as {@link machinePerson} does, after. */
     removeMachineDevice(machineId: string, deviceId: string): Promise<ModuleMachinePerson>;
     /**
@@ -426,6 +439,13 @@ export interface ModuleHost {
     /** Send the live screen of a run what the person did on it, as JSON; whether the screen took it. */
     sendToScreen(projectId: string, agentId: string, input: unknown): Promise<boolean>;
 }
+/** A person of a project, as its git host knows them. */
+export interface ModuleHostPerson {
+    email: string;
+    login: string;
+    /** A picture of them: an https address. */
+    avatar?: string;
+}
 /** A saved machine, as a module sees it: never this computer's key there. */
 export interface ModuleMachine {
     /** Where the machine answers, as an origin (`https://203.0.113.5`): what it is known by. */
@@ -434,6 +454,8 @@ export interface ModuleMachine {
     url: string;
     /** The OpenAgent it runs; absent for a machine that does not answer right now. */
     version?: string;
+    /** How it stands, as it says: its memory, disk and load; absent for one that does not answer, or does not say. */
+    health?: Health;
     /** The id the machine lists this computer under, among the devices that are in there. */
     device?: string;
     /** Whose computer it is, by their GitHub account, when it is another person's shared with everyone on a server. */
@@ -450,6 +472,8 @@ export interface ModuleMachines {
     version: string;
     /** This computer's own name, as another machine lists it: "Suleimans-MacBook-Pro". */
     name?: string;
+    /** How this computer stands: its memory, disk and load. */
+    health?: Health;
     machines: ModuleMachine[];
 }
 /** How saving a machine went: done, or stopped, with the reason. */
@@ -547,6 +571,9 @@ export { Tooltip, TooltipTrigger, TooltipContent } from '../components/ui/toolti
 export { DropdownMenu, DropdownMenuContent, DropdownMenuCheckboxItem, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger } from '../components/ui/dropdown-menu.js';
 export { ContextMenu, ContextMenuTrigger } from '../components/ui/context-menu.js';
 export { PaneTitle, PaneActions } from '../components/PaneHeader.js';
+export { Page } from '../components/Page.js';
+export { StatTile } from '../components/StatTile.js';
+export { FilterChips, type FilterChip } from '../components/FilterChips.js';
 export { FileIcon } from '../components/FileIcon.js';
 export { Markdown } from '../components/Markdown.js';
 export { StartAgentButton } from '../components/StartAgentButton.js';

package/dist/module-types/src/client.d.ts

@@ -17,3 +17,4 @@ export { reachedByLine } from './reached-by-line.js';
 export { isLoopbackHost } from './loopback-host.js';
 export { bridgeChoiceRequest } from './dashboard/bridge-question.js';
 export { cloudRunState, cloudRunActive, CLOUD_SESSION_WINDOW_MS, type CloudRunState } from './cloud-run-state.js';
+export { ALL_PROJECTS, CARD_WIDTHS, arrangeCards, widthsFor, type CardPlace, type CardWidth, type LayoutCard, type OverviewLayouts } from './overview-layout.js';

package/dist/module-types/src/computer-name.d.ts

@@ -0,0 +1,2 @@
+/** This computer's name as a person knows it: its host name, without the `.local` a Mac adds on its network. */
+export declare function computerName(): string;

package/dist/module-types/src/dashboard/compress.d.ts

@@ -0,0 +1,22 @@
+import type { IncomingMessage, OutgoingHttpHeaders, ServerResponse } from 'node:http';
+/** Whether the caller takes a gzipped answer: every browser says so. */
+export declare function takesGzip(req: IncomingMessage): boolean;
+/** The types worth packing: text. A picture or a font is packed already. */
+export declare function isText(contentType: string): boolean;
+/** A file's version, from its size and when it was last written: a file rebuilt in place gets a new one. */
+export declare function fileVersion(facts: {
+    mtimeMs: number;
+    size: number;
+}): string;
+/** The tag a file is sent with: its {@link fileVersion}. */
+export declare function fileTag(facts: {
+    mtimeMs: number;
+    size: number;
+}): string;
+/**
+ * Send `body`, gzipped when the caller takes it, it is text and not small. `key` names a body that
+ * is the same each time it is sent (a file of the page), so it is packed once. A body sent with an
+ * `etag` the browser already holds (it says so in `if-none-match`) is not sent again: a 304 tells
+ * it to use its copy, which is what a reopened page does with every file of its code.
+ */
+export declare function sendBody(req: IncomingMessage, res: ServerResponse, status: number, headers: OutgoingHttpHeaders, body: Buffer | string, key?: string): Promise<void>;

package/dist/module-types/src/dashboard/copied-logins.d.ts

@@ -0,0 +1,53 @@
+/** One of an account's usage windows, as a page names it: `5 h`, `week`, `month`, and how much of it is gone. */
+export interface UsageWindow {
+    label: string;
+    percent: number;
+}
+/** What a copied login is a login of: a coding agent's account, or a git host's. */
+export type CopiedKind = 'claude' | 'codex' | 'git';
+/** One login a computer of the person's handed over, as this server keeps it: never the login itself. */
+export interface CopiedLogin {
+    kind: CopiedKind;
+    /** A git host's account: the host. */
+    host?: string;
+    /** Which of the computer's accounts it is: `own` for its own login, else the account's name there, or its login at the git host. */
+    source: string;
+    /** The name of its row here. */
+    name: string;
+    /** Who the account is, as the computer said when it handed it over: a switch to another account says another. */
+    who: string;
+    /** The computer it came from, by its name. */
+    from: string;
+    /** The computer no longer has it, and the person said to keep it here. */
+    kept?: true;
+    /** A git host's account the computer's runs use: the server's do too. */
+    runs?: true;
+    /** How full it is, as the computer last read it. */
+    usage?: {
+        windows: UsageWindow[];
+        at: number;
+    };
+}
+/** A login handed over: what it is, and the login itself, which goes where its tool reads it. */
+export interface GivenLogin {
+    kind: CopiedKind;
+    host?: string;
+    source: string;
+    name: string;
+    who: string;
+    from: string;
+    runs?: boolean;
+}
+/** Where the file is: beside OpenAgent's other files in the person's config folder. */
+export declare function copiedPath(env?: NodeJS.ProcessEnv): string;
+export declare const isKind: (value: unknown) => value is CopiedKind;
+/** A word a computer said: a name, an account, a host. Never long, never a line break. */
+export declare const isWord: (value: unknown, max?: number) => value is string;
+export declare function readUsage(value: unknown): CopiedLogin['usage'] | undefined;
+/** The logins this server keeps from the person's computers. Forgiving: none on a file that does not read. */
+export declare function readCopied(): CopiedLogin[];
+export declare function writeCopied(logins: CopiedLogin[]): void;
+/** The same login of the same computer: its kind, its host, and which of the computer's accounts it is. */
+export declare const same: (a: Pick<CopiedLogin, 'kind' | 'host' | 'source'>, b: Pick<CopiedLogin, 'kind' | 'host' | 'source'>) => boolean;
+/** The copied login of an account row here, by its kind and its name. */
+export declare function copiedOf(kind: CopiedKind, name: string, host?: string): CopiedLogin | undefined;

package/dist/module-types/src/dashboard/git-hosts.d.ts

@@ -7,6 +7,8 @@ export interface GitHostAccount {
     runs: boolean;
     /** Whether the tool could use it when asked. */
     ok: boolean;
+    /** On a server: the computer of the person's whose login it is. */
+    from?: string;
 }
 /** What a git host's package answers of it. */
 export interface GitHostProvider {

package/dist/module-types/src/dashboard/logins-sync.d.ts

@@ -0,0 +1,145 @@
+import { type Mint } from '@openagt/agent-driver-claude';
+import { type CodexLogin, type CodexLoginOptions } from '@openagt/agent-driver-codex';
+import { type MachineRecord, type Preferences } from '../registry.js';
+import { type MachineAccess } from './remote-run.js';
+import { type CopiedKind, type UsageWindow } from './copied-logins.js';
+/**
+ * A computer's side of a server that uses its logins (`copied-logins.ts` is the server's side).
+ * Once the person said so for a server of their own, this computer keeps the server's logins as
+ * its own: every account it is logged in to, a coding agent's or a git host's, gets a login of the
+ * server's own there, and a login that changes here changes there.
+ *
+ * A login is never shared by both: each computer renews its own, and a login renewed on one
+ * computer would log the other one out. What can go as it is goes as it is, with nothing to
+ * press: a git host's token, which its host never renews, and a Claude account added here, which
+ * is a login made for a computer nobody sits at already. What cannot is made anew for the server,
+ * in this computer's browser, with one press of the person's: their own Claude login (Claude
+ * Code's `setup-token`), and any Codex account (a sign-in of its own). Nothing here is logged out.
+ *
+ * What the person no longer has here stays there until they say: kept, or taken off. A login
+ * taken off there is deleted there and ends nothing.
+ *
+ * The person's settings follow the same way: what they change here is changed there, the next
+ * minute. A setting changed on the server's own page stays, until the same one changes here.
+ */
+/** One of this computer's accounts, as a server gets it. */
+export interface LocalLogin {
+    kind: CopiedKind;
+    host?: string;
+    /** Which account it is here: `own` for the agent's own login, else its name here, or its login at the git host. */
+    source: string;
+    name: string;
+    /** Who the account is: another one under the same `source` is a switch. */
+    who: string;
+    /** A git host's account this computer's runs use. */
+    runs?: boolean;
+    /** The login as it is, for one that can go as it is; none for one made anew for the server. */
+    secret?: () => Promise<string>;
+}
+/** How one of this computer's accounts stands on a server. */
+export interface LoginThere {
+    kind: CopiedKind;
+    host?: string;
+    source: string;
+    name: string;
+    /**
+     * `there`: the server has it. `allow`: it waits for the person's press, which makes the server a
+     * login of its own. `switched`: the server has another account of this one's, which the
+     * person no longer is here: the press makes this one's. `failed`: it did not get there.
+     */
+    state: 'there' | 'allow' | 'switched' | 'failed';
+    /** `switched`: the account the server has. */
+    was?: string;
+    error?: string;
+}
+/** One of this computer's servers, and how its logins stand there. */
+export interface ServerLogins {
+    machineId: string;
+    label: string;
+    /** The person said the server uses this computer's logins. */
+    on: boolean;
+    /** It answered when last asked. */
+    reachable: boolean;
+    logins: LoginThere[];
+    /** What the server has of this computer's that this computer no longer has: the person keeps it there, or takes it off. */
+    left: {
+        kind: CopiedKind;
+        host?: string;
+        source: string;
+        name: string;
+    }[];
+    /** The press under way: the login being made, and the page it signs in at. */
+    allowing?: {
+        name: string;
+        url?: string;
+    };
+    /** Why the last press stopped. */
+    failed?: string;
+}
+/** What the sync reaches for, swapped in tests. */
+export declare const syncWiring: {
+    /** The environment the daemon was started with: whose saved machines, whose logins. */
+    env: NodeJS.ProcessEnv;
+    machines: () => Promise<MachineRecord[]>;
+    /** Whether a machine is a server, and answers. */
+    facts: (machine: MachineAccess) => Promise<{
+        server?: true;
+        version?: string;
+    }>;
+    call: (machine: MachineAccess, fn: string, args: unknown[]) => Promise<{
+        ok: true;
+        ret: unknown;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    /** This computer's own logins. */
+    local: () => Promise<LocalLogin[]>;
+    /** How full each of this computer's accounts is, as its own page reads it. */
+    usage: () => Promise<{
+        kind: CopiedKind;
+        source: string;
+        windows: UsageWindow[];
+        at: number;
+    }[]>;
+    /** This computer's settings. */
+    preferences: () => Promise<Preferences>;
+    mint: Mint;
+    loginCodex: (opts: CodexLoginOptions) => Promise<CodexLogin>;
+    computer: () => string;
+};
+/** The person's own Claude login here, as Claude Code keeps who it is: none when it is logged in to no account. */
+export declare function claudeOwnAccount(env?: NodeJS.ProcessEnv): {
+    name: string;
+    who: string;
+} | undefined;
+/** Every account this computer is logged in to: its coding agents' and its git hosts'. */
+export declare function localLogins(env?: NodeJS.ProcessEnv): Promise<LocalLogin[]>;
+/** Bring every server that uses this computer's logins up to them, and note how each stands; a saved machine that is no server of the person's is left out. */
+export declare function syncLogins(): Promise<ServerLogins[]>;
+/** The servers as last read, with the press under way on each: read anew when none were read yet. */
+export declare function serverLogins(): Promise<ServerLogins[]>;
+/**
+ * The person's press for a server: each of this computer's accounts that waits for it gets a
+ * login of the server's own, made in this computer's browser, one after the other. Answers at
+ * once; how it goes is in {@link serverLogins}.
+ */
+export declare function allowLogins(machineId: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Keep, or take off, a login the server has of this computer's that this computer no longer has. */
+export declare function settleLeft(machineId: string, which: {
+    kind: CopiedKind;
+    host?: string;
+    source: string;
+}, keep: boolean): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Keep every server that uses this computer's logins up to them, from now on: a minute apart, the first a moment after the start. */
+export declare function startLoginsSync(env: NodeJS.ProcessEnv): () => void;

package/dist/module-types/src/dashboard/machine-runs.d.ts

@@ -0,0 +1,110 @@
+import { type AgentMeta } from '../store/index.js';
+/**
+ * The runs of another computer, as this one lists them: a laptop's on its server, a server's on
+ * the laptop. Each computer answers for its own runs only, as they stand right now, over the relay
+ * of the saved machine it is ({@link RunChanges}); this computer takes what it says over the
+ * records of those runs it holds, which come through a project's shared records and stop at
+ * whatever was shared last ({@link withMachineRuns}). So how a computer's runs stand never
+ * depends on its records being shared: a computer that does not answer has its runs known by what
+ * it said last, or by their records, and none of them going: their status is `unknown`.
+ */
+/** What a computer answers for its own runs of a project. */
+export interface OwnRuns {
+    /**
+     * What to ask with next time, as `since`: the answer then holds only the runs that changed after
+     * this one. The same as `since` when nothing changed.
+     */
+    at: string;
+    /** Its runs that changed since the `since` it was asked with; every one when there was none, or one it does not know. */
+    runs: AgentMeta[];
+    /** Every one of its runs of the project, by id: a run the asker holds that is not here is gone. */
+    ids: string[];
+}
+/**
+ * What a list shows of a run, as one string to compare: what it is, how it stands, and its name.
+ * A run's card is written at every step it takes, with a later time and a higher cost, and none
+ * of that is a change a person waits on.
+ */
+export declare function shownOf(run: AgentMeta): string;
+/**
+ * A computer's own runs, counted as they change, per project: each answer says where it leaves
+ * the asker, and the next holds what changed after that. A count from before this OpenAgent
+ * started, or from no answer of its, is answered with every run.
+ */
+export declare class RunChanges {
+    private readonly started;
+    private readonly projects;
+    answer(project: string, runs: readonly AgentMeta[], since?: unknown): OwnRuns;
+    /** Whether what a list shows of the runs changed after `since`, as of the last answer: a count not of this OpenAgent's says so. */
+    shownSince(project: string, since: unknown): boolean;
+    private known;
+    private countOf;
+}
+/** A saved machine's runs of one project, as this computer last heard them. */
+export interface MachineRuns {
+    /** The computer's own name, as the records of its runs carry it. */
+    host: string;
+    /** Its runs as it said them last, since this OpenAgent started. */
+    runs: readonly AgentMeta[];
+    /** It answered the last time it was asked. */
+    answered: boolean;
+    /** When it last answered, ISO, when this computer knows. */
+    seenAt?: string;
+}
+/**
+ * A project's runs with what its saved machines said of theirs: a machine's word on a run of its
+ * own wins over the run's record, and a run of its own with no record here yet is listed too. A
+ * machine's run that is going is going only by its machine's word just now: one whose machine did
+ * not answer, or that its machine did not say, reads `unknown`, with when its machine was last
+ * seen. The runs of every other computer pass through as recorded.
+ */
+export declare function withMachineRuns(records: AgentMeta[], machines: readonly MachineRuns[]): AgentMeta[];
+/** A saved machine to ask for its runs: where it answers and its computer's own name. */
+export interface AskedMachine {
+    url: string;
+    host: string;
+    /** When it last answered, ISO, as kept with the machine. */
+    seenAt?: string;
+}
+/**
+ * How long a computer holds a call for its runs when nothing a list shows changed since it last
+ * answered: it answers at the first such change, else with what else changed once this is up, and
+ * is asked again.
+ */
+export declare const RUNS_WAIT_MS = 25000;
+/**
+ * What each saved machine says of its runs of a project, followed while a page wants them: one call
+ * to each machine is kept open, which the machine answers when its runs change
+ * ({@link RUNS_WAIT_MS}), and asked again at once from where the answer left off ({@link OwnRuns}).
+ * So what is kept is what the machine says now, and whoever listens to the project's address is
+ * told the moment it changes. A page is answered at once with what is known, and waits only for a
+ * machine's first answer, and not long.
+ */
+export declare class MachineRunsKept {
+    /** Ask the machine for its runs of the project at `address`, since what it answered last: it answers when they change. */
+    private readonly ask;
+    /** Told each time a machine answered. */
+    private readonly seen;
+    private readonly now;
+    /** Wait before the next ask. */
+    private readonly pause;
+    private readonly kept;
+    private readonly listeners;
+    constructor(
+    /** Ask the machine for its runs of the project at `address`, since what it answered last: it answers when they change. */
+    ask: (machine: AskedMachine, address: string, since: string | undefined) => Promise<unknown>, 
+    /** Told each time a machine answered. */
+    seen?: (machine: AskedMachine, at: string) => void, now?: () => number, 
+    /** Wait before the next ask. */
+    pause?: (ms: number) => Promise<void>);
+    /** The machines' runs of the project at `address`, followed from now on for a while: a page reads them every few seconds. */
+    of(machines: readonly AskedMachine[], address: string): Promise<MachineRuns[]>;
+    /** Follow nothing more: each machine's call is let go once it is answered. */
+    stop(): void;
+    /** Tell `changed` each time a machine's runs of the project at `address` change, until the answer is called. */
+    listen(address: string, changed: () => void): () => void;
+    private follow;
+    /** Ask once, and keep what the machine said: whether a change a list shows was told, nothing such changed, or it did not answer. */
+    private askAgain;
+    private tell;
+}

package/dist/module-types/src/dashboard/module-agents.d.ts

@@ -0,0 +1,43 @@
+import type { AgentMeta, AgentStatus } from '../store/agent-store.js';
+/** One run of a project, as a module sees it: what a page or a card shows of a run, and no more. */
+export interface ModuleAgent {
+    /** The run's id, the one `ModuleHost.openAgent` takes. */
+    id: string;
+    /** The run's branch, the name the agent gave its work, when its record carries one. */
+    name?: string;
+    /** What the run was asked, as typed or as queued; absent when its record carries none. */
+    ask?: string;
+    /** How it stands: `unknown` while the computer it runs on does not answer, whatever its record last said. */
+    status: AgentStatus;
+    /** ISO 8601. */
+    startedAt: string;
+    /** ISO 8601, once it ended. */
+    endedAt?: string;
+    /** Its short name, as a list of runs shows it. */
+    title?: string;
+    /** Whose run it is, by the email its record is kept under. */
+    person?: string;
+    /** What it cost so far, in US dollars. */
+    cost?: number;
+    /** The coding agent that runs it (`claude-code`, `codex`, …) and its model. */
+    driver?: string;
+    model?: string;
+    /** The saved machine it runs on, by the name it was given; absent for a run of this computer's. */
+    machine?: string;
+    /** While its status is `unknown`: when its computer was last seen, ISO, if it was. */
+    seenAt?: string;
+}
+/**
+ * Which of a project's runs a module asks for, when not all of them: a project keeps every run it
+ * ever made, hundreds, and a card shows a few. Both given, a run must be both.
+ */
+export interface ModuleAgentsWanted {
+    /** These runs only, by id: the ones holding a claim. */
+    ids?: string[];
+    /** The runs started at this time or later, ISO 8601: the last 30 days. */
+    since?: string;
+}
+/** A run as a module sees it. */
+export declare function moduleAgentOf(agent: AgentMeta): ModuleAgent;
+/** The runs a module asked for, as it sees them. */
+export declare function moduleAgents(agents: readonly AgentMeta[], wanted?: ModuleAgentsWanted): ModuleAgent[];

package/dist/module-types/src/dashboard/module-serve.d.ts

@@ -9,11 +9,20 @@ export declare const COMPUTER_MODULES_PREFIX = "/_computer-modules";
 export declare function moduleUrl(projectId: string, module: Pick<ProjectModule, 'package' | 'entry'>): string;
 /** The URL the browser part of one of the computer's modules is served at. */
 export declare function computerModuleUrl(module: Pick<ProjectModule, 'package' | 'entry'>): string;
+/**
+ * A module's URL with its entry file's version (`?v=`): a browser keeps that file for good, and
+ * the next version of the module is another URL. Without the file there to read, the URL as it is.
+ */
+export declare function versionedModuleUrl(url: string, module: Pick<ProjectModule, 'dir' | 'entry'>): Promise<string>;
 /**
  * Serve one module file (#1774): the project must be registered, the package must be a module of
  * that project, and the file must sit inside the module's browser part's own directory. Anything else is a
  * 404, never a fallback: a module URL is asked for by the dashboard's loader, not typed by a person.
- * Served as `no-cache`, since a module is rebuilt in place under the same name.
+ * Asked for with the file's own version ({@link versionedModuleUrl}), it is kept for good: a page
+ * opened again does not ask for it at all. Otherwise it is served as `no-cache`, since a module is
+ * rebuilt in place under the same name (its stylesheet, a file another of its files imports, a URL
+ * naming a version gone since), with a tag of the file's own: a page opened again asks with it and
+ * is answered "not changed", with no body. Sent gzipped, a module's code being a page's largest file.
  */
 export declare function serveModuleFile(req: IncomingMessage, res: ServerResponse, pathname: string, projects?: ProjectsProvider): Promise<void>;
 /** Serve one file of a module that is the computer's: as {@link serveModuleFile}, with no project to be registered. */

package/dist/module-types/src/dashboard/remote-run.d.ts

@@ -1,3 +1,4 @@
+import { type Health } from '../health.js';
 import { EventStream } from '../event-stream.js';
 import type { OpenAgentEvent } from '../events.js';
 import type { AgentMeta } from '../store/index.js';
@@ -50,13 +51,15 @@ export type RelayStartResult = StartAgentResult | {
 export declare function pingRemote(target: MachineAccess): Promise<boolean>;
 /**
  * What a saved machine says of itself in its ping: the OpenAgent it runs, the computer's own
- * name, which the records of its runs carry, and the ids it is listed under at the doors of the
- * machines it saved. Nothing for a machine that does not answer, or does not say.
+ * name, which the records of its runs carry, the ids it is listed under at the doors of the
+ * machines it saved, and whether it is a server. Nothing for a machine that does not answer, or does not say.
  */
 export declare function remoteFacts(target: MachineAccess): Promise<{
     version?: string;
     host?: string;
     listed?: string[];
+    server?: true;
+    health?: Health;
 }>;
 /** The OpenAgent a saved machine runs, as its ping tells it; nothing for a machine that does not answer, or does not say. */
 export declare function remoteVersion(target: MachineAccess): Promise<string | undefined>;
@@ -158,7 +161,7 @@ export interface BringProject {
  * shape, the same way a failed local read does. A refusal the machine gave a reason for is thrown
  * as a {@link MachineRefusal}, so the reason can be shown in place of that shape's own words.
  */
-export declare function relayRpc(target: RemoteTarget, fn: string, args: unknown[]): Promise<unknown>;
+export declare function relayRpc(target: RemoteTarget, fn: string, args: unknown[], timeoutMs?: number): Promise<unknown>;
 /**
  * Fetch-stream a remote agent's newline-delimited events into `onEvent` until the remote closes the
  * body, the agent ends, or `cancel()` is called. A 401 (this computer was removed there) ends the stream
@@ -258,6 +261,18 @@ export declare function remoteAddMachine(machine: MachineAccess, link: string, l
     ok: false;
     error: string;
 }>;
+/**
+ * Call one of a machine's own machine-wide functions (relay-dispatch.ts), with this computer's key
+ * there: through the relay, so a computer reached through a server is asked as a server is. What
+ * the machine answers is its own words, to read as data. Why not, when it did not answer.
+ */
+export declare function machineCall(machine: MachineAccess, fn: string, args: unknown[], timeoutMs?: number): Promise<{
+    ok: true;
+    ret: unknown;
+} | {
+    ok: false;
+    error: string;
+}>;
 /** The logins this computer's person has on a machine of another person's, as that machine says (machine-logins.ts). */
 export declare function remoteLogins(machine: MachineAccess): Promise<{
     ok: true;

package/dist/module-types/src/dashboard/rpc-serve.d.ts

@@ -8,6 +8,7 @@ import type { ProjectErrorsReader } from '../project-errors.js';
 import type { AddProjectResult, RemoveProjectResult, StartAgentOptions, StartAgentResult, StartedInResult } from './types.js';
 import type { AgentMeta } from '../store/index.js';
 import type { RemoteTarget } from './remote-run.js';
+import type { MachineRuns } from './machine-runs.js';
 /** Wired by the daemon so `sendStart` can reach the daemon's own `startAgent` closure. */
 export type StartAgentHandler = (prompt: string, options: StartAgentOptions, projectId?: string) => StartAgentResult | Promise<StartAgentResult>;
 /** Wired by the daemon so `sendAddProject` can install + register a repo (#433). */
@@ -53,6 +54,10 @@ export interface RemoteAgents {
      * it was given and its address. Asked of the machines first, when one has not said its name yet.
      */
     machineNames(): Promise<(host: string) => SavedMachine | undefined>;
+    /** What each saved machine says of its own runs of the project at `projectPath`, followed for a while from now on (machine-runs.ts). */
+    machineRuns(projectPath: string): Promise<MachineRuns[]>;
+    /** Tell `changed` each time a saved machine's runs of the project at `projectPath` change, until the answer is called. */
+    followRuns(projectPath: string, changed: () => void): () => void;
 }
 /**
  * What every RPC acts through.
@@ -118,8 +123,9 @@ export declare function isExpectedHost(req: IncomingMessage): boolean;
 export declare const RPC_PREFIX = "/_rpc";
 /**
  * Mount the dashboard's RPC surface (#405) on the daemon's `node:http` server: `POST /_rpc/<name>`
- * for the calls, `GET /_rpc/events` for the live stream. It runs in the daemon process, so
- * `sendStart` reaches the daemon's own `startAgent` through the wired {@link DashboardContext}.
+ * for the calls, `GET /_rpc/events` for the live stream, `GET /_rpc/changes` for when to read the
+ * runs again. It runs in the daemon process, so `sendStart` reaches the daemon's own `startAgent`
+ * through the wired {@link DashboardContext}.
  *
  * Cross-origin POSTs are rejected (CSRF: a page on evil.com must not steer or start a session), as
  * are requests carrying someone else's `Host` (DNS rebinding: the same page must not reach us by