@openagt/dashboard 0.40.0 → 0.41.0

package/dist/module-types/dashboard/rpc/machines.d.ts

@@ -0,0 +1,35 @@
+import type * as impl from '../../src/dashboard-rpc/machines.js';
+export type * from '../../src/dashboard-rpc/machines.js';
+export declare const onMachines: () => Promise<impl.Machine[]>;
+export declare const sendAddMachine: (pasted: string, label?: string | undefined, owner?: string | undefined) => Promise<impl.AddMachineResult>;
+export declare const sendRemoveMachine: (id: string) => Promise<impl.RemoveMachineResult>;
+export declare const onMachinesReachable: () => Promise<Record<string, boolean>>;
+export declare const onMachineVersions: () => Promise<impl.MachineVersions>;
+export declare const sendProjectToMachine: (projectId: string, machineId: string) => Promise<impl.ProjectOnMachine>;
+export declare const onProjectOnMachine: (projectId: string, machineId: string) => Promise<impl.ProjectOnMachine>;
+export declare const sendProjectHere: (projectId: string) => Promise<impl.ProjectOnMachine>;
+export declare const onProjectHere: (projectId: string) => Promise<impl.ProjectOnMachine>;
+export declare const onMachineStartCheck: (projectId: string, machineId: string, driver?: string | undefined) => Promise<import("../../src/project-hooks.js").StartReadiness | null>;
+export declare const onMachineModels: (machineId: string) => Promise<import("./models.js").ModelsView | null>;
+export declare const onComputersThrough: (machineId: string) => Promise<impl.ComputersThrough>;
+export declare const sendAddComputerThrough: (machineId: string, computerId: string) => Promise<impl.AddMachineResult>;
+export declare const onMachinePerson: (machineId: string) => Promise<impl.MachinePerson>;
+export declare const sendRemoveMachineDevice: (machineId: string, deviceId: string) => Promise<impl.MachinePerson>;
+export declare const sendRenameMachine: (id: string, label: string) => Promise<impl.AddMachineResult>;
+export declare const sendLetMachineIn: (machineId: string, link: string) => Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare const sendMachineCode: (machineId: string) => Promise<{
+    ok: true;
+    value: impl.MachineCode;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare const sendMachineTold: (machineId: string) => Promise<{
+    ok: boolean;
+}>;
+export declare const onMachineLogins: (machineId: string) => Promise<impl.MachineLoginsResult>;

package/dist/module-types/src/built-in.d.ts

@@ -39,6 +39,11 @@ export declare function builtInPackages(): Promise<ProjectPackage[]>;
 export declare function builtInPackagesOf(root: string): Promise<ProjectPackage[]>;
 /** The project's own installed packages, less the names OpenAgent brings itself. */
 export declare function ownPackages(root: string): Promise<ProjectPackage[]>;
+/**
+ * Every package OpenAgent brings to projects, the picked ones too, whatever a project holds: the
+ * copy a module's page is served from on a computer where no project of its own has the module.
+ */
+export declare function broughtToProjects(): Promise<ProjectPackage[]>;
 /** The packages that are this computer's: see {@link COMPUTER_PACKAGES}. */
 export declare function computerPackages(): Promise<ProjectPackage[]>;
 /**

package/dist/module-types/src/clone-project.d.ts

@@ -66,3 +66,14 @@ export interface CloneOptions {
  * folder a second ask could take for the project.
  */
 export declare function cloneProject(typed: string, opts?: CloneOptions): Promise<Cloned>;
+/**
+ * Whether this computer's logins read the repository at the address, asked of its host without
+ * cloning anything: what a run of a project cloned here first would hit before it starts. The
+ * answer is the clone's own words when they cannot.
+ */
+export declare function canRead(typed: string, opts?: CloneOptions, subject?: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;

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

@@ -22,8 +22,8 @@ export interface Activity {
 }
 /** Injectable seam so {@link buildActivity} is unit-testable off disk. */
 export interface ActivityDeps {
-    /** A project's runs, live prepended to the archived history, newest-first. Defaults to disk. */
-    readAgents?: (cwd: string) => Promise<AgentMeta[]>;
+    /** A project's runs, live prepended to the archived history, newest-first: off its folder by default, as its computer says them for another computer's. */
+    readAgents?: (project: ProjectSummary) => Promise<AgentMeta[]>;
 }
 /**
  * Build the cross-project activity feed: for each registered project's most recent agents, one

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

@@ -0,0 +1,91 @@
+import type { ProjectSummary } from './projects.js';
+/**
+ * The projects of the person's other computers, as this one lists them beside its own: a
+ * laptop's on its server, a server's on the laptop. Each computer says its own projects only
+ * ({@link OwnProject}), over the relay of the saved machine it is, and only a computer that is
+ * the person's own is asked: a computer of another person's, shared on a server, keeps its
+ * projects to its person.
+ *
+ * A project this computer has too, by its repository's address, is listed once, as this
+ * computer's: a run of it goes to any computer that has it, by "Run on". One only another
+ * computer has is listed as that computer's, under an id of its own ({@link elsewhereId}): what
+ * the page asks of it is asked of that computer, and a run of it starts there unless another
+ * computer is picked, which clones it first. What a computer said last is kept, so its projects
+ * stay listed while it is off.
+ */
+/** What a computer says of one of its own projects to another computer of the person's. */
+export interface OwnProject {
+    /** Its id there. */
+    id: string;
+    name: string;
+    /** Its folder there. */
+    path: string;
+    /** Its repository's address ({@link import('../repository-address.js').repositoryAddress}), when it has one. */
+    address?: string;
+    /** The same address in the letters its `origin` is written with: what another computer clones it from. */
+    spelling?: string;
+    /** Whether the agents' records of it go to its repository's remote: a copy cloned from it takes the same answer. */
+    share: boolean;
+    gitHost: boolean;
+    activated: boolean;
+    lastActivityAt?: string;
+    /** The packages that bring it a module's pages there (Queue, Tickets, Automations): the pages it has here too. */
+    modules?: string[];
+}
+/** What a computer answered as its projects, the ones that read as projects: anything else is dropped. */
+export declare function ownProjectsOf(said: unknown): OwnProject[];
+/** The id here of a project of another computer's: its id there, and the mark of the saved machine it is. */
+export declare function elsewhereId(projectId: string, machineId: string): string;
+/** Whether an id is that of another computer's project, not one of this computer's own. */
+export declare function isElsewhereId(id: unknown): id is string;
+/** How a call about the project names it to its computer: its repository's address, or its id there when it has none. */
+export declare function lineNameOf(project: Pick<OwnProject, 'id' | 'address'>): string;
+/** The project's id on its computer, from how a call named it there: undefined for an address. */
+export declare function idInLineName(name: string): string | undefined;
+/** A saved machine of the person's own, with what it said of its projects last. */
+export interface OwnMachine {
+    id: string;
+    projects?: OwnProject[];
+}
+/** A project of another computer's: the saved machine it is on, and the project as that computer said it. */
+export interface ElsewhereHome<M extends OwnMachine = OwnMachine> {
+    machine: M;
+    project: OwnProject;
+}
+/** The listing of another computer's project, as the page lists projects: marked with the saved machine it is on. */
+export declare function elsewhereSummary(home: ElsewhereHome): ProjectSummary;
+/**
+ * The projects of the person's other computers that this one does not have, each listed once:
+ * one whose repository's address is a project here is this computer's, and of two computers
+ * with the same repository the first one listed has it. A project with no address is only its
+ * own computer's, and listed for it.
+ */
+export declare function elsewhereHomes<M extends OwnMachine>(machines: readonly M[], ownAddresses: ReadonlySet<string>): ElsewhereHome<M>[];
+/** The project of another computer's with this id, among the saved machines, whether it is listed here or not. */
+export declare function homeOf<M extends OwnMachine>(machines: readonly M[], id: string): ElsewhereHome<M> | undefined;
+/** How long a computer's word on its projects is taken before it is asked again. */
+export declare const PROJECTS_KEPT_MS = 20000;
+/** How long a list waits for a computer never answered before: what it says after comes at the next list. */
+export declare const FIRST_WAIT_MS = 3000;
+/**
+ * Each of the person's computers asked for its projects at most every {@link PROJECTS_KEPT_MS}, and
+ * what it said kept by `keep` (the saved machine's record), so a list is made of what each said
+ * last: at once, while each is asked again behind it. One never answered yet is waited for a
+ * little, the first time.
+ */
+export declare class OwnProjectsAsked<M extends OwnMachine> {
+    /** Ask the machine for its projects. */
+    private readonly ask;
+    /** Keep what the machine said, when it answered and said otherwise than it had. */
+    private readonly keep;
+    private readonly now;
+    private readonly asked;
+    constructor(
+    /** Ask the machine for its projects. */
+    ask: (machine: M) => Promise<unknown>, 
+    /** Keep what the machine said, when it answered and said otherwise than it had. */
+    keep: (machine: M, projects: OwnProject[]) => Promise<void>, now?: () => number);
+    /** Ask each machine whose word is old, and wait for the ones never heard from, a little. */
+    refresh(machines: readonly M[]): Promise<void>;
+    private askOne;
+}

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

@@ -4,6 +4,7 @@ import type { ProjectSummary, ProjectionRead } from './projects.js';
 import { type BranchesFor } from '../store/branches.js';
 import { type PrLister } from './pull-requests.js';
 import { type BridgeQuestion } from './bridge-question.js';
+import type { MachineKind } from '../reached-by-line.js';
 export { interventionKey } from './keys.js';
 /**
  * One item awaiting the human: an open `pr` to review and merge or close, a run `awaiting` the
@@ -42,6 +43,11 @@ export interface Intervention {
     files?: number;
     /** When the PR was opened (`pr`) or the agent last updated (the other two), ISO, for ordering. */
     createdAt?: string;
+    /** The computer the run it is about runs on, when that is one of the person's other computers: the saved machine's name and kind. */
+    computer?: {
+        name: string;
+        kind: MachineKind;
+    };
 }
 /** Injectable seam so {@link buildInterventions} is unit-testable off disk. */
 export interface InterventionsDeps {

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

@@ -0,0 +1,51 @@
+import type { Intervention } from './interventions.js';
+import type { ProjectionRead } from './projects.js';
+/**
+ * The Human Queue of the person's other computers, beside this one's own: what needs the person in
+ * a run there (its question, the work it left unpublished, the PR it opened) and the PRs of a
+ * project only another computer has. Each computer says the items of its own projects only, never
+ * the ones it lists of other computers', so two computers never ask each other in a circle. Here
+ * each item is named by the project as it is listed here: this computer's own of the same
+ * repository, else the other computer's under its id here; and an item of a run there is marked
+ * with that computer.
+ */
+/** What the person's other computers said of their Human Queues, each as named here, and the projects here that one which did not answer has. */
+export interface MachinesQueue {
+    said: ProjectionRead<Intervention>[];
+    /** Projects here whose items on a computer that did not answer are not known: none of them is read whole. */
+    unread: string[];
+}
+/** What a computer answered as its Human Queue, the items that read as items, each in the fields an item has: anything else is dropped. */
+export declare function interventionsOf(said: unknown): ProjectionRead<Intervention>;
+/**
+ * A computer's Human Queue as named here: each item by `idHere` of its project's id there, and one
+ * about a run marked with the computer it runs on. An item of a project not listed here is dropped.
+ */
+export declare function namedHere(said: ProjectionRead<Intervention>, idHere: (theirs: string) => string | undefined, computer: NonNullable<Intervention['computer']>): ProjectionRead<Intervention>;
+/**
+ * This computer's Human Queue with what the other computers said: each item named as its project is
+ * here (`names`, by id: one not listed is dropped), once, newest first. Of a PR both list, the one
+ * a run opened is kept: its row opens the run. A project is read whole when every computer that has
+ * it answered.
+ */
+export declare function withMachinesQueue(own: ProjectionRead<Intervention>, machines: MachinesQueue, names: ReadonlyMap<string, string>): ProjectionRead<Intervention>;
+/** How long a computer's Human Queue is taken before it is asked again: a page asks every few seconds. */
+export declare const QUEUE_KEPT_MS = 10000;
+/** How long a Human Queue waits for a computer never answered before: what it says after comes at the next read. */
+export declare const QUEUE_FIRST_WAIT_MS = 3000;
+/**
+ * Each machine asked at most every {@link QUEUE_KEPT_MS}, and what it said last kept: a read is
+ * answered at once with that while the machine is asked again behind it. One never answered yet is
+ * waited for a little; one whose last ask failed has nothing kept, so its items are not taken as
+ * still there.
+ */
+export declare class AnswersKept<M extends {
+    id: string;
+}, T> {
+    private readonly ask;
+    private readonly now;
+    private readonly kept;
+    constructor(ask: (machine: M) => Promise<T>, now?: () => number);
+    /** What each machine said last, by its id: one that never answered, or whose last ask failed, has none. */
+    of(machines: readonly M[]): Promise<Map<string, T>>;
+}

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

@@ -5,10 +5,14 @@ import { type ProjectModule } from '../project-modules.js';
 export declare const MODULES_PREFIX = "/_modules";
 /** Where the files of the computer's modules are served, which are no project's: `/_computer-modules/<package>/<file>`. */
 export declare const COMPUTER_MODULES_PREFIX = "/_computer-modules";
+/** Where the files of the modules OpenAgent brings to projects are served from its own copy: `/_brought-modules/<package>/<file>`. */
+export declare const BROUGHT_MODULES_PREFIX = "/_brought-modules";
 /** The URL a module's browser part is served at from one project. */
 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;
+/** The URL the browser part of a module OpenAgent brings to projects is served at from its own copy. */
+export declare function broughtModuleUrl(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.
@@ -27,3 +31,5 @@ export declare function versionedModuleUrl(url: string, module: Pick<ProjectModu
 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. */
 export declare function serveComputerModuleFile(req: IncomingMessage, res: ServerResponse, pathname: string): Promise<void>;
+/** Serve one file of a module OpenAgent brings to projects, from its own copy: as {@link serveComputerModuleFile}. */
+export declare function serveBroughtModuleFile(req: IncomingMessage, res: ServerResponse, pathname: string): Promise<void>;

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

@@ -1,6 +1,7 @@
 import { type LiveAgent, type AgentMeta, type AgentStatus } from '../store/index.js';
 import type { ProjectSummary } from './projects.js';
 import { type ProjectQueue } from './queue.js';
+import type { MachineKind } from '../reached-by-line.js';
 /** One project's in-flight run, surfaced in the Overview's "working now" list. */
 export interface ActiveAgent {
     projectId: string;
@@ -21,8 +22,14 @@ export interface ActiveAgent {
      * cloud side is the agent, and "no agents working" over a waiting cloud session was a lie.
      */
     cloud?: 'in-cloud' | 'waiting';
-    /** The machine whose daemon started it (#1648), only when that is not this one. */
-    host?: string;
+    /**
+     * The computer it runs on, only when that is not this one: the saved machine's name and kind for
+     * a run of one of the person's other computers, else the computer its record names (#1648).
+     */
+    computer?: {
+        name: string;
+        kind?: MachineKind;
+    };
 }
 /** One recently active project, most-recent first. */
 export interface RecentProject {
@@ -47,7 +54,8 @@ export interface RecentAgent {
 }
 /** Injectable reader so {@link buildRecentAgents} is unit-testable off disk. */
 export interface RecentAgentsDeps {
-    agents?: (cwd: string) => Promise<AgentMeta[]>;
+    /** A project's runs: off its folder for one of this computer's, as its computer says them for another's. */
+    agents?: (project: ProjectSummary) => Promise<AgentMeta[]>;
 }
 /**
  * Every project's sessions pooled and sorted newest-first (capped), so the shared sidebar (#shared-
@@ -65,13 +73,20 @@ export interface OverviewDeps {
     /** Whether the bridge holds a question for that cloud session (default: the daemon's bridge store). */
     waiting?: (sessionId: string) => boolean;
     now?: () => number;
+    /**
+     * The runs the person's other computers say they run of a project, each marked with the saved
+     * machine it is (`remoteLabel`): of a project this computer has too, and of one only they have.
+     */
+    machineRuns?: (project: ProjectSummary) => Promise<AgentMeta[]>;
     /** This machine's hostname; `node:os` in production. */
     host?: string;
 }
 /**
  * Build the cross-project Overview: the running agents (every live agent of each project, one per
- * worktree since #736), the total of open queue entries (from {@link collectQueue}), and the most
- * recently active projects (by {@link ProjectSummary.lastActivityAt}). Forgiving — a project
+ * worktree since #736, and every run the person's other computers say is running), the total of
+ * open queue entries (from {@link collectQueue}), and the most recently active projects (by
+ * {@link ProjectSummary.lastActivityAt}). A project of another computer's ({@link ProjectSummary.machine})
+ * has no folder here: only what its computer says of its runs is read. Forgiving — a project
  * with no live run, or none running, simply contributes nothing to `active`.
  */
 export declare function buildOverview(projects: ProjectSummary[], deps?: OverviewDeps): Promise<Overview>;

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

@@ -12,8 +12,15 @@ import { type GitHostFor } from '../store/git-host.js';
 export interface ProjectSummary {
     /** Registry id (stable, URL-safe). */
     id: string;
-    /** Absolute repo path. */
+    /** Absolute repo path: on the computer the project is on. */
     path: string;
+    /**
+     * The saved machine the project is on, when it is not on this computer (elsewhere.ts): what the
+     * page asks of it is asked there, and a run of it starts there unless another computer is picked.
+     */
+    machine?: string;
+    /** The packages that bring a module's pages to a project of another computer's, as that computer said them. */
+    modules?: string[];
     /** Display name (the path's basename). */
     name: string;
     /** True when the repo still has its `.openagent/` marker. */
@@ -56,10 +63,12 @@ export interface SummarizeDeps {
     readAgents?: (path: string) => Promise<AgentMeta[]>;
     /** The project's git host. Defaults to {@link projectGitHost}. */
     gitHost?: GitHostFor;
+    /** The project's name. Defaults to {@link projectNameOf}: its repository's. */
+    name?: (path: string) => Promise<string>;
 }
 /** A project's runs, live prepended to the archived history. Forgiving: a failed read is `[]`. */
 /**
- * Derive a {@link ProjectSummary} from a registry record: its display name, whether
+ * Derive a {@link ProjectSummary} from a registry record: its name (its repository's), whether
  * it is still activated, and its last activity. Forgiving: a failed read reads as an
  * inactive project with no activity, never a throw.
  *

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

@@ -1,4 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type OwnProject } from './elsewhere.js';
+import type { MachinesQueue } from './machine-interventions.js';
+import type { ProjectSummary } from './projects.js';
 import type { OpenAgentEvent } from '../events.js';
 import type { PreferencesStore } from '../registry.js';
 import type { QuotaSource } from './quota.js';
@@ -7,7 +10,7 @@ import type { BridgeBrowserOwner } from '../bridge-browser.js';
 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 { BringProject, RelayProject, 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>;
@@ -58,6 +61,23 @@ export interface RemoteAgents {
     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;
+    /** The projects of the person's other computers that this one does not have, each marked with the saved machine it is on (elsewhere.ts). */
+    elsewhere(): Promise<ProjectSummary[]>;
+    /** What the computer another computer's project is on says of its own runs of it, followed for a while from now on. */
+    elsewhereRuns(projectId: string): Promise<MachineRuns[]>;
+    /** Tell `changed` each time the runs of another computer's project change there, until the answer is called. */
+    followElsewhereRuns(projectId: string, changed: () => void): () => void;
+    /** Another computer's project by its id here: the saved machine it is on, and the project as that computer said it. */
+    elsewhereHome(projectId: string): Promise<{
+        machine: string;
+        project: OwnProject;
+    } | undefined>;
+    /** Make a page's call about another computer's project on that computer, and answer what it answered. */
+    forward(projectId: string, fn: string, args: unknown[]): Promise<unknown>;
+    /** What the person's other computers say of their Human Queues, each named as its project is here (machine-interventions.ts). */
+    machinesQueue(): Promise<MachinesQueue>;
+    /** Where this computer's copy of the project at `address` stands; with `bring`, cloned and added when there is none, on its own. */
+    bringHere(address: string, bring?: BringProject): Promise<RelayProject>;
 }
 /**
  * What every RPC acts through.

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

@@ -119,12 +119,14 @@ export interface StartAgentOptions {
  * there is none. `driver` is the coding agent the hook said runs it: what another computer that
  * follows the run shows, since the run's record stays on this one. `notThere` marks the one
  * refusal a page can do something about: the machine the run was sent to does not have the
- * project yet, and can clone it.
+ * project yet, and can clone it. `projectId` is the project the run started in, when it is not the
+ * one the start named: this computer's own copy of a project another computer of the person's has.
  */
 export type StartAgentResult = {
     ok: true;
     agentId: string;
     driver?: string;
+    projectId?: string;
 } | {
     ok: false;
     error: string;

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

@@ -1,7 +1,7 @@
 export { onAgents, onModuleAgents, onAgent, onAgentsDoing, onDocs, onQueue, onOverview, onRecentAgents, onInterventions, onActivity, onDashboard, onGitHostHome, onRepositoryOffer, onGitStatus, onProjectFiles, onRetainedWorktrees, onAgentWorktree, onAgentHandoff, onBridgeQuestion, onBridgeStatus, onBridgeToken, onBridgeEvents, onBridgeAnswer, onBridgeBrowser } from './reads.js';
 export { sendStop, sendChoice, sendBridgeAnswer, sendBridgeAnswerCancel, sendBridgeBrowser, sendMessage, sendStart, sendOpenInApp, sendRemoveWorktree, sendDeleteAgent, sendOpenPullRequest, sendPush, sendMergeBranch, sendMerge, sendCreateRepository } from './control.js';
 export { streamAgentEvents, type LiveFeedEvent, type PartialMessage, type StreamSync } from './events.js';
-export { onProjects, sendAddProject, sendStartedAgain, onCloneTarget, sendAddProjectFromAddress, sendRemoveProject, onRecordsReach, sendShareRecords, sendPickProjectDirectory, onOnboarding, onCommands, onStartCheck, type ProjectLauncher } from './projects.js';
+export { onProjects, sendAddProject, sendStartedAgain, onCloneTarget, sendAddProjectFromAddress, sendRemoveProject, onRecordsReach, sendShareRecords, sendPickProjectDirectory, onOnboarding, onCommands, onStartCheck, onCloneCheck, type ProjectLauncher } from './projects.js';
 export { onPreferences, savePreferences, patchPreferences, onProjectPresets, saveProjectPresets, onEditors, type SavePreferencesResult, type PatchPreferencesResult, } from './preferences.js';
 export { type EditorInfo } from '../dashboard/open-in-app.js';
 export { onQuota } from './quota.js';

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

@@ -1,6 +1,7 @@
 import { type Health } from '../health.js';
 import { type MachineLogins } from '../dashboard/machine-logins.js';
 import { type StartReadiness } from '../project-hooks.js';
+import type { ModelsView } from '../dashboard/models.js';
 /** A saved machine as the browser sees it: no key. */
 export interface Machine {
     id: string;
@@ -211,8 +212,22 @@ export declare function sendProjectToMachine(projectId: string, machineId: strin
 export declare function onProjectOnMachine(projectId: string, machineId: string): Promise<ProjectOnMachine>;
 /**
  * What would stop a run sent to a saved machine, as the machine says from its own copy of the
- * project: its coding agent there, installed and logged in. `null` when there is nothing to say:
- * a machine that does not answer, does not have the project yet (it clones it at the first run),
- * or has no check.
+ * project: its coding agent there, installed and logged in. A machine that does not have the
+ * project yet clones it at the first run, and says before it whether it could: its coding agent,
+ * and whether its logins read the repository. `null` when there is nothing to say: a machine that
+ * does not answer, or one with no check.
  */
 export declare function onMachineStartCheck(projectId: string, machineId: string, driver?: string): Promise<StartReadiness | null>;
+/**
+ * The models each coding agent offers on a saved machine, as it asked its own: a run sent there is
+ * given one of these. `null` when it does not answer, or runs an OpenAgent that is not asked this.
+ */
+export declare function onMachineModels(machineId: string): Promise<ModelsView | null>;
+/**
+ * Have this computer clone a project only another computer of the person's has (elsewhere.ts),
+ * for a run here: on its own, as for a machine that is sent a run. {@link onProjectHere} says when
+ * it is here. Nothing happens when it is here already, or on its way.
+ */
+export declare function sendProjectHere(projectId: string): Promise<ProjectOnMachine>;
+/** Whether this computer has another computer's project by now, or why it will not. */
+export declare function onProjectHere(projectId: string): Promise<ProjectOnMachine>;

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

@@ -3,8 +3,15 @@ import { type BranchReach } from '@openagt/agent-data';
 import { type StartReadiness } from '../project-hooks.js';
 import { type PickDirectoryResult } from '../pick-directory.js';
 import type { ProjectSummary } from '../dashboard/projects.js';
+import type { OwnProject } from '../dashboard/elsewhere.js';
 import type { AddProjectResult, OnboardingSuggestion, RemoveProjectResult, StartedInResult } from '../dashboard/types.js';
 export declare function onProjects(): Promise<ProjectSummary[]>;
+/**
+ * This computer's own projects, for another computer of the person's that lists them beside its
+ * own (elsewhere.ts): each with the address another computer names it by and clones it from, and
+ * whether its agents' records are shared. Never the projects this computer lists of others.
+ */
+export declare function onOwnProjects(): Promise<OwnProject[]>;
 /**
  * Add a project from the dashboard (#396/#433): install the repo and register it so it joins the
  * Projects list. Like `sendStart` this needs the daemon (it spawns git + writes the shared
@@ -110,3 +117,10 @@ export declare function onCommands(projectId: string): Promise<ProjectLauncher |
  * `null` for an unknown project or one without a check hook: nothing to say.
  */
 export declare function onStartCheck(projectId: string, driver?: string): Promise<StartReadiness | null>;
+/**
+ * What would stop a run of a project this computer clones first, asked before it does: its coding
+ * agent, installed and logged in, and whether its logins read the repository at the address. A
+ * computer that does not have the project yet has no check hook of it to run. `as` is what the
+ * asker calls this computer, so the words read right on its page.
+ */
+export declare function onCloneCheck(address: string, driver?: string, as?: string): Promise<StartReadiness>;

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

@@ -173,6 +173,12 @@ export declare function onRecentAgents(): Promise<RecentAgent[]>;
  * backlog the moment the git host answers.
  */
 export declare function onInterventions(): Promise<ProjectionRead<Intervention>>;
+/**
+ * This computer's own Human Queue, for another computer of the person's that shows it beside its
+ * own (machine-interventions.ts): the items of this computer's projects only, never of the
+ * projects it lists of other computers, so no computer asks back the one that asked it.
+ */
+export declare function onOwnInterventions(): Promise<ProjectionRead<Intervention>>;
 /**
  * The cross-project "New activity" feed (#627): recent run started/finished transitions, newest
  * first, with the projects that were read whole beside them (#1625) — see {@link onInterventions}.

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

@@ -0,0 +1,28 @@
+/** The names a relay caller may invoke. */
+export declare const RELAY_RPC_NAMES: readonly string[];
+/**
+ * The calls a page makes about another computer's project (elsewhere.ts) that this computer passes
+ * on to that computer as they are: every relayed one but a start, which goes where "Run on" says,
+ * and a computer's own runs, which only a computer asks for.
+ */
+export declare const ELSEWHERE_FORWARDED: ReadonlySet<string>;
+/** Whether a relayed RPC only reads. A name that is not on the whitelist is no read. */
+export declare function isRelayRead(fn: string): boolean;
+/**
+ * Whether one relayed call only reads, here: a read by its name, or a module's command that its
+ * package says only reads, as this computer's own copy of the module says it. The caller's word
+ * for it counts for nothing: a server holding this computer's key could call any command a read.
+ */
+export declare function isRelayReadCall(projectId: string, fn: string, args: readonly unknown[]): Promise<boolean>;
+/**
+ * Dispatch one relayed RPC against `projectId` (this machine's own id for the project). `args[0]`
+ * from the caller is the remote daemon's project id and is meaningless here, so it is replaced
+ * with `projectId`; the rest (path, agentId, ...) carry through unchanged. Throws on an unknown name.
+ */
+export declare function dispatchRelayRpc(projectId: string, fn: string, args: unknown[]): Promise<unknown>;
+/** The machine-wide names a relay caller may invoke. */
+export declare const MACHINE_RPC_NAMES: readonly string[];
+/** Whether a machine-wide call only reads. A name that is not on the whitelist is no read. */
+export declare function isMachineRead(fn: string): boolean;
+/** Dispatch one machine-wide call, its arguments as the caller gave them. Throws on an unknown name. */
+export declare function dispatchMachineRpc(fn: string, args: unknown[]): Promise<unknown>;

package/dist/module-types/src/project-modules.d.ts

@@ -20,7 +20,20 @@ export interface ProjectModule {
     bins: Record<string, string>;
     /** The module's server part, an absolute path inside the package, when it has one. */
     server?: string;
+    /**
+     * The commands that only read, by command name: the first word of the arguments, or `""` for
+     * the command with no word (flags only). What a computer that lets its server only watch answers
+     * of the module; any other command changes something there, and is refused. The package says
+     * them: `"openagent": { "reads": { "<command>": ["list", ""] } }`.
+     */
+    reads: Record<string, string[]>;
 }
+/**
+ * Whether running the module's command with these arguments only reads, as its package says
+ * ({@link ProjectModule.reads}): its first word is a read, or it has no word and its bare form is
+ * one, every argument then being a flag.
+ */
+export declare function commandReads(module: Pick<ProjectModule, 'bins' | 'reads'>, args: readonly unknown[], command?: string): boolean;
 /**
  * The modules a project has: each of its dependencies whose package.json exports `./dashboard` to
  * a file that exists inside the package, plus the modules among the packages OpenAgent brings to
@@ -37,6 +50,12 @@ export declare function findProjectModule(root: string, name: string): Promise<P
 export declare function readComputerModules(): Promise<ProjectModule[]>;
 /** The one module of this computer's that `name` names, or undefined. */
 export declare function findComputerModule(name: string): Promise<ProjectModule | undefined>;
+/**
+ * The module of a package OpenAgent brings to projects, from OpenAgent's own copy: the page of
+ * another computer's project, on a computer where no project of its own has it. Undefined for any
+ * other package.
+ */
+export declare function findBroughtModule(name: string): Promise<ProjectModule | undefined>;
 /**
  * The file a module serves at `rel`, a path relative to its module's directory: its module, its
  * stylesheet, a chunk. `undefined` for a path that leaves that directory (symlinks resolved) or

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

@@ -1,5 +1,6 @@
 import { type OverviewLayouts } from './overview-layout.js';
 import { type PublishPick } from './publish-levels.js';
+import { type OwnProject } from './dashboard/elsewhere.js';
 /**
  * The multi-project registry (#390): the list of projects the user has
  * installed OpenAgent into, kept as a single JSON file `.bashrc`-style —
@@ -58,6 +59,8 @@ export interface MachineRecord {
     listed?: string[];
     /** When the machine last answered for its runs, ISO, kept to the minute: what its runs say while it does not answer. */
     seenAt?: string;
+    /** Its own projects, as it said them last (elsewhere.ts): a computer of the person's own lists them while it does not answer. */
+    projects?: OwnProject[];
 }
 /** A GitHub account's name: letters, digits and single dashes, at most 39. */
 export declare function isAccount(value: unknown): value is string;
@@ -348,6 +351,11 @@ export declare function noteSeen(machine: {
     id: string;
     key: string;
 }, at: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<void>;
+/** Keep what a saved machine said of its own projects: the same machine, by its key, or nothing is written. */
+export declare function noteProjects(machine: {
+    id: string;
+    key: string;
+}, projects: OwnProject[], fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<void>;
 /** Write down that the person was told their logins are copied to a saved machine of another person's. Answers whether it is saved. */
 export declare function tellMachine(id: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<boolean>;
 /** Say whether a saved server uses this computer's logins. Answers whether it is saved. */

package/dist/module-types/src/repository-address.d.ts

@@ -26,5 +26,11 @@ export declare function spellingOfRemote(remote: string): string | undefined;
  * machine only.
  */
 export declare function repositoryAddress(cwd: string, git?: GitRunner): Promise<string | undefined>;
+/**
+ * A project's name: its repository's, the last part of its address in the letters `origin` writes
+ * it with, so the project reads the same on every computer whatever its folder there is called.
+ * A project with no address is its folder's.
+ */
+export declare function projectNameOf(cwd: string, git?: GitRunner): Promise<string>;
 /** The same address in the letters the `origin` remote is written with: see {@link spellingOfRemote}. */
 export declare function repositorySpelling(cwd: string, git?: GitRunner): Promise<string | undefined>;