@openagt/dashboard 0.10.0 → 0.12.0

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

@@ -22,18 +22,18 @@ export declare function resolveProjectPath(projectId: string): Promise<string |
 export declare function resolveAgentPath(projectId: string, agentId?: string): Promise<string | undefined>;
 /**
  * The in-memory {@link EventsSource} (#426). It answers only for a run this daemon is relaying
- * from a connected device (#1067) — such a run has no diary on this machine, since it works in a
+ * from a saved machine (#1067) — such a run has no diary on this machine, since it works in a
  * checkout over there — and returns undefined for an ordinary local run, whose diary `onEvents`
  * tails off disk.
  */
 export declare function contextEventsSource(): EventsSource;
 /**
  * The relayed-agent lookup (#1067 slice 2). A run-scoped RPC uses it to tell an ordinary local agent
- * (resolve a local checkout) from one running on a connected device (forward the call there).
+ * (resolve a local checkout) from one running on a saved machine (forward the call there).
  *
  * The one accessor with a default rather than a throw, because "unwired" has a real meaning here:
- * a call arriving over `/_relay/rpc` is the *device* side of the relay, and the agent it names is
- * local to that device. Forwarding it onward would be a loop, so the honest answer there is that
+ * a call arriving over `/_relay/rpc` is the *machine* side of the relay, and the agent it names is
+ * local to that machine. Forwarding it onward would be a loop, so the honest answer there is that
  * nothing is relayed from here.
  */
 export declare function contextRemote(): RemoteAgents;

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

@@ -65,7 +65,7 @@ export declare function sendRemoveWorktree(projectId: string, agentId: string):
 export declare function sendDeleteAgent(projectId: string, agentId: string): Promise<DeleteAgentResult>;
 /**
  * Start a run in the project (#405, #1774): the project's own `start` hook line, reached through
- * the daemon's wired `startAgent` (which relays to a connected device when the options name
+ * the daemon's wired `startAgent` (which relays to a saved machine when the options name
  * one). Answers the id of the run the hook began, or why there is none: a project without the
  * line cannot start a run from here.
  */

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

@@ -28,7 +28,7 @@ export type LiveFeedEvent = OpenAgentEvent | StreamSync | PartialMessage;
  * The `agentId` names the run whose diary is followed; without one there is nothing to stream.
  *
  * Two sources, chosen by what is wired. An in-memory stream wins: an agent the daemon is relaying
- * from a device (#1067). Otherwise the on-disk log. The daemon's source answers only for relayed
+ * from a machine (#1067). Otherwise the on-disk log. The daemon's source answers only for relayed
  * runs, so an ordinary local agent falls through to tailing the log.
  *
  * Only the on-disk tail sends the {@link StreamSync} marker: the in-memory sources have no replay

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

@@ -1,13 +1,13 @@
 export { onAgents, onAgent, onAgentsDoing, onDocs, onQueue, onOverview, onRecentAgents, onInterventions, onOpenQuestions, 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, sendRemoveProject, onRecordsReach, sendShareRecords, sendPickProjectDirectory, onOnboarding, onCommands, onStartCheck, type ProjectLauncher } from './projects.js';
+export { onProjects, sendAddProject, onCloneTarget, sendAddProjectFromAddress, sendRemoveProject, onRecordsReach, sendShareRecords, sendPickProjectDirectory, onOnboarding, onCommands, onStartCheck, 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';
 export { onModels } from './models.js';
-export { checkDevices, type DeviceCheck } from './devices.js';
-export { onModules, runModuleCommand, readModule, type DashboardModule, type ModuleCommandResult, type ModuleReadResult } from './modules.js';
+export { onMachines, sendAddMachine, sendRemoveMachine, onMachinesReachable, onMachineVersions, type Machine, type AddMachineResult, type MachineVersions } from './machines.js';
+export { onModules, runModuleCommand, runComputerCommand, readModule, type DashboardModule, type ModuleCommandResult, type ModuleReadResult } from './modules.js';
 export { onProjectSkills, sendChangeSkills, sendCommitSkills, type ProjectSkills, type ProjectSkill, type ChangeSkillsResult } from './skills.js';
 import { streamAgentEvents } from './events.js';
 /** One RPC: called with whatever the browser sent, answering with whatever JSON.stringify keeps. */

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

@@ -0,0 +1,51 @@
+/** A saved machine as the browser sees it: no key. */
+export interface Machine {
+    id: string;
+    label: string;
+    url: string;
+}
+export type AddMachineResult = {
+    ok: true;
+    machine: Machine;
+} | {
+    ok: false;
+    error: string;
+};
+/** The saved machines, newest first. */
+export declare function onMachines(): Promise<Machine[]>;
+/**
+ * Save the machine a pasted link names: the link another OpenAgent gives for a new device. This
+ * computer is let in there with the link's code, once, and keeps the key it is answered. Adding
+ * a machine again, with a new link, replaces its name and the key, and the key it had there
+ * before is taken out.
+ */
+export declare function sendAddMachine(pasted: string, label?: string): Promise<AddMachineResult>;
+export type RemoveMachineResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Take a saved machine off the list, and this computer out of the machine: its key there stops
+ * working. Not while a run is at work there, which is read with that key. Taking the key out is
+ * not waited for: a machine that cannot be reached right now keeps it until this computer is
+ * removed there, among its devices.
+ */
+export declare function sendRemoveMachine(id: string): Promise<RemoveMachineResult>;
+/** Whether each saved machine answers right now, by id: one short call to each, with this computer's key. */
+export declare function onMachinesReachable(): Promise<Record<string, boolean>>;
+/** This computer's OpenAgent, and the one each saved machine runs. */
+export interface MachineVersions {
+    /** This computer's own. */
+    version: string;
+    /** Each saved machine, with its version when it answers and says. */
+    machines: (Machine & {
+        version?: string;
+    })[];
+}
+/**
+ * The saved machines with the OpenAgent each runs, beside this computer's own: how a page tells
+ * that a machine fell behind this computer. One short call to each, with this computer's key.
+ */
+export declare function onMachineVersions(): Promise<MachineVersions>;

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

@@ -6,13 +6,14 @@ export type { ModuleReadResult } from '../dashboard/module-host.js';
 export interface DashboardModule {
     /** The package that brings it. */
     package: string;
-    /** The URL of its browser module, served from the first project that has it. */
+    /** The URL of its browser module, served from the first project that has it, or from OpenAgent's own copy for one of the computer's. */
     url: string;
-    /** The registered projects whose packages include it, in the registry's order. */
+    /** The registered projects whose packages include it, in the registry's order; none for one of the computer's, whose commands run in no project. */
     projects: string[];
 }
 /**
- * Every module any registered project brings (#1774), one per package, with the projects
+ * Every module the dashboard loads (#1774), one per package. First the computer's, which are
+ * there with no project added. Then every module any registered project brings, with the projects
  * that have it: with no project picked the sidebar and the pages are every project's, and the
  * dashboard narrows them itself to a picked project's. A package several projects install is loaded once, from
  * the first of them in the registry's order; its page then reads each project through that
@@ -34,11 +35,18 @@ export declare function onModules(): Promise<DashboardModule[]>;
  * write only at the next sync.
  */
 export declare function runModuleCommand(projectId: string, pkg: string, args: string[], command?: string, acts?: boolean): Promise<ModuleCommandResult>;
+/**
+ * Run one of the commands of a package that is this computer's, in no project, and answer its
+ * JSON output: how the door's page and the servers' page read and change what they keep, which is
+ * in the person's home folder, where the command runs. Refused for any other package: a project's
+ * module runs its commands in its project ({@link runModuleCommand}).
+ */
+export declare function runComputerCommand(pkg: string, args: string[], command?: string): Promise<ModuleCommandResult>;
 /**
  * Call read `name` of a module's server part in one project: how a module's browser part reads
  * what a command cannot answer fast enough. Refused for an unknown project, a package that is not
  * a module of that project, and a module with no server part. A read whose input names a run this
- * daemon relays to a connected device (`input.agentId`) is read over there, by that device's own
+ * daemon relays to a saved machine (`input.agentId`) is read over there, by that machine's own
  * copy of the module, since the run's checkout is there.
  */
 export declare function readModule(projectId: string, pkg: string, name: string, input: unknown): Promise<ModuleReadResult>;

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

@@ -15,6 +15,22 @@ export declare function onProjects(): Promise<ProjectSummary[]>;
  * repository's remote. Nothing is pushed for a project added with `false`.
  */
 export declare function sendAddProject(path: string, share: boolean): Promise<AddProjectResult>;
+/** Where the repository a person typed the address of would be cloned to on this computer, or why what was typed is no address: asked before anything is cloned. */
+export declare function onCloneTarget(address: string): Promise<{
+    ok: true;
+    address: string;
+    path: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+/**
+ * Add a project by its repository's address, for a computer that does not have its folder: the
+ * repository is cloned into `~/projects/<its name>` with the logins this computer has, and the
+ * folder is then added as {@link sendAddProject} adds one. A folder already there with this
+ * repository in it is added as it is. The answer says where the project is.
+ */
+export declare function sendAddProjectFromAddress(address: string, share: boolean): Promise<AddProjectResult>;
 /**
  * Remove a project from the dashboard: it leaves the Projects list. Nothing in its folder is
  * deleted unless `files` is true: then what OpenAgent left there is removed too, and the answer
@@ -58,6 +74,8 @@ export interface ProjectLauncher {
     gitHost: boolean;
     /** Whether the project's repository has an `origin` remote; without one nothing can be published, so the publish menu stops at the commit. */
     remote: boolean;
+    /** The address the project's repository was cloned from, the name another machine knows the project by; absent, the project cannot be sent to one. */
+    address?: string;
     /**
      * The two branches an agent can start from here, for the launcher's "start from" chip: `main`,
      * the name of origin's default branch, and `local`, the branch the project's folder is on now.

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

@@ -31,7 +31,7 @@ import type { BridgeAnswer, BridgeContact, BridgeVersion } from '../dashboard/br
  * may have just self-healed a dead agent to `stopped` (#716), and that freshly-archived row can
  * lag `listAgents` by a poll — keeping it regardless leaves the row visible with no flicker.
  *
- * An agent relayed to a connected device (#1067) lives only in the daemon's memory, never on disk, so
+ * An agent relayed to a saved machine (#1067) lives only in the daemon's memory, never on disk, so
  * its in-memory stub is merged in too (#1077): that is what re-opens it after a dashboard reload
  * instead of losing it.
  */
@@ -168,9 +168,8 @@ export declare function onBridgeStatus(): Promise<{
  *
  * Only while the bridge is on, so a daemon with the feature off never hands the secret to a
  * page. Revealing it here is not a new exposure: anyone who can load this dashboard can already
- * start runs on this machine, and on a non-loopback bind their browser is holding the same token
- * as a cookie. What it replaces is the alternative, which was telling people to open
- * `~/.openagent.json` and copy a field out of it.
+ * start runs on this machine. What it replaces is the alternative, which was telling people to
+ * open `~/.openagent.json` and copy a field out of it.
  */
 export declare function onBridgeToken(): Promise<string | null>;
 /**

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

@@ -1,8 +1,8 @@
 /**
- * Run a run-scoped RPC locally, or relay it to the device when `agentId` names an agent this daemon is
- * relaying to a connected one (#1067 slice 2). For an ordinary local agent the remote lookup is empty and
+ * Run a run-scoped RPC locally, or relay it to the machine when `agentId` names an agent this daemon is
+ * relaying to a saved one (#1067 slice 2). For an ordinary local agent the remote lookup is empty and
  * `local()` runs unchanged. For a remote agent there is no local checkout, so the call is forwarded to the
- * device over the token; if the device is unreachable, `unreachable` is returned - the same empty/error
+ * machine with this computer's key there; if the machine is unreachable, or no longer lets this computer in, `unreachable` is returned - the same empty/error
  * shape `local()` gives on a failed read - so the caller never special-cases a remote agent.
  */
 export declare function relayOr<T>(agentId: string | undefined, fn: string, args: unknown[], local: () => Promise<T>, unreachable: T): Promise<T>;

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

@@ -102,11 +102,12 @@ export type OpenAgentEvent = {
     event: DriverEvent;
 }
 /**
- * A live screen something the agent ran is showing: a page on this machine's loopback, shown in
- * the chat where the line is, while it is the newest open screen at that address and the run
+ * A live screen something the agent ran is showing: where it answers, on the loopback of the
+ * computer the run is on, live while it is the newest open screen at that address and the run
  * has not ended. `label` names what it showed then. The same address with `ended` says the
  * screen has gone. A diary line a command appends itself (agent-driver's `DIARY_ENV`);
- * OpenAgent knows nothing of what the page is.
+ * OpenAgent passes a watcher's calls on to the address (dashboard/screen.ts) and knows nothing
+ * of what the screen is.
  */
  | {
     kind: 'screen';

package/dist/module-types/src/loopback-host.d.ts

@@ -1,11 +1,9 @@
 /**
- * Loopback-address helpers, shared by the daemon (deciding whether a bind gates behind the
- * token, #1051) and the RPC mount (rejecting a rebound `Host`). A leaf module on purpose:
- * `daemon.ts` imports the dashboard, so the mount cannot import these back out of it.
+ * Loopback-address helpers, for the RPC mount (rejecting a cross-origin page and a rebound `Host`).
  */
 /**
- * True when `host` is a loopback address the browser reaches without leaving the machine (#1051).
- * A bind-all (`0.0.0.0`, `::`) or a routable address is not, and gates behind the shared token.
+ * True when `host` is a loopback address the browser reaches without leaving the machine.
+ * A bind-all (`0.0.0.0`, `::`) or a routable address is not.
  *
  * The IPv4 check matches the whole `127.0.0.0/8` range but only as an address: a bare
  * `startsWith('127.')` also accepts a *registrable name* like `127.evil.com`, which is exactly the

package/dist/module-types/src/machine-link.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Read the link another computer's OpenAgent gives for a new device (its Settings, Devices, Add
+ * device): where this computer is let in, and the code that lets it in once. The code rides the
+ * link after the `#`. A server's link carries one thing more after the code and a dot: what the
+ * server's key is known by. Not a web address is `null`, and so is a link with no code.
+ *
+ * A leaf with no Node in it: the dashboard reads a paste with it as the person types, and the
+ * daemon reads it again before it asks to be let in.
+ */
+export interface MachineLink {
+    /** Where the other OpenAgent answers, as an origin (`http://studio.local:4201`). */
+    url: string;
+    /** Where this computer asks to be let in, and later takes itself out: the link without its code. */
+    door: string;
+    /** The code, good once. */
+    code: string;
+    /** What the machine's key is known by, when the link says: a call then goes only to a machine that shows that key. */
+    pin?: string;
+}
+export declare function parseMachineLink(pasted: string): MachineLink | null;

package/dist/module-types/src/pick-directory.d.ts

@@ -19,6 +19,8 @@ export type DialogRun = {
 };
 /** Injectable seam so tests never open a real dialog. */
 export type DialogRunner = (command: string, args: string[]) => Promise<DialogRun>;
+/** Whether this computer has a screen a folder dialog can open on: asked before one is offered. */
+export declare function canPickDirectory(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): boolean;
 /**
  * Open the OS folder picker and wait for the user's choice.
  *

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

@@ -4,7 +4,8 @@ import { type PackageCommandResult } from '@openagt/agent-data';
  * `exports["./dashboard"]`, and optionally its server part, named by `exports["./server"]`.
  * Any dependency of the project that exports `./dashboard` is a module, whoever wrote it, and the
  * packages OpenAgent brings itself come the same way, for the projects that have them
- * (`built-in.ts`).
+ * (`built-in.ts`). A package that is this computer's is a module of no project: see
+ * {@link readComputerModules}.
  */
 export interface ProjectModule {
     /** The package's name. */
@@ -15,7 +16,7 @@ export interface ProjectModule {
     dir: string;
     /** The module's browser part's file name inside {@link dir}. */
     entry: string;
-    /** The package's commands, by name, as absolute paths: what the module may run in this project. */
+    /** The package's commands, by name, as absolute paths: what the module may run, in this project or, for one of the computer's, in none. */
     bins: Record<string, string>;
     /** The module's server part, an absolute path inside the package, when it has one. */
     server?: string;
@@ -29,6 +30,13 @@ export interface ProjectModule {
 export declare function readProjectModules(root: string): Promise<ProjectModule[]>;
 /** The one module of this project that `name` names, or undefined. */
 export declare function findProjectModule(root: string, name: string): Promise<ProjectModule | undefined>;
+/**
+ * The modules that are this computer's and no project's: the ones among the packages OpenAgent
+ * brings for the computer (`built-in.ts`). They are there with no project added. Sorted by name.
+ */
+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 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
@@ -43,7 +51,8 @@ export type ModuleCommandResult = PackageCommandResult;
  * (`npx @openagt/skill-logs@0.1`), so the module and the agent see the same thing and OpenAgent knows neither.
  *
  * `command` picks one of the package's commands; a package with exactly one needs none. The
- * command runs with Node (a package's commands are Node scripts), in the project root, never
+ * command runs with Node (a package's commands are Node scripts), in `root` (the project's, or
+ * the person's home folder for a module of the computer's), never
  * through a shell, bounded in time and output. Refused: a command the package does not have, too
  * many or too long arguments. A command that exits non-zero answers its last stderr line; one that
  * prints no JSON says so.

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

@@ -3,8 +3,9 @@ import { type PublishPick } from './publish-levels.js';
  * The multi-project registry (#390): the list of projects the user has
  * installed OpenAgent into, kept as a single JSON file `.bashrc`-style —
  * `$HOME/.openagent.json` — so it is the user's responsibility to re-create
- * per machine. The same file also holds the user's dashboard preferences (#410),
- * so the daemon owns one user file and the UI never needs localStorage.
+ * per machine. The same file also holds the user's dashboard preferences (#410)
+ * and the machines they saved, so the daemon owns one user file and the UI never
+ * needs localStorage.
  */
 /** One registered project. */
 export interface ProjectRecord {
@@ -15,6 +16,25 @@ export interface ProjectRecord {
     /** ISO timestamp the project was added. */
     addedAt: string;
 }
+/**
+ * A saved machine: another computer running OpenAgent that a run can be sent to. Kept in this
+ * file, the person's own, so every browser on this computer shows the same machines and the
+ * key that reaches one never leaves the two machines.
+ */
+export interface MachineRecord {
+    /** The machine's address, which is also what names it: saving the same address again replaces it. */
+    id: string;
+    /** The name the person gave it, or its host when they gave none. */
+    label: string;
+    /** Where its OpenAgent answers, as an origin (`http://studio.local:4201`). */
+    url: string;
+    /** This computer's own key on that machine. Never handed to a browser. */
+    key: string;
+    /** Where this computer was let in there, and where it takes itself out when the machine is removed. */
+    door: string;
+    /** What the machine's key is known by, when its link said: every call goes only to a machine that shows that key. */
+    pin?: string;
+}
 /**
  * The dashboard's Global options (#410), persisted next to the project list so they
  * survive restarts without localStorage — the daemon reads/writes them, the SPA reads
@@ -104,11 +124,16 @@ export interface Registry {
     projects: ProjectRecord[];
     preferences: Preferences;
     /**
-     * The shared daemon token (#1051): generated on the first non-loopback bind and reused after.
-     * A top-level field, deliberately not a {@link Preferences} one, so it is never shipped to the
-     * browser bundle. Absent on a loopback-only machine.
+     * The browser bridge's key (#1237): generated when the bridge is first switched on and reused
+     * after. A top-level field, deliberately not a {@link Preferences} one, so it is never shipped
+     * to the browser bundle. Absent on a machine that never had the bridge on.
      */
-    daemonToken?: string;
+    bridgeToken?: string;
+    /**
+     * The saved machines. Top-level like {@link bridgeToken}, and for the same reason: each one
+     * carries a key, so the list is never part of what the browser is handed.
+     */
+    machines?: MachineRecord[];
 }
 /** A read/write handle for the user preferences, wired into the dashboard's context by the daemon. */
 export interface PreferencesStore {
@@ -122,7 +147,7 @@ export interface PreferencesStore {
 }
 /** The registry file name: a single file under `$XDG_CONFIG_HOME` (dotted under `$HOME`). */
 export declare const REGISTRY_FILE = "openagent.json";
-/** Owner read/write only: the file holds the daemon token (#1051). */
+/** Owner read/write only: the file holds the bridge's key and the saved machines' keys. */
 export declare const REGISTRY_FILE_MODE = 384;
 /**
  * Deterministic, URL-safe id for a project path: the sanitized basename plus a
@@ -151,7 +176,7 @@ export interface RegistryFs {
     rename?(from: string, to: string): Promise<void>;
     /**
      * Narrow a file's permissions. Optional, and best-effort at the call site: this file holds the
-     * daemon token (#1051), so it is written owner-only — but a
+     * bridge's key and the saved machines' keys, so it is written owner-only — but a
      * filesystem that cannot express that (Windows, a FAT volume) must not fail the write.
      */
     chmod?(path: string, mode: number): Promise<void>;
@@ -205,15 +230,33 @@ export declare function writePreferences(preferences: Preferences, fs?: Registry
  */
 export declare function patchPreferences(patch: Preferences, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<Preferences>;
 /**
- * The shared daemon token (#1051): read the persisted one, or generate + persist it now. Called
- * only on a non-loopback bind, so a loopback-only machine never grows one. Serialized with the
- * other mutators so two concurrent binds can't each write a different token. `base64url` of 32
- * random bytes: URL-safe, so it drops straight into a `?token=` without encoding.
+ * The browser bridge's key (#1237): read the persisted one, or generate + persist it now. Called
+ * only with the bridge switched on, so a machine that never had it on never grows one. Serialized
+ * with the other mutators so two concurrent starts can't each write a different key.
+ */
+export declare function ensureBridgeToken(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<string>;
+/** The persisted bridge key, or `undefined` when none exists. A pure read: it never generates one. */
+export declare function readBridgeToken(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
+/** The saved machines, newest first. Forgiving like every read of this file: none on a bad file. */
+export declare function listMachines(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<MachineRecord[]>;
+/**
+ * Save a machine, newest first. One per address: saving an address again replaces its name and
+ * its key, which is how a machine whose key changed is fixed. Answers the stored record, and the
+ * records it took the place of (the one saved at that address before, the oldest past the cap):
+ * each still holds a key the caller takes out of its machine.
  */
-export declare function ensureDaemonToken(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<string>;
-/** The persisted daemon token (#1051), or `undefined` when none exists. A pure read, so a process
- * that only prints the reachable URL never generates one. */
-export declare function readDaemonToken(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
+export declare function addMachine(machine: {
+    url: string;
+    key: string;
+    door: string;
+    pin?: string;
+    label?: string;
+}, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<{
+    record: MachineRecord;
+    displaced: MachineRecord[];
+}>;
+/** Take a saved machine off the list, by id. Answers the one that was there. */
+export declare function removeMachine(id: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<MachineRecord | undefined>;
 /** A {@link PreferencesStore} bound to the real registry file, wired by the daemon so the
  * dashboard's preferences RPCs read/write the user's home file.
  *

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

@@ -0,0 +1,22 @@
+import { type GitRunner } from '@openagt/agent-data';
+/**
+ * The one name a project has on every machine: where its repository was cloned from, as
+ * `host/path` (`github.com/me/shop`). A project's id is made from its folder's path, which is
+ * another path on another machine, so a run sent to a machine names its project by this.
+ *
+ * The same repository reads the same whichever way it was cloned: the scheme, a user before the
+ * host, a port, a trailing `.git` or slash are dropped, and letters are lowered, since the git
+ * hosts match names without regard to case. Not an address at all (a path on this disk, a
+ * `file:` address) is none.
+ *
+ * What it does not see through: a host that serves the two ways under two names or two paths
+ * (`ssh.github.com`, Azure DevOps). Such a project reads as two, and the other machine says it
+ * does not have it.
+ */
+export declare function addressOfRemote(remote: string): string | undefined;
+/**
+ * The address of the repository at `cwd`: its `origin` remote, the one every push goes to. A
+ * project with no `origin`, or one that is a folder on this disk, has none and runs on this
+ * machine only.
+ */
+export declare function repositoryAddress(cwd: string, git?: GitRunner): Promise<string | undefined>;

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

@@ -0,0 +1,13 @@
+import type { OpenAgentEvent } from './events.js';
+/**
+ * Which of a run's `screen` lines are live and which are hidden. Live: the newest line at its
+ * address with no `ended` line for it after, and no run `end` after it other than one waiting on
+ * an answer. Every `ended` line is hidden: the screen going is said by its line no longer being
+ * live.
+ */
+export declare function foldScreenRows(events: readonly OpenAgentEvent[]): {
+    live: Set<OpenAgentEvent>;
+    hidden: Set<OpenAgentEvent>;
+};
+/** Where a run's live screen answers: the address of its newest live `screen` line, or nothing. */
+export declare function liveScreen(events: readonly OpenAgentEvent[]): string | undefined;

package/dist/module-types/src/store/agent-store.d.ts

@@ -157,12 +157,12 @@ export interface AgentMeta {
     browserStreamPort?: number;
     /**
      * Where this run executes (#1050/#1053/#610): `actions` for a GitHub Actions run, `web` for a
-     * Claude Code cloud session, `remote` when relayed to a connected device (#1067), absent for a
+     * Claude Code cloud session, `remote` when relayed to a saved machine (#1067), absent for a
      * local run. Persisted so the agent view can tell a burst-mode Actions run from a stalled live
      * feed, show a cloud agent's session link after a reload, and gate the browser pane off (#1053).
      */
     target?: 'local' | 'actions' | 'remote' | 'web';
-    /** The connected device a remote agent (#1067) executes on, for the session list + notice after a reload. */
+    /** The saved machine a remote agent (#1067) executes on, for the session list + notice after a reload. */
     remoteLabel?: string;
     /**
      * The flow this agent started under (#1467): `build` for the scope→build orchestration, `prompt`

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

@@ -0,0 +1 @@
+export declare function openagentVersion(): string;

package/dist/package-services.d.ts

@@ -0,0 +1,27 @@
+import { type ChildProcess } from 'node:child_process';
+import type { ProvidedCommand } from '@openagt/agent-data';
+/**
+ * The services of OpenAgent's own packages: each declared command's `serve`, run as a process of
+ * its own for as long as OpenAgent runs, and told where OpenAgent is (`OPENAGENT_URL`). OpenAgent
+ * knows nothing of what a service does. One that ends by itself is started again after a
+ * while; all of them end with OpenAgent. Each is started in a process group of its own, so a
+ * Ctrl-C in OpenAgent's terminal reaches OpenAgent alone, which then ends them in its own order.
+ */
+export interface PackageServicesOptions {
+    /** The commands to run, each a package's declared service. */
+    commands: readonly ProvidedCommand[];
+    /** OpenAgent's own address on this computer. */
+    url: string;
+    env: NodeJS.ProcessEnv;
+    log: (line: string) => void;
+    /** How a service's process is started; the real one when unsaid. */
+    spawn?: (bin: string, env: NodeJS.ProcessEnv) => ChildProcess;
+    /** After how long a service that ended by itself is started again. */
+    restartMs?: number;
+}
+export interface PackageServices {
+    /** End every service, and wait until each is gone. */
+    stop(): Promise<void>;
+}
+export declare function startPackageServices(opts: PackageServicesOptions): PackageServices;
+//# sourceMappingURL=package-services.d.ts.map

package/dist/package-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-services.d.ts","sourceRoot":"","sources":["../src/package-services.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D;;;;;;GAMG;AAEH,MAAM,WAAW,sBAAsB;IACrC,8DAA8D;IAC9D,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAA;IACpC,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAC,UAAU,CAAA;IACtB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3B,oEAAoE;IACpE,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,UAAU,KAAK,YAAY,CAAA;IAC7D,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,sDAAsD;IACtD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACtB;AAKD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,sBAAsB,GAAG,eAAe,CAwDlF"}

package/dist/package-services.js

@@ -0,0 +1,62 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+/** How long a service gets to end by itself once asked, before it is killed. */
+const STOP_GRACE_MS = 3_000;
+export function startPackageServices(opts) {
+    const spawn = opts.spawn ?? ((bin, env) => nodeSpawn(process.execPath, [bin, 'serve'], { env, stdio: ['ignore', 'ignore', 'pipe'], detached: true }));
+    const env = { ...opts.env, OPENAGENT_URL: opts.url };
+    let stopping = false;
+    const running = new Map();
+    const timers = new Set();
+    const start = (command) => {
+        if (stopping)
+            return;
+        const child = spawn(command.bin, env);
+        running.set(command.package, child);
+        child.stderr?.setEncoding('utf8').on('data', (said) => {
+            for (const line of said.split('\n'))
+                if (line.trim())
+                    opts.log(line.trim());
+        });
+        const ended = (why) => {
+            if (running.get(command.package) !== child)
+                return;
+            running.delete(command.package);
+            if (stopping)
+                return;
+            opts.log(`${command.package}: its service ended (${why}); it is started again shortly`);
+            const timer = setTimeout(() => {
+                timers.delete(timer);
+                start(command);
+            }, opts.restartMs ?? 5_000);
+            timers.add(timer);
+        };
+        child.once('error', err => ended(err.message));
+        child.once('exit', (code, signal) => ended(signal ?? `exit ${code}`));
+    };
+    for (const command of opts.commands)
+        start(command);
+    return {
+        async stop() {
+            stopping = true;
+            for (const timer of timers)
+                clearTimeout(timer);
+            timers.clear();
+            await Promise.all([...running.values()].map(child => new Promise(resolve => {
+                if (child.exitCode !== null || child.signalCode !== null)
+                    return resolve();
+                const kill = setTimeout(() => child.kill('SIGKILL'), STOP_GRACE_MS);
+                child.once('exit', () => {
+                    clearTimeout(kill);
+                    resolve();
+                });
+                child.once('error', () => {
+                    clearTimeout(kill);
+                    resolve();
+                });
+                child.kill('SIGTERM');
+            })));
+            running.clear();
+        },
+    };
+}
+//# sourceMappingURL=package-services.js.map

package/dist/package-services.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-services.js","sourceRoot":"","sources":["../src/package-services.ts"],"names":[],"mappings":"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"}

package/dist/pick-directory.d.ts

@@ -19,6 +19,8 @@ export type DialogRun = {
 };
 /** Injectable seam so tests never open a real dialog. */
 export type DialogRunner = (command: string, args: string[]) => Promise<DialogRun>;
+/** Whether this computer has a screen a folder dialog can open on: asked before one is offered. */
+export declare function canPickDirectory(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): boolean;
 /**
  * Open the OS folder picker and wait for the user's choice.
  *