@openagt/dashboard 0.10.0 → 0.12.0

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

@@ -104,13 +104,13 @@ export interface ModuleCard {
 }
 /** What a Settings section is rendered with: the projects that have its package. */
 export interface ModuleSettingsProps {
-    /** The registered projects whose dependencies include the module's package, in the registry's order. */
+    /** The registered projects whose dependencies include the module's package, in the registry's order; none for a package that is the computer's. */
     projects: ModuleProject[];
 }
 /**
  * A section a module adds to the Settings page: the package's own settings, read and written
- * through its own command, drawn after the dashboard's own sections. A package with no projects
- * registered shows none.
+ * through its own command, drawn after the dashboard's own sections. A project's package with no
+ * project registered shows none; a package that is the computer's shows its own with no project.
  */
 export interface ModuleSettings {
     /** Which section this is, for the shell's key and its error line; the section draws its own title. */
@@ -191,6 +191,11 @@ export interface ModulePanel {
      * on it, and hands it the file as `reveal`. Without such a tab, those rows open nothing.
      */
     changes?: true;
+    /**
+     * This tab shows a run's live screen ({@link ModuleHost.watchScreen}). The chat's row of a live
+     * screen then opens the side panel on it. Without such a tab, that row is a line of text.
+     */
+    screen?: true;
     /** The tab's contents. */
     Panel: ComponentType<ModulePanelProps>;
 }
@@ -268,6 +273,12 @@ export interface ModuleHost {
      * change shows at once instead of at the next sync. A link action's host runs every command so.
      */
     act(projectId: string, args: string[], command?: string): Promise<ModuleCommandResult>;
+    /**
+     * Run one of the module package's own commands in no project, for a package that is this
+     * computer's (the door to it, its servers): what such a package keeps is the computer's, so
+     * its page reads and changes it with no project added. Refused for any other package.
+     */
+    runComputerCommand(args: string[], command?: string): Promise<ModuleCommandResult>;
     /**
      * Call one of the module's own server reads (its package's `./server`) in one project, with
      * `input`, a JSON object; `input.agentId` names the run the read is about, when it is about one.
@@ -290,9 +301,49 @@ export interface ModuleHost {
     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 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.
+     */
+    machines(): Promise<ModuleMachines>;
+    /**
+     * Save the machine a link names: the link another OpenAgent gives for a new device, as a person
+     * pastes it under Machines. This computer is let in there with it, once, and keeps its key.
+     */
+    addMachine(link: string, label?: string): Promise<MachineAdded>;
+    /**
+     * What the live screen of a run shows, as the screen's own stream of bytes, until `signal` ends
+     * it; nothing when the run has no live screen. OpenAgent asks the computer the run is on, which
+     * may be another machine: the bytes are that computer's, to read as data and never to run.
+     */
+    watchScreen(projectId: string, agentId: string, signal: AbortSignal): Promise<ReadableStream<Uint8Array> | undefined>;
+    /** 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 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. */
+    id: string;
+    label: string;
+    url: string;
+    /** The OpenAgent it runs; absent for a machine that does not answer right now. */
+    version?: string;
+}
+/** What {@link ModuleHost.machines} answers. */
+export interface ModuleMachines {
+    /** This computer's own OpenAgent. */
+    version: string;
+    machines: ModuleMachine[];
 }
+/** How saving a machine went: done, or stopped, with the reason. */
+export type MachineAdded = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
 /** What the dashboard knows about the module it is serving: every service but the commands and the reads, which it binds to the package. */
-export type ModuleHostBase = Omit<ModuleHost, 'runCommand' | 'act' | 'read'>;
+export type ModuleHostBase = Omit<ModuleHost, 'runCommand' | 'act' | 'runComputerCommand' | 'read'>;
 /**
  * The host for one module: the dashboard's services, and its commands bound to the module's own
  * package. `acts` marks every command as an action on the project rather than a page's read: the
@@ -329,6 +380,7 @@ export { StartAgentButton } from '../components/StartAgentButton.js';
 export { LinkActions, type ProjectLinks, type LinkTargets } from '../components/LinkActions.js';
 export { cn } from '../lib/utils.js';
 export { SettingsSection, SettingsRow, SettingsSelectRow, type SettingsOption } from '../components/SettingsRows.js';
+export { QrCode } from '../components/QrCode.js';
 export { useCodingAgents, type CodingAgent } from '../lib/models.js';
 export { MAX_SPEND_OFFSET } from '../../src/preference-defaults.js';
 export { formatRelative, formatDateTime, formatDuration, formatAge } from '../lib/format-date.js';

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

@@ -2,4 +2,5 @@ import type * as impl from '../../src/dashboard-rpc/modules.js';
 export type * from '../../src/dashboard-rpc/modules.js';
 export declare const onModules: () => Promise<impl.DashboardModule[]>;
 export declare const runModuleCommand: (projectId: string, pkg: string, args: string[], command?: string | undefined, acts?: boolean | undefined) => Promise<import("@openagt/agent-data").PackageCommandResult>;
+export declare const runComputerCommand: (pkg: string, args: string[], command?: string | undefined) => Promise<import("@openagt/agent-data").PackageCommandResult>;
 export declare const readModule: (projectId: string, pkg: string, name: string, input: unknown) => Promise<impl.ModuleReadResult>;

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

@@ -5,12 +5,18 @@ import { type ProjectPackage, type ProvidedCommand, type ProvidedCommandLookup }
  * own install, so a project installs nothing for them and an empty folder starts an agent and
  * shows it. Each comes through the same contract as any package: a module by its `./dashboard`
  * export, a provider of a kind of data and the writer of its hook lines by its `openagent` key.
- * These two lists are the one place OpenAgent names a package. One of these names among a
+ * These three lists are the one place OpenAgent names a package. One of these names among a
  * project's own dependencies is not read: OpenAgent's copy, and the rules below for which
  * project has it, are the only ones.
  */
 /** The packages every project has: an agent cannot start, be shown or be put on a git host without them. */
 export declare const BUILT_IN_PACKAGES: readonly string[];
+/**
+ * The packages that are this computer's and no project's: the door to it, and the servers it
+ * installed OpenAgent on. Their pages show and their commands run with no project added, and
+ * what one keeps is in the person's home folder.
+ */
+export declare const COMPUTER_PACKAGES: readonly string[];
 /**
  * The packages a project has once it picked them (#2023). A skill's package is the project's
  * when the project holds the skill's text where the coding agents read it
@@ -27,11 +33,21 @@ export declare function builtInPackages(): Promise<ProjectPackage[]>;
 /**
  * The packages OpenAgent brings to the project at `root`: the ones every project has, and
  * each picked one the project has by its rule (see {@link PICKED_PACKAGES}). Read off the
- * project's files each time, so a skill written or deleted a moment ago counts at once.
+ * project's files each time, so a skill written or deleted a moment ago counts at once. None of
+ * the computer's: no project has those.
  */
 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[]>;
+/** The packages that are this computer's: see {@link COMPUTER_PACKAGES}. */
+export declare function computerPackages(): Promise<ProjectPackage[]>;
+/**
+ * The services of the computer's packages: a package declares
+ * `"openagent": { "service": "<command>" }`, and `<command> serve` runs for as long as OpenAgent
+ * runs (`package-services.ts`). Only those packages: a service is this computer's, and any
+ * other package is a project's.
+ */
+export declare function builtInServices(): Promise<ProvidedCommand[]>;
 /** The directories the commands of OpenAgent's packages sit in: what a hook line's PATH gains after the project's own installed tools. */
 export declare function builtInBinDirs(): Promise<string[]>;
 /** What provides `kind` in the project at `root`: a package the project installed for it, else one OpenAgent brings to this project. */

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

@@ -1,6 +1,7 @@
 export { DRIVERS, DRIVER_LABELS, isDriverName, driverFromImpl, type DriverName } from './driver-names.js';
 export { PUBLISH_LABELS, isPublishPick, offeredPublishPicks, publishPickIn, type PublishPick } from './publish-levels.js';
 export { formatOpenAgentEvent } from './terminal.js';
+export { foldScreenRows } from './screens.js';
 export { formatBytes } from './format-bytes.js';
 export { errorMessage } from './error-message.js';
 export { pickedIds } from './events.js';
@@ -10,6 +11,6 @@ export { interventionKey, activityKey } from './dashboard/keys.js';
 export { SeenTracker } from './dashboard/keyed-watcher.js';
 export type { ProjectionRead } from './dashboard/projects.js';
 export { NOTIFICATION_DEFAULTS, MAX_SPEND_OFFSET, notifies, browserNotifyEnabled, notifyCategoryEnabled, type NotifyCategory } from './preference-defaults.js';
-export { isLoopbackHost } from './loopback-host.js';
+export { parseMachineLink } from './machine-link.js';
 export { bridgeChoiceRequest } from './dashboard/bridge-question.js';
 export { cloudRunState, cloudRunActive, CLOUD_SESSION_WINDOW_MS, type CloudRunState } from './cloud-run-state.js';

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

@@ -0,0 +1,68 @@
+/**
+ * A project added by its repository's address, for a computer that does not have its folder: a
+ * server that was just connected has no screen to pick a folder on and no folder to pick. The
+ * repository is cloned into `~/projects/<its name>`, in the home of the user OpenAgent runs as,
+ * and that folder is then added like any other. Nothing is asked about where: the page says
+ * where it went.
+ *
+ * git clones with the logins this computer has (its credential helper, its SSH keys) and is
+ * never let ask a person for one: a repository it cannot read is refused in words.
+ */
+/** Where a repository is cloned from and to. */
+export interface CloneTarget {
+    /** What git is given. */
+    url: string;
+    /** The repository's one name on every machine: see `addressOfRemote`. */
+    address: string;
+    /** The folder it is cloned into. */
+    path: string;
+}
+/**
+ * Read what a person typed as a repository's address: `github.com/you/shop`, the same with
+ * `https://` before it, `ssh://git@github.com/you/shop.git`, or `git@github.com:you/shop.git`.
+ * Undefined for anything else: a folder on this disk, another kind of address, a name that could
+ * be read as an option or lead out of the folder projects are cloned into.
+ */
+export declare function cloneTarget(typed: string, home?: string): CloneTarget | undefined;
+/** How a clone went: the folder the project is in, and whether it was cloned now or was already there. */
+export type Cloned = {
+    ok: true;
+    path: string;
+    cloned: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/** Run git and answer how it ended, with what it said on its error side. */
+export type CloneRunner = (args: readonly string[], env: NodeJS.ProcessEnv, timeoutMs: number) => Promise<{
+    ok: true;
+} | {
+    ok: false;
+    said: string;
+    timedOut: boolean;
+}>;
+/** Where what a person typed would be cloned to, before anything is cloned: what the page shows to be confirmed. */
+export declare function cloneTargetOf(typed: string, home?: string): {
+    ok: true;
+    address: string;
+    path: string;
+} | {
+    ok: false;
+    error: string;
+};
+export interface CloneOptions {
+    home?: string;
+    run?: CloneRunner;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    /** The person's own way to SSH for git, when they set one; read off git's settings when unsaid. */
+    sshCommand?: (env: NodeJS.ProcessEnv) => Promise<string | undefined>;
+}
+/**
+ * Clone the repository a person typed the address of into `~/projects/<its name>`. A folder that
+ * is already there and holds this very repository is taken as it is; one that holds anything
+ * else is never written over, and is refused. The clone is made beside that folder and moved
+ * there once it is whole: a clone that fails leaves nothing behind, and one on its way is no
+ * folder a second ask could take for the project.
+ */
+export declare function cloneProject(typed: string, opts?: CloneOptions): Promise<Cloned>;

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

@@ -5,11 +5,11 @@ export type { BridgeOption, BridgeQuestion } from './bridge-question.js';
  * The browser bridge (#1237): the one endpoint an extension running in the user's own Claude
  * session posts to, so a question a cloud agent is parked on becomes visible in the dashboard.
  *
- * **Why this route carries its own token, unlike every other one.** The #1051 guard in
- * `startDashboard` only exists on a non-loopback bind, and what protects a loopback daemon is
- * the same-origin check on `/_rpc`: a page on another origin is refused outright. This
- * route is the first that is *meant* to be reached from another origin, so neither of those
- * protects it, and it demands `Authorization: Bearer <daemonToken>` unconditionally instead.
+ * **Why this route carries its own token, unlike every other one.** What protects the daemon,
+ * which listens on its own computer only, is the same-origin check on `/_rpc`: a page on another
+ * origin is refused outright. This route is the first that is *meant* to be reached from another
+ * origin, so that check does not protect it, and it demands `Authorization: Bearer <bridgeToken>`
+ * unconditionally instead.
  *
  * **No CORS headers, on purpose.** An extension's service worker holding `host_permissions`
  * fetches without a preflight, so the bridge does not need `Access-Control-Allow-Origin` and

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

@@ -1,7 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 /**
  * The plumbing every one of the daemon's non-RPC HTTP surfaces shares: the browser bridge
- * (`/_bridge`), the web-start queue (`/_web-start`) and the device relay (`/_relay`).
+ * (`/_bridge`), the web-start queue (`/_web-start`) and the machine relay (`/_relay`).
  *
  * All three answer plain-text statuses, JSON payloads, and read capped JSON request bodies, and
  * each carried its own copy — two body readers that differed only in which message they rejected

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

@@ -0,0 +1,9 @@
+/** What a call says when the machine at the address shows another key than the one it was added with. */
+export declare const NOT_THE_MACHINE = "what answers at this address is not the machine that was added: add the machine again, with a new link";
+export interface MachineCall {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+}
+export declare function machineFetch(url: string, pin: string | undefined, init?: MachineCall): Promise<Response>;

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

@@ -3,8 +3,12 @@ import { type ProjectsProvider } from './projects.js';
 import { type ProjectModule } from '../project-modules.js';
 /** Where module files are served: `/_modules/<project id>/<package>/<file>`, each segment encoded. */
 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";
 /** 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;
 /**
  * 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
@@ -12,3 +16,5 @@ export declare function moduleUrl(projectId: string, module: Pick<ProjectModule,
  * Served as `no-cache`, since a module is rebuilt in place under the same name.
  */
 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>;

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

@@ -3,50 +3,90 @@ import type { OpenAgentEvent } from '../events.js';
 import type { AgentMeta } from '../store/index.js';
 import type { StartAgentOptions, StartAgentResult } from './types.js';
 /**
- * The server-side half of "run on a connected device" (#1067). The local daemon holds the saved
- * device's token, so it - not the browser - drives the remote daemon: it POSTs the agent to the
+ * The server-side half of "run on a saved machine" (#1067). The local daemon holds this computer's
+ * key on the saved machine, so it - not the browser - drives the remote daemon: it POSTs the agent to the
  * remote's `/_relay/start` and then fetch-streams the remote's `/_relay/events` back into a local
  * {@link EventStream}, which the dashboard reads over its normal same-origin `onEvents` channel. So
- * the browser never talks cross-origin and the token never leaves the two daemons (issue #1067 (b)).
+ * the browser never talks cross-origin and the key never leaves the two daemons (issue #1067 (b)).
  *
- * Authentication is the shared-token cookie (#1051), sent daemon-to-daemon: `Cookie: oa_daemon=<token>` with no
- * `Origin` header. The remote's guard admits a matching cookie without the browser-only `?token=`
- * 302, and its `/_rpc` CSRF check (absent Origin passes) is not even on these raw routes.
+ * Every call but the ping names its project, by its repository's address
+ * (repository-address.ts): a project's folder, and so its id, is another one on each machine.
+ *
+ * The other OpenAgent listens on its own computer only. What answers at a machine's address is
+ * whatever that computer opened to the network, which lets this computer in once, with the code
+ * a machine's link carries ({@link enterRemote}), answers a key of this computer's own, and from
+ * then on passes each call that carries the key (`Authorization: Bearer`, no `Origin`) to its
+ * OpenAgent as that computer's own browser would have made it.
  */
-/** Where a relayed agent executes: the remote daemon's origin and its #1051 token. Memory-only. */
-export interface RemoteTarget {
+/** How a machine is reached: where its OpenAgent answers, this computer's key there, and what the machine's own key is known by when its link said. */
+export interface MachineAccess {
     url: string;
-    token: string;
+    key: string;
+    pin?: string;
+}
+/** Where a relayed agent works: a machine, and the project there, by its repository's address. */
+export interface RemoteTarget extends MachineAccess {
+    project: string;
 }
-/** The body a relay start forwards to the remote's `/_relay/start`. */
+/** What a relay start forwards to the remote's `/_relay/start`, beside the project. */
 export interface RelayStartBody {
     prompt: string;
     options: StartAgentOptions;
 }
 /**
- * Health-check a saved device (#1072): a cookie'd `GET /_relay/ping`, true on any 2xx, false on a
- * non-2xx, an unreachable host, or the timeout. The token stays in memory for the check only, never
- * persisted, same as {@link startRemoteAgent}. This is how the browser's status dots learn reachable
- * from not: it has the tokens, the daemon does the cross-origin request.
+ * What a machine answers a relayed start with: a Start's own outcome, or `noProject` when it has
+ * no project cloned from the address the start named.
+ */
+export type RelayStartResult = StartAgentResult | {
+    ok: false;
+    error: string;
+    noProject: true;
+};
+/**
+ * Health-check a saved machine (#1072): true when it answers this computer's key. This is how
+ * the browser's status dots learn reachable from not.
+ */
+export declare function pingRemote(target: MachineAccess): Promise<boolean>;
+/** 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>;
+/** What asking to be let in came to: this computer's key there, or why not, in words. */
+export type EnterResult = {
+    ok: true;
+    key: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Ask a machine to let this computer in, with the code its link carries, under `name`. The code
+ * is good once: a link used before, or older than a few minutes, is refused.
+ */
+export declare function enterRemote(door: string, code: string, name: string, pin?: string): Promise<EnterResult>;
+/**
+ * Take this computer out of a machine: its key there stops working. Whether the machine did;
+ * one that cannot be reached keeps the key until this computer is removed there by hand.
  */
-export declare function pingRemote(target: RemoteTarget): Promise<boolean>;
+export declare function leaveRemote(machine: MachineAccess & {
+    door: string;
+}): Promise<boolean>;
 /**
- * Start an agent on the remote daemon and return its {@link StartAgentResult} (with the remote's own run
- * id). A non-2xx or a transport failure surfaces as an `ok: false` result the dashboard shows, the
- * same shape a local refusal has, so the caller does not special-case remote errors.
+ * Start an agent on the remote daemon, in its project cloned from `target.project`, and return
+ * what it answered (with the remote's own run id). A non-2xx or a transport failure surfaces as an
+ * `ok: false` result the dashboard shows, the same shape a local refusal has, so the caller does
+ * not special-case remote errors.
  */
-export declare function startRemoteAgent(target: RemoteTarget, body: RelayStartBody): Promise<StartAgentResult>;
+export declare function startRemoteAgent(target: RemoteTarget, body: RelayStartBody): Promise<RelayStartResult>;
 /**
- * Relay one run-scoped RPC to the device that owns a remote agent (#1067 slice 2). The local daemon
- * holds the device token, so a read/diff/handoff/push/PR for a relayed agent runs ON the device: POST
- * {fn, args} to the remote's /_relay/rpc over the shared-token cookie (#1051) (no Origin), returning the device's
- * result. Throws on an unreachable device or a non-2xx so the caller falls back to its own empty/error
+ * Relay one run-scoped RPC to the machine that owns a remote agent (#1067 slice 2). The local daemon
+ * holds this computer's key there, so a read/diff/handoff/push/PR for a relayed agent runs ON the machine: POST
+ * {fn, args} to the remote's /_relay/rpc with the key (no Origin), returning the machine's
+ * result. Throws on an unreachable machine or a non-2xx so the caller falls back to its own empty/error
  * shape, the same way a failed local read does.
  */
 export declare function relayRpc(target: RemoteTarget, fn: string, args: unknown[]): 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 (the token was rotated) ends the stream
+ * body, the agent ends, or `cancel()` is called. A 401 (this computer was removed there) ends the stream
  * cleanly rather than as an error, so the dashboard sees a normal `done`, not a lost connection.
  * Returns a cancel function; calling it aborts the fetch and releases the reader.
  */
@@ -54,11 +94,12 @@ export declare function streamRemoteEvents(target: RemoteTarget, agentId: string
 /**
  * The local daemon's live relayed runs (#1067), keyed by the remote agent id. Registering an agent opens
  * an {@link EventStream} the dashboard reads through `onEvents`, fed by {@link streamRemoteEvents}
- * from the remote. This map is where a saved device's token lives daemon-side: in memory, for the
- * run's lifetime.
+ * from the remote. The target is the saved machine as it was at the Start. A machine is not
+ * removed while a run is at work on it ({@link working}); the runs that ended there before it
+ * was removed read as unreachable, and one added again answers for them with its new key ({@link rekey}).
  *
  * The `targets` map outlives the event pump (#1067 slice 2): a finished remote agent's post-run reads,
- * open-PR and merge still have to reach the device after its event stream has ended, so the device
+ * open-PR and merge still have to reach the machine after its event stream has ended, so the machine
  * target is kept until {@link dispose} clears it, not dropped when the stream closes.
  *
  * The `metas` map (#1077) holds a local {@link AgentMeta} stub per relayed agent so `onAgents` can show a
@@ -73,22 +114,26 @@ export declare class RelayedAgents {
     register(agentId: string, target: RemoteTarget, meta: AgentMeta, projectId: string): void;
     /** The live event stream for a relayed agent, or undefined when this daemon is not relaying it. */
     get(agentId: string | undefined): EventStream<OpenAgentEvent> | undefined;
-    /** The device a relayed agent runs on, kept past the event stream so post-run push/PR still reach it. */
+    /** The machine a relayed agent runs on, kept past the event stream so post-run push/PR still reach it. */
     target(agentId: string | undefined): RemoteTarget | undefined;
+    /** Whether a run this daemon follows is still at work on the machine at `url`: its events still stream. */
+    working(url: string): boolean;
+    /** How the machine at `url` is reached since it was added again, for the runs kept from before: this computer's new key there, and the key the machine is known by. */
+    rekey(url: string, key: string, pin?: string): void;
     /** A project's relayed run stubs (#1077), newest-first, so `onAgents` can surface them in the list. */
     list(projectId: string): AgentMeta[];
     /** Fold each relayed event into the agent's list row via the store's own reducer (#1077), so the
-     *  local stub mirrors the device: the terminal status on `end`, the waiting flag while it is parked
+     *  local stub mirrors the machine: the terminal status on `end`, the waiting flag while it is parked
      *  (#785), the driver once its session starts. Events carry no write time, so this stamps its own. */
     private apply;
     /** Close a relayed agent's event stream (not its target). Idempotent. */
     private endStream;
-    /** Stop every pump, close every stream, and forget every device target + list stub, on daemon shutdown. */
+    /** Stop every pump, close every stream, and forget every machine target + list stub, on daemon shutdown. */
     dispose(): void;
 }
 /**
- * Fold one relayed event into the memory-only row of a run on a device: what the device's own
- * card would say, kept here because that card is on the device. The events are the ones a run's
+ * Fold one relayed event into the memory-only row of a run on a machine: what the machine's own
+ * card would say, kept here because that card is on the machine. The events are the ones a run's
  * diary yields: the agent's session id, its cost, its end.
  */
 export declare function foldRelayedEvent(meta: AgentMeta, event: OpenAgentEvent, at: string): AgentMeta;

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

@@ -7,6 +7,7 @@ import type { BridgeBrowserOwner } from '../bridge-browser.js';
 import type { ProjectErrorsReader } from '../project-errors.js';
 import type { AddProjectResult, RemoveProjectResult, StartAgentOptions, StartAgentResult } from './types.js';
 import type { AgentMeta } from '../store/index.js';
+import type { RemoteTarget } from './remote-run.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). */
@@ -14,19 +15,20 @@ export type AddProjectHandler = (path: string, share: boolean) => AddProjectResu
 /** Wired by the daemon so `sendRemoveProject` can take a project off the list, by its id, and with `files` remove what OpenAgent left in its folder. */
 export type RemoveProjectHandler = (projectId: string, files: boolean) => RemoveProjectResult | Promise<RemoveProjectResult>;
 /** Resolve an agent to its live event stream: the relay feeds `onEvents` from its own in-memory stream
- * rather than a file on disk (#426), and the daemon feeds an agent it is relaying from a device (#1067).
+ * rather than a file on disk (#426), and the daemon feeds an agent it is relaying from a machine (#1067).
  * Returns undefined when there is no in-memory stream, so `onEvents` falls back to tailing the log. */
 export type EventsSource = (projectId: string, agentId?: string) => AsyncIterable<OpenAgentEvent> | undefined;
-/** Look up the device a relayed agent (#1067) executes on, or undefined for an ordinary local agent. The
+/** Look up the machine a relayed agent (#1067) executes on, or undefined for an ordinary local agent. The
  *  daemon wires this from its live relayed-agent map; a run-scoped RPC uses it to forward a remote agent's
- *  read/steer/handoff to that device instead of resolving a (nonexistent) local checkout. */
+ *  read/steer/handoff to that machine instead of resolving a (nonexistent) local checkout. */
 export interface RemoteAgents {
-    target(agentId: string | undefined): {
-        url: string;
-        token: string;
-    } | undefined;
+    target(agentId: string | undefined): RemoteTarget | undefined;
     /** A project's relayed run stubs (#1077), so `onAgents` can show a remote agent in the list and re-open it after a reload. */
     list(projectId: string): AgentMeta[];
+    /** Whether a run relayed from here is still at work on the machine at `url`. */
+    working(url: string): boolean;
+    /** How the machine at `url` is reached since it was added again, for the runs kept from before. */
+    rekey(url: string, key: string, pin?: string): void;
 }
 /**
  * What every RPC acts through.
@@ -40,10 +42,10 @@ export interface DashboardContext {
     startAgent: StartAgentHandler;
     addProject: AddProjectHandler;
     removeProject: RemoveProjectHandler;
-    /** The in-memory event stream for an agent relayed from a connected device (#1067), else undefined. */
+    /** The in-memory event stream for an agent relayed from a saved machine (#1067), else undefined. */
     eventsSource: EventsSource;
     /** The relayed-agent lookup (#1067 slice 2), so a run-scoped RPC can tell a local agent from one
-     *  running on a connected device and forward the call there. */
+     *  running on a saved machine and forward the call there. */
     remote: RemoteAgents;
     /** The user-preferences store (#410), over the registry file. */
     preferences: PreferencesStore;
@@ -65,6 +67,15 @@ export interface DashboardContext {
  * the mount, its only caller.
  */
 export declare function isSameOriginRequest(req: IncomingMessage): boolean;
+/**
+ * The third guard: a call says its body is JSON. {@link isSameOriginRequest} lets every loopback
+ * origin pass, whatever its port, so a page another program serves on this computer (an app an
+ * agent previews, a dev server) is let through it. A browser sends such a page's POST without
+ * asking only while its content type is one a plain form can have, and JSON is none of them:
+ * with JSON it asks first, this server never says yes, and the call is not sent. So a call that
+ * is not JSON is refused, and no page of another origin can make one, not even blind.
+ */
+export declare function isJsonRequest(req: IncomingMessage): boolean;
 /**
  * DNS-rebinding guard, the other half of the CSRF check above. A page on `evil.com` whose DNS
  * re-answers as `127.0.0.1` is *same-origin* with this server as far as the browser is concerned,
@@ -72,16 +83,12 @@ export declare function isSameOriginRequest(req: IncomingMessage): boolean;
  * the mount, `sendStart` included, is reachable from a page the user merely visited.
  *
  * The `Host` header is what still gives the attacker away: it carries the name the browser was
- * asked for (`evil.com`), not the address it resolved to. So when we are bound to loopback, the
- * only `Host` a real user's browser can send is a loopback one (or the bound address itself) —
- * anything else is a rebound name and is rejected. An absent `Host` is rejected too when we are
- * enforcing: HTTP/1.1 requires it, and every browser sends it.
- *
- * A non-loopback bind (`--host`, #1051) is reached by a hostname we cannot predict, so there is
- * no allowlist to check against; that case gates behind the shared daemon token instead. Hosts
- * that never pass a bind host at all (the relay, which serves a public domain) are unaffected.
+ * asked for (`evil.com`), not the address it resolved to. The dashboard listens on this
+ * computer's own address only, so the only `Host` a real user's browser can send is a loopback
+ * one — anything else is a rebound name and is rejected. An absent `Host` is rejected too:
+ * HTTP/1.1 requires it, and every browser sends it.
  */
-export declare function isExpectedHost(req: IncomingMessage, boundHost: string | undefined): boolean;
+export declare function isExpectedHost(req: IncomingMessage): boolean;
 /** Where the dashboard's RPCs live. One prefix, so the static handler can decline it by path. */
 export declare const RPC_PREFIX = "/_rpc";
 /**
@@ -90,16 +97,12 @@ export declare const RPC_PREFIX = "/_rpc";
  * `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` when we are bound to loopback (DNS rebinding: the
- * same page must not reach us by pointing its own name at `127.0.0.1`). Pass `opts.host` — the
- * address the server is bound to — to enable that second check. Returns whether the request was
- * the RPC surface's.
+ * are requests carrying someone else's `Host` (DNS rebinding: the same page must not reach us by
+ * pointing its own name at `127.0.0.1`). Returns whether the request was the RPC surface's.
  *
  * This replaced Telefunc (F3), which required a build-time transform over every `.telefunc.ts`
  * file, a registration table pinning each RPC to the client-baked key of the *dashboard* source
  * path it was re-exported from, and a request-context indirection for wiring that never varied
  * per request. What it bought over this was type-safety across a package boundary that A7 removed.
  */
-export declare function makeRpcMount(context: DashboardContext, opts?: {
-    host?: string;
-}): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+export declare function makeRpcMount(context: DashboardContext): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;

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

@@ -22,7 +22,8 @@ export type DeleteAgentResult = {
 export type AddProjectResult = {
     ok: true;
     alreadyActivated: boolean;
-    noRemote?: true;
+    noRemote?: true; /** For a project added by its repository's address: the folder it is in. */
+    path?: string;
 } | {
     ok: false;
     error: string;
@@ -56,10 +57,12 @@ export type RemoveProjectResult = {
  * never discloses its filesystem layout.
  */
 export interface OnboardingSuggestion {
-    /** The server's working directory, or null when it cannot be offered. */
+    /** The server's working directory, or null when it cannot be offered: the home folder is where a service runs, not a project. */
     cwd: string | null;
     /** The project id for {@link cwd} when it is already registered, else null. */
     cwdProjectId: string | null;
+    /** Whether this computer can show a window to pick a folder in: one with no screen, as a server, cannot. */
+    canPickFolder: boolean;
 }
 /**
  * What a Start carries besides its prompt (#1774): the person's picks, handed to the project's
@@ -75,7 +78,7 @@ export interface StartAgentOptions {
     /**
      * The branch the agent's own branch starts from, as this machine has it, commits that are not
      * pushed included: the launcher's "My local branch" pick. Absent, origin's default branch. A
-     * word that is no branch name refuses the Start. Not sent to a device: its branches are its own.
+     * word that is no branch name refuses the Start. Not sent to another machine: its branches are its own.
      */
     base?: string;
     /**
@@ -84,20 +87,12 @@ export interface StartAgentOptions {
      */
     then?: string;
     /**
-     * Run this session on a connected device (#1067): the local daemon relays the start to the remote
-     * daemon at `url` (authenticating with `token` as the `oa_daemon` cookie) and streams its events
-     * back into the local agent view. The device `label` rides along (memory-only, like `url`/`token`) so
-     * the local session list + notice can show which device the agent is on after a reload (#1077).
-     * Memory-only relay config the dashboard sets at submit time from a saved device. NEVER persisted to
-     * Preferences or the registry: a device token is a per-browser secret. Absent = run locally.
-     * Stripped before the start is forwarded, so the remote starts an ordinary local run and does not
-     * relay onward.
+     * Run this session on a saved machine (#1067), named by its id: the local daemon relays the
+     * start to that machine's daemon, which starts it in its own copy of the project, and streams
+     * its events back into the local agent view. Absent = run on this machine. Stripped before the
+     * start is forwarded, so the machine starts an ordinary local run and does not relay onward.
      */
-    remote?: {
-        url: string;
-        token: string;
-        label?: string;
-    };
+    machine?: string;
 }
 /** The outcome of a Start attempt (#345): the id of the run the project's start hook began, or why there is none. */
 export type StartAgentResult = {