@openagt/dashboard 0.37.0 → 0.38.0

package/dist/module-types/dashboard/lib/use-modules.d.ts

@@ -10,10 +10,12 @@ export interface MountedLinkAction extends LinkAction {
     package: string;
     projects: string[];
 }
-/** A card as the shell mounts it (#1818): the card, plus the package it came from and the projects that have it. */
+/** A card as the shell mounts it (#1818): the card, plus the package it came from, the projects that have it, and whether it is the computer's. */
 export interface MountedCard extends ModuleCard {
     package: string;
     projects: string[];
+    /** A package of this computer's (its devices): the card is on every Overview, whichever project is picked. */
+    computer: boolean;
 }
 /** A pane as the shell mounts it: the pane, plus the package it came from and the projects that have it. */
 export interface MountedPanel extends ModulePanel {

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

@@ -1,7 +1,9 @@
+import type { Health } from '../../src/health.js';
+import type { CardWidth } from '../../src/overview-layout.js';
 import { type ComponentType } from 'react';
 import type { AgentStatus } from '../../src/index.js';
 import type { ModuleCommandResult, ModuleReadResult } from '../rpc/modules.js';
-export type { ModuleCommandResult, ModuleReadResult, AgentStatus };
+export type { ModuleCommandResult, ModuleReadResult, AgentStatus, CardWidth, Health };
 /** A registered project that has the module's package, as a page gets it. */
 export interface ModuleProject {
     id: string;
@@ -113,6 +115,12 @@ export interface ModuleCardProps {
 export interface ModuleCard {
     /** Which card this is, for the shell's key and its error line; never shown as a title. */
     id: string;
+    /** Its name where the person arranges the Overview's cards: what its title says ("Hot tickets"). */
+    label: string;
+    /** How wide it stands until the person picks: half the Overview when unsaid. */
+    width?: CardWidth;
+    /** The narrowest it fits: a third of the Overview when unsaid. */
+    minWidth?: CardWidth;
     /** Its place among every installed package's cards, lower first; 50 when unsaid, ties by package name. */
     order?: number;
     /** The card itself. */
@@ -302,9 +310,25 @@ export interface ModuleAgent {
     name?: string;
     /** What the run was asked, as typed or as queued; absent when its record carries none. */
     ask?: string;
+    /** How it stands: `unknown` while the computer it runs on does not answer, whatever its record last said. */
     status: AgentStatus;
     /** ISO 8601. */
     startedAt: string;
+    /** ISO 8601, once it ended. */
+    endedAt?: string;
+    /** Its short name, as a list of runs shows it. */
+    title?: string;
+    /** Whose run it is, by the email its record is kept under. */
+    person?: string;
+    /** What it cost so far, in US dollars. */
+    cost?: number;
+    /** The coding agent that runs it (`claude-code`, `codex`, …) and its model. */
+    driver?: string;
+    model?: string;
+    /** The saved machine it runs on, by the name it was given; absent for a run of this computer's. */
+    machine?: string;
+    /** While its status is `unknown`: when its computer was last seen, ISO, if it was. */
+    seenAt?: string;
 }
 /** What starting a run answered: the run's id, or in words why there is none. */
 export type StartRunResult = {
@@ -362,6 +386,13 @@ export interface ModuleHost {
     openPage(segment: string, path?: string[], projectId?: string): void;
     /** The address of a page a module adds, with the project picked in the dashboard: a link's `href`, for a link that also opens in a new tab. */
     pageHref(segment: string): string;
+    /** Open an entry of Settings over the page, by its id: `openSettings('devices')`. */
+    openSettings(entry: string): void;
+    /**
+     * The accounts behind a project's commit emails at its git host, each with its login and picture:
+     * an email the host knows nobody for, or a project with no git host, is left out. Kept a day.
+     */
+    gitHostPeople(projectId: string, emails: string[]): Promise<ModuleHostPerson[]>;
     /**
      * Start a run in one project with this prompt, with the person's own picks (which tool, which
      * model, where it runs), and land on it, unless `land` is false: then the dashboard stays where
@@ -415,6 +446,11 @@ export interface ModuleHost {
      * it said is another computer's data, to read as such; `unknown` for a machine that does not say.
      */
     machinePerson(machineId: string): Promise<ModuleMachinePerson>;
+    /**
+     * A saved server of the person's uses this computer's logins from now on: each account this
+     * computer is logged in to gets a login of the server's own there, as Settings › Accounts says.
+     */
+    useLoginsOn(machineId: string): Promise<MachineAdded>;
     /** Take one of that person's devices out at the machine, by its id there; answers as {@link machinePerson} does, after. */
     removeMachineDevice(machineId: string, deviceId: string): Promise<ModuleMachinePerson>;
     /**
@@ -426,6 +462,13 @@ export interface ModuleHost {
     /** Send the live screen of a run what the person did on it, as JSON; whether the screen took it. */
     sendToScreen(projectId: string, agentId: string, input: unknown): Promise<boolean>;
 }
+/** A person of a project, as its git host knows them. */
+export interface ModuleHostPerson {
+    email: string;
+    login: string;
+    /** A picture of them: an https address. */
+    avatar?: string;
+}
 /** A saved machine, as a module sees it: never this computer's key there. */
 export interface ModuleMachine {
     /** Where the machine answers, as an origin (`https://203.0.113.5`): what it is known by. */
@@ -434,6 +477,8 @@ export interface ModuleMachine {
     url: string;
     /** The OpenAgent it runs; absent for a machine that does not answer right now. */
     version?: string;
+    /** How it stands, as it says: its memory, disk and load; absent for one that does not answer, or does not say. */
+    health?: Health;
     /** The id the machine lists this computer under, among the devices that are in there. */
     device?: string;
     /** Whose computer it is, by their GitHub account, when it is another person's shared with everyone on a server. */
@@ -450,6 +495,8 @@ export interface ModuleMachines {
     version: string;
     /** This computer's own name, as another machine lists it: "Suleimans-MacBook-Pro". */
     name?: string;
+    /** How this computer stands: its memory, disk and load. */
+    health?: Health;
     machines: ModuleMachine[];
 }
 /** How saving a machine went: done, or stopped, with the reason. */
@@ -547,6 +594,9 @@ export { Tooltip, TooltipTrigger, TooltipContent } from '../components/ui/toolti
 export { DropdownMenu, DropdownMenuContent, DropdownMenuCheckboxItem, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger } from '../components/ui/dropdown-menu.js';
 export { ContextMenu, ContextMenuTrigger } from '../components/ui/context-menu.js';
 export { PaneTitle, PaneActions } from '../components/PaneHeader.js';
+export { Page } from '../components/Page.js';
+export { StatTile } from '../components/StatTile.js';
+export { FilterChips, type FilterChip } from '../components/FilterChips.js';
 export { FileIcon } from '../components/FileIcon.js';
 export { Markdown } from '../components/Markdown.js';
 export { StartAgentButton } from '../components/StartAgentButton.js';

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

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

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

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

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

@@ -0,0 +1,10 @@
+import type { IncomingMessage, OutgoingHttpHeaders, ServerResponse } from 'node:http';
+/** Whether the caller takes a gzipped answer: every browser says so. */
+export declare function takesGzip(req: IncomingMessage): boolean;
+/** The types worth packing: text. A picture or a font is packed already. */
+export declare function isText(contentType: string): boolean;
+/**
+ * Send `body`, gzipped when the caller takes it, it is text and not small. `key` names a body that
+ * is the same each time it is sent (a file of the page), so it is packed once.
+ */
+export declare function sendBody(req: IncomingMessage, res: ServerResponse, status: number, headers: OutgoingHttpHeaders, body: Buffer | string, key?: string): Promise<void>;

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

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

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

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

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

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

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

@@ -0,0 +1,77 @@
+import { type AgentMeta } from '../store/index.js';
+/**
+ * The runs of another computer, as this one lists them: a laptop's on its server, a server's on
+ * the laptop. Each computer answers for its own runs only, as they stand right now, over the relay
+ * of the saved machine it is ({@link RunChanges}); this computer takes what it says over the
+ * records of those runs it holds, which come through a project's shared records and stop at
+ * whatever was shared last ({@link withMachineRuns}). So how a computer's runs stand never
+ * depends on its records being shared: a computer that does not answer has its runs known by what
+ * it said last, or by their records, and none of them going: their status is `unknown`.
+ */
+/** What a computer answers for its own runs of a project. */
+export interface OwnRuns {
+    /** What to ask with next time, as `since`: the answer then holds only the runs that changed after this one. */
+    at: string;
+    /** Its runs that changed since the `since` it was asked with; every one when there was none, or one it does not know. */
+    runs: AgentMeta[];
+    /** Every one of its runs of the project, by id: a run the asker holds that is not here is gone. */
+    ids: string[];
+}
+/**
+ * A computer's own runs, counted as they change, per project: each answer says where it leaves
+ * the asker, and the next holds what changed after that. A count from before this OpenAgent
+ * started, or from no answer of its, is answered with every run.
+ */
+export declare class RunChanges {
+    private readonly started;
+    private readonly projects;
+    answer(project: string, runs: readonly AgentMeta[], since?: unknown): OwnRuns;
+    private countOf;
+}
+/** A saved machine's runs of one project, as this computer last heard them. */
+export interface MachineRuns {
+    /** The computer's own name, as the records of its runs carry it. */
+    host: string;
+    /** Its runs as it said them last, since this OpenAgent started. */
+    runs: readonly AgentMeta[];
+    /** It answered the last time it was asked. */
+    answered: boolean;
+    /** When it last answered, ISO, when this computer knows. */
+    seenAt?: string;
+}
+/**
+ * A project's runs with what its saved machines said of theirs: a machine's word on a run of its
+ * own wins over the run's record, and a run of its own with no record here yet is listed too. A
+ * machine's run that is going is going only by its machine's word just now: one whose machine did
+ * not answer, or that its machine did not say, reads `unknown`, with when its machine was last
+ * seen. The runs of every other computer pass through as recorded.
+ */
+export declare function withMachineRuns(records: AgentMeta[], machines: readonly MachineRuns[]): AgentMeta[];
+/** A saved machine to ask for its runs: where it answers and its computer's own name. */
+export interface AskedMachine {
+    url: string;
+    host: string;
+    /** When it last answered, ISO, as kept with the machine. */
+    seenAt?: string;
+}
+/**
+ * What each saved machine said last of its runs of a project, asked again behind the page once
+ * its answer is a few seconds old: a page is answered at once with what is known, and waits only
+ * for a machine's first answer, and not long. One ask at a time per machine and project; each
+ * holds only what changed since the one before ({@link OwnRuns}).
+ */
+export declare class MachineRunsKept {
+    /** Ask the machine for its runs of the project at `address`, since what it answered last. */
+    private readonly ask;
+    /** Told each time a machine answered. */
+    private readonly seen;
+    private readonly now;
+    private readonly kept;
+    constructor(
+    /** Ask the machine for its runs of the project at `address`, since what it answered last. */
+    ask: (machine: AskedMachine, address: string, since: string | undefined) => Promise<unknown>, 
+    /** Told each time a machine answered. */
+    seen?: (machine: AskedMachine, at: string) => void, now?: () => number);
+    of(machines: readonly AskedMachine[], address: string): Promise<MachineRuns[]>;
+    private askAgain;
+}

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

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

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

@@ -8,6 +8,7 @@ import type { ProjectErrorsReader } from '../project-errors.js';
 import type { AddProjectResult, RemoveProjectResult, StartAgentOptions, StartAgentResult, StartedInResult } from './types.js';
 import type { AgentMeta } from '../store/index.js';
 import type { RemoteTarget } from './remote-run.js';
+import type { MachineRuns } from './machine-runs.js';
 /** Wired by the daemon so `sendStart` can reach the daemon's own `startAgent` closure. */
 export type StartAgentHandler = (prompt: string, options: StartAgentOptions, projectId?: string) => StartAgentResult | Promise<StartAgentResult>;
 /** Wired by the daemon so `sendAddProject` can install + register a repo (#433). */
@@ -53,6 +54,8 @@ export interface RemoteAgents {
      * it was given and its address. Asked of the machines first, when one has not said its name yet.
      */
     machineNames(): Promise<(host: string) => SavedMachine | undefined>;
+    /** What each saved machine said last of its own runs of the project at `projectPath`, asked again once that is a few seconds old (machine-runs.ts). */
+    machineRuns(projectPath: string): Promise<MachineRuns[]>;
 }
 /**
  * What every RPC acts through.

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

@@ -16,6 +16,8 @@ export interface AccountRow {
     id: string;
     /** Its name as shown: the person's own goes by the agent's name for them until they give it one. */
     name: string;
+    /** A login of the person's own computer, by that computer's name: a server's copy of it. */
+    from?: string;
     /** The person's own login, which the agent keeps: it is never removed. */
     own: boolean;
     /** When an added one was added, ISO 8601. */
@@ -32,11 +34,19 @@ export interface AccountRow {
 /** An account being added: the browser is open on the agent's page, or the login is being kept. */
 export interface AccountAdding {
     name: string;
-    /** The page to sign in at, when the agent gave one: what a person copies into a private window when the browser is signed in to another account. */
+    /** The page to sign in at, when the agent gave one: what a person copies into a private window when the browser is signed in to another account, or opens on their device where this computer has no browser. */
     url?: string;
+    /** No browser here: the code Codex gave, which the person types at {@link url}. */
+    code?: string;
+    /** No browser here: Claude's page shows a code once the person said yes, which they paste back. */
+    paste?: true;
 }
 export interface AccountsView {
     accounts: AccountRow[];
+    /** This computer's own name: what its own login's row says it is on. */
+    computer: string;
+    /** On a server: the computer of the person's whose logins it uses, by its name. */
+    from?: string;
     adding?: AccountAdding;
     /** Why the last add did not go through. */
     failed?: string;
@@ -55,6 +65,10 @@ export declare const accountsWiring: {
     codexFolder: (account: AgentAccount) => string;
     codexWho: (home: string) => Promise<CodexWho>;
     codexUsage: (home: string) => Promise<DriverRateWindow[]>;
+    /** No browser on this computer: a server's. */
+    headless: () => boolean;
+    /** This computer's own name. */
+    computer: () => string;
 };
 /** An agent's accounts in the order runs try them, each with how full it is and whether a limit keeps it out. */
 export declare function onAgentAccounts(agent: AccountsAgent): Promise<AccountsView>;
@@ -70,6 +84,8 @@ export type AccountResult = {
  * in {@link onAgentAccounts}.
  */
 export declare function sendAddAgentAccount(agent: AccountsAgent, name: string): Promise<AccountResult>;
+/** Hand Claude Code the code its page showed the person, on a computer with no browser of its own. */
+export declare function sendAgentAccountCode(agent: AccountsAgent, code: string): Promise<AccountResult>;
 /**
  * Remove an added account. A Claude login is not ended: it is good until its year is over, or until
  * it is taken back on claude.ai. A Codex account's folder, its login in it, goes with it.

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

@@ -0,0 +1,48 @@
+import { type CopiedKind, type CopiedLogin, type GivenLogin, type UsageWindow } from '../dashboard/copied-logins.js';
+import { type AccountResult } from './accounts.js';
+/** What the RPCs reach for, swapped in tests. */
+export declare const copiedWiring: {
+    /** Whether this OpenAgent is a server's: only a server takes logins. */
+    server: () => boolean;
+    /** Where a Codex account's sign-in is kept, a folder each. */
+    codexDir: () => string;
+    /** Run a git host's package command for `host`, with `input` on its standard input. */
+    gitHost: (host: string, args: string[], input?: string) => Promise<{
+        ok: true;
+        output: unknown;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+};
+/** What the server says it keeps, to the computer that asks. */
+export type CopiedView = {
+    ok: true;
+    logins: Omit<CopiedLogin, 'usage'>[];
+} | {
+    ok: false;
+    error: string;
+};
+/** What the server keeps from the person's computers, without how full each is: what a computer compares its own with. */
+export declare function onCopiedLogins(): Promise<CopiedView>;
+/**
+ * Take a login a computer of the person's handed over: it goes where its tool reads it, in place
+ * of what the same account of the same computer had here before. `secret` is the login: a
+ * Claude login, a Codex sign-in as Codex keeps it, a git host's token.
+ */
+export declare function sendCopiedLogin(given: GivenLogin, secret: string): Promise<AccountResult>;
+/** Take a login a computer handed over off this server: it is deleted here, and goes on working wherever else it is. */
+export declare function sendForgetCopiedLogin(which: Pick<CopiedLogin, 'kind' | 'host' | 'source'>): Promise<AccountResult>;
+/**
+ * Keep a login the computer no longer has: the person said to. It is no longer that account of the
+ * computer's, so the computer's next login under the same account takes a place of its own.
+ */
+export declare function sendKeepCopiedLogin(which: Pick<CopiedLogin, 'kind' | 'host' | 'source'>): Promise<AccountResult>;
+/** How full each login is, as the computer read it: shown on this server's page, whose own reading a Claude login made for it cannot make. */
+export declare function sendCopiedUsage(readings: {
+    kind: CopiedKind;
+    host?: string;
+    source: string;
+    windows: UsageWindow[];
+    at: number;
+}[]): Promise<AccountResult>;

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

@@ -10,8 +10,11 @@ export { onMachines, sendAddMachine, sendRemoveMachine, onMachinesReachable, onM
 export { onModules, runModuleCommand, runComputerCommand, runComputerCommandOn, readModule, type DashboardModule, type ModuleCommandResult, type ModuleReadResult } from './modules.js';
 export { onProjectSkills, sendChangeSkills, sendProjectSkills, type ProjectSkills, type ProjectSkill, type ChangeSkillsResult } from './skills.js';
 export { onPerson, type Person } from './person.js';
+export { onGitHostPeople, type HostPerson } from './people.js';
 export { onGitHosts, sendUseGitHostAccount, sendGitHostLogin, sendGitHostInstall, onAgentState, sendAgentFix, onProjectAccounts, sendProjectAccounts, type GitHostsView, type GitHostRow, type GitHostAccount, type GitHostProvider, type AgentState, type ProjectAccountsView, type ProjectAgentAccounts } from './logins.js';
-export { onAgentAccounts, sendAddAgentAccount, sendRemoveAgentAccount, sendUseAgentAccountFirst, sendNameOwnAgentAccount, type AccountsAgent, type AccountRow, type AccountWindow, type AccountAdding, type AccountsView, type AccountResult } from './accounts.js';
+export { onServerLogins, sendUseLoginsOn, sendAllowLogins, sendSettleLogin, type ServerLoginsView, type ServerLogins, type LoginThere } from './server-logins.js';
+export { onCopiedLogins, sendCopiedLogin, sendForgetCopiedLogin, sendKeepCopiedLogin, sendCopiedUsage, type CopiedView } from './copied-logins.js';
+export { onAgentAccounts, sendAddAgentAccount, sendAgentAccountCode, sendRemoveAgentAccount, sendUseAgentAccountFirst, sendNameOwnAgentAccount, type AccountsAgent, type AccountRow, type AccountWindow, type AccountAdding, type AccountsView, type AccountResult } from './accounts.js';
 import { streamAgentEvents } from './events.js';
 /** One RPC: called with whatever the browser sent, answering with whatever JSON.stringify keeps. */
 export type RpcHandler = (...args: never[]) => unknown;