@openagt/dashboard 0.34.0 → 0.36.0

package/dist/local-bin.js

@@ -0,0 +1,16 @@
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+/**
+ * The folder the installs a press runs put their programs in, with no admin: Claude Code's own
+ * installer and gh's build both go to `~/.local/bin`. A shell started from a terminal often has it
+ * on its PATH by the person's own setup; OpenAgent, started from anywhere, puts it there itself,
+ * last, so what is installed after it started is found by its checks and its runs alike.
+ */
+export function withLocalBin(env) {
+    const dir = join(env['HOME'] ?? homedir(), '.local', 'bin');
+    const path = env['PATH'] ?? '';
+    if (path.split(delimiter).includes(dir))
+        return;
+    env['PATH'] = path ? `${path}${delimiter}${dir}` : dir;
+}
+//# sourceMappingURL=local-bin.js.map

package/dist/local-bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-bin.js","sourceRoot":"","sources":["../src/local-bin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACjC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAE3C;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,GAAsB;IACjD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,OAAO,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAA;IAC3D,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;IAC9B,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAM;IAC/C,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAA;AACxD,CAAC"}

package/dist/module-types/dashboard/components/Waiting.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+/**
+ * What a pane says while it waits on a read ("Reading the file…"), shown only once the read takes
+ * a moment: a read that answers at once goes from nothing straight to what it read, with no line
+ * flashing between. It keeps its room while unseen, so nothing moves when it shows.
+ */
+export declare function Waiting({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/lib/route.d.ts

@@ -21,6 +21,8 @@ export interface Route {
      */
     scope?: string;
 }
+/** The query parameter that carries {@link Route.settings}. */
+export declare const SETTINGS_PARAM = "settings";
 /**
  * Read the route out of a URL's path and query, naming projects by `projects`. A first segment
  * that names no project is a module's page when it can be one, and else a project nobody

package/dist/module-types/dashboard/lib/settings-crumb.d.ts

@@ -0,0 +1,15 @@
+/** The page inside an entry, as its header shows it. */
+export interface SettingsCrumb {
+    /** What the page is about: "Studio Mac". */
+    title: string;
+    /** Back to the entry itself. */
+    back: () => void;
+}
+/** Set by the Settings dialog around an entry: how its page inside says it is open, and closed. */
+export declare const SettingsCrumbContext: import("react").Context<((crumb: SettingsCrumb | undefined) => void) | null>;
+/**
+ * Show a page inside a Settings entry: the header says its title after the entry's, and its back
+ * arrow calls `back`. Nothing while `crumb` is undefined. Answers whether a header shows it: outside
+ * the Settings dialog none does, and the page draws its own way back.
+ */
+export declare function useSettingsCrumb(crumb: SettingsCrumb | undefined): boolean;

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

@@ -1,3 +1,4 @@
+import { type ComponentType } from 'react';
 import type { LinkAction, ModuleCard, ModulePage, ModulePanel, ModuleRunSlots, ModuleSchedule, ModuleSettings, ModuleUsageLimit } from '../module/index.js';
 /** A module page as the shell mounts it: the page, plus the package it came from and the projects that have it. */
 export interface MountedPage extends ModulePage {
@@ -35,6 +36,11 @@ export interface MountedUsageLimit extends ModuleUsageLimit {
     package: string;
     projects: string[];
 }
+/** What a module of this computer's draws over every page, as the shell mounts it: the part, and the package it came from. */
+export interface MountedEveryPage {
+    EveryPage: ComponentType;
+    package: string;
+}
 /** The commands a module starts by itself, as the shell mounts them: the read, plus the package it came from and the projects that have it. */
 export interface MountedSchedule extends ModuleSchedule {
     package: string;
@@ -52,6 +58,8 @@ export interface MountedModules {
     runSlots: MountedRunSlots[];
     /** The Settings entries, in the order they are listed: by `order`, then by package name. */
     settings: MountedSettings[];
+    /** What the modules of this computer's draw over every page, in package order. */
+    everyPage: MountedEveryPage[];
     /** The usage bar's stop line: the first module's that declares one, in package order; absent when none does. */
     usageLimit?: MountedUsageLimit;
     /** What starts by itself: the first module's that declares it, in package order; absent when none does. */

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

@@ -2,5 +2,8 @@
  * Whether an element is narrower than `width` pixels, followed as it is resized: a pane beside the
  * chat is as wide as the person drags it, not as the window is. Pass the element through a state
  * setter used as its `ref`. Wide where the browser cannot measure.
+ *
+ * Measured before the page is drawn, so a pane opened narrow never shows for a frame as a wide one
+ * would (a file tree beside the file, then gone).
  */
 export declare function useNarrow(element: HTMLElement | null, width: number): boolean;

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

@@ -212,11 +212,12 @@ export interface ModulePanelProps {
     activity?: number;
     /**
      * On a pane that lists what a run changed (`changes`): the changed file a click in the chat
-     * asked to see, by its path in the run's checkout. `at` tells one ask from the next for the
-     * same file. Absent until a file is asked for.
+     * asked to see, by its path in the run's checkout; no path when the click asked for all of
+     * them, from the first. `at` tells one ask from the next for the same file. Absent until a
+     * file is asked for.
      */
     reveal?: {
-        path: string;
+        path?: string;
         at: number;
     };
     context: ModuleContext;
@@ -230,10 +231,8 @@ export interface ModulePanelProps {
 export interface ModulePanel {
     /** Which pane this is among the module's own, for its key and for remembering that it is open. */
     id: string;
-    /** The pane's name: on its card, and what its icon is called. */
+    /** The pane's name: on its card, and what its icon is called and its tooltip says. */
     label: string;
-    /** The icon's tooltip: one sentence on what the pane shows. */
-    help: string;
     /** The pane's icon in the top bar, drawn at the size its `className` gives. */
     icon: ComponentType<{
         className?: string;
@@ -280,6 +279,12 @@ export interface ModuleDefinition {
     run?: ModuleRunSlots;
     /** The entries the module adds to Settings. */
     settings?: ModuleSettings[];
+    /**
+     * What the module draws over every page, for as long as the dashboard is open: nothing, until
+     * something it watches asks for the person, such as another computer asking to connect. Drawn
+     * once, with no project, and only for a module of this computer's.
+     */
+    everyPage?: ComponentType;
     /** The stop line the module puts on the usage bar. */
     usageLimit?: ModuleUsageLimit;
     /** The commands the module starts by itself, for the other pages to say. */
@@ -331,8 +336,10 @@ export interface ModuleHost {
      * 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.
+     * `input` is what the command reads on standard input: a secret, which no other program on
+     * this computer sees there, as it would among the arguments.
      */
-    runComputerCommand(args: string[], command?: string): Promise<ModuleCommandResult>;
+    runComputerCommand(args: string[], command?: string, input?: string): Promise<ModuleCommandResult>;
     /**
      * The same, on a saved machine whose package of the same name is that computer's: what the
      * package keeps over there, read and changed with this computer's key there, as that machine's
@@ -374,7 +381,7 @@ export interface ModuleHost {
     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.
+     * pastes it under Devices. This computer is let in there with it, once, and keeps its key.
      */
     addMachine(link: string, label?: string): Promise<MachineAdded>;
     /**
@@ -382,6 +389,19 @@ export interface ModuleHost {
      * there stops working. Refused, with the reason, while a run is at work there.
      */
     removeMachine(id: string): Promise<MachineRemoved>;
+    /** Give a saved machine the name the person picked. */
+    renameMachine(id: string, label: string): Promise<MachineAdded>;
+    /**
+     * Have a saved machine save this computer, with the link this computer's door gave for a new
+     * device: that machine then starts runs here too. Not for a computer reached through a server.
+     */
+    letMachineIn(machineId: string, link: string): Promise<MachineAdded>;
+    /**
+     * A code one more device of the person's gets in with at a saved machine, a server: the link a
+     * camera opens, and what is typed on another computer instead, where and the code. Works once,
+     * until `expires`. Not for a computer reached through a server.
+     */
+    machineCode(machineId: string): Promise<ModuleMachineCode>;
     /**
      * The computers that keep a line open to a saved server: computers at home a run can be sent to
      * through the server, and whether each is saved here already. None for a machine that is no server.
@@ -418,11 +438,18 @@ export interface ModuleMachine {
     device?: string;
     /** Whose computer it is, by their GitHub account, when it is another person's shared with everyone on a server. */
     owner?: string;
+    /**
+     * The ids the machine is listed under at the doors of the machines it saved, as it says: one of
+     * them among this computer's own door's devices is that machine, in there too.
+     */
+    listed?: string[];
 }
 /** What {@link ModuleHost.machines} answers. */
 export interface ModuleMachines {
     /** This computer's own OpenAgent. */
     version: string;
+    /** This computer's own name, as another machine lists it: "Suleimans-MacBook-Pro". */
+    name?: string;
     machines: ModuleMachine[];
 }
 /** How saving a machine went: done, or stopped, with the reason. */
@@ -432,6 +459,19 @@ export type MachineAdded = {
     ok: false;
     error: string;
 };
+/** A code a device gets in with at a saved machine, as {@link ModuleHost.machineCode} answers it. */
+export type ModuleMachineCode = {
+    ok: true;
+    value: {
+        url: string;
+        where: string;
+        code: string;
+        expires: string;
+    };
+} | {
+    ok: false;
+    error: string;
+};
 /** A computer that keeps a line open to a saved server, as {@link ModuleHost.computersThrough} answers it. */
 export interface ModuleComputerThrough {
     /** The server's id for it. */
@@ -513,9 +553,8 @@ 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 { useSettingsCrumb, type SettingsCrumb } from '../lib/settings-crumb.js';
 export { QrCode } from '../components/QrCode.js';
-export { AddMachineDialog } from '../components/AddMachineDialog.js';
-export { InviteDialog, type InviteCode, type InviteAnswer, type InvitePersons } from '../components/InviteDialog.js';
 export { Dialog } from '../components/ui/dialog.js';
 export { reachedByLine } from '../../src/client.js';
 export { useCodingAgents, type CodingAgent } from '../lib/models.js';
@@ -523,6 +562,7 @@ export { MAX_SPEND_OFFSET } from '../../src/preference-defaults.js';
 export { formatRelative, formatDateTime, formatDuration, formatAge } from '../lib/format-date.js';
 export { usePolled, useLoaded, forgetRemembered } from '../lib/use-async.js';
 export { useNarrow } from '../lib/use-narrow.js';
+export { Waiting } from '../components/Waiting.js';
 export { useHighlighted, Pieces, type Piece } from '../lib/highlight.js';
 export { useAction } from '../lib/use-action.js';
 export { useSchedule, type Schedule } from '../lib/use-schedule.js';

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

@@ -0,0 +1,37 @@
+/** An account the git host's tool knows, as its package said it. */
+export interface GitHostAccount {
+    login: string;
+    /** The terminal's: the one the tool uses when not told which. */
+    terminal: boolean;
+    /** The one OpenAgent's runs use. */
+    runs: boolean;
+    /** Whether the tool could use it when asked. */
+    ok: boolean;
+}
+/** What a git host's package answers of it. */
+export interface GitHostProvider {
+    name: string;
+    /** The host's word for a pull request. */
+    requestWord: string;
+    /** Its logo, an SVG. */
+    logo?: string;
+    /** The tool it works through, by its command's name. */
+    tool: string;
+    installed: boolean;
+    /** The command a press installs the tool with, shown under the button. */
+    install: string;
+    accounts: GitHostAccount[];
+    /** A login waiting for the browser's yes: the code the person types, and where. */
+    loggingIn?: {
+        code: string;
+        url: string;
+    };
+    /** The install a press started is going on. */
+    installing?: boolean;
+    /** Why the last install failed, while the tool is still not here. */
+    installFailed?: string;
+}
+/** The host of a git remote's address: `git@host:path`, `ssh://user@host/path`, `https://host/path`. None for a local path. */
+export declare function remoteHost(remote: string): string | undefined;
+/** A package's `accounts` answer, read: none for an answer that is not one. */
+export declare function readProvider(output: unknown): GitHostProvider | undefined;

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

@@ -7,7 +7,7 @@
  *
  * What a computer says of a login there is only whose it is, where it came from and a mark of it:
  * the start of its SHA-256, by which the copier tells whether the copy is still its own login.
- * The login itself is never said. The marks are the servers package's (`own.ts`), made the same way.
+ * The login itself is never said. The marks are the devices package's (`servers/own.ts`), made the same way.
  */
 /** One login there, as that computer says it. */
 export interface LoginThere {
@@ -40,7 +40,7 @@ export declare function markOf(login: string): string;
 /** What another computer said of the logins there, as far as it reads as such: it is another computer's data. */
 export declare function readLogins(value: unknown): MachineLogins;
 /**
- * The servers package's `own` answer of a person's own OpenAgent, as that computer says it: each
+ * The devices package's `server own` answer of a person's own OpenAgent, as that computer says it: each
  * login that is there, a copy when it names the server it came from.
  */
 export declare function loginsOfOwn(said: unknown): MachineLogins;

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

@@ -14,17 +14,19 @@ export interface Person {
     avatar?: string;
 }
 /**
- * Who a call came from, when the door in front of OpenAgent says (remote-access): the GitHub
- * account of the person whose device made it. Said only on a computer several persons use.
+ * Who a call came from, when the door in front of OpenAgent says (the devices package): the name
+ * of the person whose device made it, `%`-encoded, as a header carries only plain letters. Said
+ * only on a computer several persons use.
  */
 export declare const PERSON_HEADER = "x-openagent-person";
-/** Run `call` as one a person's device made, by their GitHub account, when the request said one. */
+/** Run `call` as one a person's device made, by their name, when the request said one. */
 export declare function asCaller<T>(header: string | string[] | undefined, call: () => Promise<T>): Promise<T>;
-/**
- * The person at the page: the one this computer knows, or, for a call another person's device
- * made, that person by their GitHub account and its picture.
- */
-export declare function personAtPage(own: Person, account?: string | undefined): Person;
+/** The person whose device made this call, by their name: only a person the owner invited is said. */
+export declare function callerAtPage(): string | undefined;
+/** How a command of this computer's is told who asks, when a person the owner invited does: their name, `%`-encoded. */
+export declare const CALLER_ENV = "OPENAGENT_CALLER";
+/** The person at the page: the one this computer knows, or, for a call another person's device made, that person by their name. */
+export declare function personAtPage(own: Person, name?: string | undefined): Person;
 /** `projects` are the listed projects' folders, in the list's order. */
 export declare function readPerson(deps: {
     projects: () => Promise<string[]>;

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

@@ -49,13 +49,14 @@ 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, and the computer's own
- * name, which the records of its runs carry. Nothing for a machine that does not answer, or
- * does not say.
+ * 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.
  */
 export declare function remoteFacts(target: MachineAccess): Promise<{
     version?: string;
     host?: string;
+    listed?: string[];
 }>;
 /** 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>;
@@ -93,7 +94,7 @@ export declare function leaveRemote(machine: MachineAccess & {
  * computer at home that nothing on a network reaches is asked at this address, through the
  * server, with this computer's key at the server. To this computer it is one more machine.
  */
-export declare const THROUGH_PATH = "/_remote-access/via/";
+export declare const THROUGH_PATH = "/_devices/via/";
 /** A computer that keeps a line open to a server, as the server's door lists it. */
 export interface ComputerOnServer {
     id: string;
@@ -246,6 +247,17 @@ export declare function remoteComputerCommand(machine: MachineAccess, pkg: strin
     ok: false;
     error: string;
 }>;
+/**
+ * Have a saved machine save this computer, by a link this computer's door gave for a new device:
+ * that machine then sends its runs here too. Asked of the machine's own OpenAgent, as its page
+ * would add a machine; what it answers is its own words.
+ */
+export declare function remoteAddMachine(machine: MachineAccess, link: string, label: string): Promise<{
+    ok: true;
+} | {
+    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;
@@ -270,6 +282,8 @@ export type DoorAsk = {
     id: string;
 } | {
     what: 'line';
+} | {
+    what: 'code';
 };
 /**
  * Ask a machine's door about the person this computer is in as there: the door answers it

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

@@ -0,0 +1,81 @@
+import { type AgentAccount, type DriverRateWindow } from '@openagt/agent-driver';
+import { type Mint } from '@openagt/agent-driver-claude';
+import { type CodexLogin, type CodexLoginOptions, type CodexWho } from '@openagt/agent-driver-codex';
+/** The agents with accounts: Claude Code's and Codex's. */
+export type AccountsAgent = 'claude' | 'codex';
+/** One of an account's usage windows, by how long it lasts. */
+export interface AccountWindow {
+    /** `5 h`, `week`, `month`. */
+    label: string;
+    /** How much of it is gone, 0-100. */
+    percent: number;
+}
+/** One account as the page shows it. */
+export interface AccountRow {
+    /** The account as the file names it: what the page sends back to act on it. */
+    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;
+    /** The person's own login, which the agent keeps: it is never removed. */
+    own: boolean;
+    /** When an added one was added, ISO 8601. */
+    added?: string;
+    /** How full it is, shortest window first; none when nothing said it yet. */
+    windows: AccountWindow[];
+    /** When those were said, epoch ms, when not now: an added Claude account is known from its last run. */
+    asOf?: number;
+    /** Until when a limit keeps it out, epoch ms. */
+    limitedUntil?: number;
+    /** `in-use`: the first one a run takes now; `next`: the one after it; `limited`: a limit keeps it out. */
+    state?: 'in-use' | 'next' | 'limited';
+}
+/** 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. */
+    url?: string;
+}
+export interface AccountsView {
+    accounts: AccountRow[];
+    adding?: AccountAdding;
+    /** Why the last add did not go through. */
+    failed?: string;
+    /** The daemon's clock, so "free in 2 h" is counted from the same now. */
+    now: number;
+}
+/** What the RPCs reach for, swapped in tests: the logins, where each agent keeps who the person is, how full a Codex account is. */
+export declare const accountsWiring: {
+    mint: Mint;
+    claudeJson: () => string;
+    path: (agent: AccountsAgent) => string;
+    now: () => number;
+    loginCodex: (opts: CodexLoginOptions) => Promise<CodexLogin>;
+    codexDir: () => string;
+    codexOwnHome: () => string;
+    codexFolder: (account: AgentAccount) => string;
+    codexWho: (home: string) => Promise<CodexWho>;
+    codexUsage: (home: string) => Promise<DriverRateWindow[]>;
+};
+/** 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>;
+export type AccountResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Add an account: this computer's browser opens on the agent's page, the person signs in there to
+ * the account being added, and its login is kept under `name`. Answers at once; the page follows it
+ * in {@link onAgentAccounts}.
+ */
+export declare function sendAddAgentAccount(agent: AccountsAgent, name: 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.
+ */
+export declare function sendRemoveAgentAccount(agent: AccountsAgent, name: string): Promise<AccountResult>;
+/** Runs try `name` first from now on. */
+export declare function sendUseAgentAccountFirst(agent: AccountsAgent, name: string): Promise<AccountResult>;
+/** The person's own login under the name they give it. */
+export declare function sendNameOwnAgentAccount(agent: AccountsAgent, name: string): Promise<AccountResult>;

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

@@ -6,10 +6,12 @@ export { onPreferences, savePreferences, patchPreferences, onProjectPresets, sav
 export { type EditorInfo } from '../dashboard/open-in-app.js';
 export { onQuota } from './quota.js';
 export { onModels } from './models.js';
-export { onMachines, sendAddMachine, sendRemoveMachine, onMachinesReachable, onMachineVersions, sendProjectToMachine, onProjectOnMachine, onComputersThrough, sendAddComputerThrough, onMachinePerson, sendRemoveMachineDevice, sendMachineLineLink, sendMachineTold, onMachineLogins, sendMachineLogins, type Machine, type MachineLoginsResult, type AddMachineResult, type MachineVersions, type ProjectOnMachine, type ComputersThrough, type MachinePerson } from './machines.js';
+export { onMachines, sendAddMachine, sendRemoveMachine, onMachinesReachable, onMachineVersions, sendProjectToMachine, onProjectOnMachine, onComputersThrough, sendAddComputerThrough, onMachinePerson, sendRemoveMachineDevice, sendRenameMachine, sendLetMachineIn, sendMachineLineLink, sendMachineCode, sendMachineTold, onMachineLogins, sendMachineLogins, type Machine, type MachineLoginsResult, type AddMachineResult, type MachineVersions, type ProjectOnMachine, type ComputersThrough, type MachinePerson, type MachineCode } from './machines.js';
 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 { 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';
 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;

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

@@ -0,0 +1,97 @@
+import { runPackageCommand, type ProvidedCommand } from '@openagt/agent-data';
+import type { DriverFix, DriverReadiness } from '@openagt/agent-driver';
+import { type DriverName } from '../driver-names.js';
+import { type AccountResult } from './accounts.js';
+import { type GitHostProvider } from '../dashboard/git-hosts.js';
+export type { GitHostAccount, GitHostProvider } from '../dashboard/git-hosts.js';
+/** One host the projects' remotes are on: which projects, and its package's answer, or none when no package answers for it. */
+export interface GitHostRow {
+    host: string;
+    /** The projects whose remote is there, by name. */
+    projects: string[];
+    provider?: GitHostProvider;
+}
+export interface GitHostsView {
+    hosts: GitHostRow[];
+}
+/** What the RPCs reach for, swapped in tests. */
+export declare const loginsWiring: {
+    /** The origin remote's address of the project at `root`. */
+    origin: (root: string) => Promise<string | undefined>;
+    /** The project's git host package's command. */
+    gitHost: (root: string) => Promise<ProvidedCommand | undefined>;
+    run: typeof runPackageCommand;
+    ready: (driver: DriverName) => Promise<DriverReadiness>;
+    /** Run a fix's command to its end; rejects with its last lines. */
+    fix: (command: string) => Promise<void>;
+    driver: () => Promise<DriverName>;
+};
+/** The hosts the projects' remotes are on, in the projects' order, each with its package's answer. A project with no remote is on none. */
+export declare function onGitHosts(): Promise<GitHostsView>;
+/** Runs use `login` at `host` from now on; the terminal's own account stays as it is. */
+export declare function sendUseGitHostAccount(host: string, login: string): Promise<AccountResult>;
+/** Log another account in at `host`, in the browser: the code the person types, and where. */
+export declare function sendGitHostLogin(host: string): Promise<{
+    ok: true;
+    code: string;
+    url: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Install the tool `host`'s package works through, with the command it declared; the card follows it. */
+export declare function sendGitHostInstall(host: string): Promise<AccountResult>;
+/** How the coding agent's CLI is on this computer, and what a press does about what is missing. */
+export interface AgentState {
+    driver: DriverName;
+    /** Installed and logged in, or it could not say otherwise. */
+    ready: boolean;
+    /** What is in the way, in words. */
+    problem?: string;
+    /** What a press does about it, when the agent's package declared a command for it. */
+    fix?: DriverFix;
+    /** A press's fix going on. */
+    fixing?: DriverFix['kind'];
+    /** Why the last press's fix failed. */
+    failed?: string;
+}
+/** The coding agent picked in Settings, or `driver`: installed, logged in, and what a press fixes. */
+export declare function onAgentState(driver?: string): Promise<AgentState>;
+/**
+ * Fix what is in the way of `driver`: the command its package declared for it, run here, the
+ * install to its end, the login until the browser said yes. Answers at once; the page follows it
+ * in {@link onAgentState}.
+ */
+export declare function sendAgentFix(driver: string): Promise<AccountResult>;
+/** A project's own accounts, beside the computer's: shown for a kind the computer has two or more of, or that the project names already. */
+export interface ProjectAccountsView {
+    gitHost?: {
+        host: string;
+        name: string;
+        /** The host's word for a pull request. */
+        requestWord: string;
+        accounts: string[];
+        /** The computer's runs' account. */
+        computer?: string;
+        /** The project's own, when it names one. */
+        project?: string;
+    };
+    claude?: ProjectAgentAccounts;
+    codex?: ProjectAgentAccounts;
+}
+/** One agent's accounts a project may pick from, and its own few. */
+export interface ProjectAgentAccounts {
+    accounts: {
+        id: string;
+        name: string;
+    }[];
+    /** The project's own few, by id, when it names some. */
+    project?: string[];
+}
+export declare function onProjectAccounts(projectId: string): Promise<ProjectAccountsView | null>;
+/** Change a project's own accounts: a value sets one, `null` goes back to the computer's. Kept on this computer, never in the repository. */
+export declare function sendProjectAccounts(projectId: string, change: {
+    gitHost?: string | null;
+    claude?: string[] | null;
+    codex?: string[] | null;
+}): Promise<AccountResult>;

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

@@ -123,25 +123,67 @@ export declare function sendMachineLineLink(machineId: string): Promise<{
     ok: false;
     error: string;
 }>;
+/** A code one more device of this person's gets in with at a saved machine: the link a camera opens, and what is typed instead, where and the code. */
+export interface MachineCode {
+    url: string;
+    where: string;
+    code: string;
+    expires: string;
+}
+/**
+ * A code that lets one more device of this person's in at a saved machine, a server: a device
+ * that is in gives the code for the next one. Asked of the machine's door with this computer's
+ * key there, so every computer of the person's that is in asks, not only the one that set the
+ * server up. The code works once, for a short time.
+ */
+export declare function sendMachineCode(machineId: string): Promise<{
+    ok: true;
+    value: MachineCode;
+} | {
+    ok: false;
+    error: string;
+}>;
 /** 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, and the id it lists this computer under among its devices. */
+    /** This computer's own name, as another machine lists it. */
+    name: string;
+    /**
+     * Each saved machine, with its version when it answers and says, the id it lists this computer
+     * under among its devices, and the ids it is listed under at the doors of the machines it saved.
+     */
     machines: (Machine & {
         version?: string;
         device?: string;
+        listed?: 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.
  * The key itself is never told: only the id the machine lists this computer under, which a page
- * that lists the machine's devices names this computer by.
+ * that lists the machine's devices names this computer by. A machine also says the ids it is
+ * listed under at the doors it saved: one of them in this computer's own door is that machine,
+ * in there too, so a page lists the computer once. A machine that does not answer is known by
+ * what it said last.
  */
 export declare function onMachineVersions(): Promise<MachineVersions>;
+/** Give a saved machine the name the person picked. */
+export declare function sendRenameMachine(id: string, label: string): Promise<AddMachineResult>;
+/**
+ * Have a saved machine save this computer, with a link this computer's door gave for a new
+ * device: from then on it starts runs here too. Not for a computer reached through a server,
+ * whose runs come here through that server.
+ */
+export declare function sendLetMachineIn(machineId: string, link: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
 /** Whether a saved machine has a project of this computer's: `there` is false while the machine clones it. */
 export type ProjectOnMachine = {
     ok: true;