@openagt/dashboard 0.56.0 → 0.58.0

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

@@ -1,3 +1,4 @@
+import { type RemoteAccount } from '@openagt/agent-data';
 /**
  * A project added by its repository's address, for a computer that does not have its folder: a
  * server that was just connected has no screen to pick a folder on and no folder to pick. The
@@ -5,8 +6,11 @@
  * and that folder is then added like any other. Nothing is asked about where: the page says
  * where it went.
  *
- * git clones with the logins this computer has (its credential helper, its SSH keys) and is
- * never let ask a person for one: a repository it cannot read is refused in words.
+ * git clones as one of OpenAgent's accounts at the repository's host (`account`), never with the
+ * person's own logins: their credential helpers are dropped, and an SSH address, which would use
+ * their own key, is refused unless the account's settings take it over the web. With no account
+ * there, only a public repository can be cloned. git is never let ask a person for a login: a
+ * repository it cannot read is refused in words.
  */
 /** Where a repository is cloned from and to. */
 export interface CloneTarget {
@@ -18,10 +22,8 @@ export interface CloneTarget {
     path: string;
 }
 /**
- * Read what a person typed as a repository's address: `github.com/you/shop`, the same with
- * `https://` before it, `ssh://git@github.com/you/shop.git`, or `git@github.com:you/shop.git`.
- * Undefined for anything else: a folder on this disk, another kind of address, a name that could
- * be read as an option or lead out of the folder projects are cloned into.
+ * Where what a person typed would be cloned to: `~/projects/<its name>`, in the home of the user
+ * OpenAgent runs as. Undefined wherever {@link typedRepository} is.
  */
 export declare function cloneTarget(typed: string, home?: string): CloneTarget | undefined;
 /** How a clone went: the folder the project is in, and whether it was cloned now or was already there. */
@@ -55,8 +57,8 @@ export interface CloneOptions {
     run?: CloneRunner;
     env?: NodeJS.ProcessEnv;
     timeoutMs?: number;
-    /** The person's own way to SSH for git, when they set one; read off git's settings when unsaid. */
-    sshCommand?: (env: NodeJS.ProcessEnv) => Promise<string | undefined>;
+    /** The account of OpenAgent's the repository is read as: its git settings. None: no login at all. */
+    account?: RemoteAccount;
 }
 /**
  * Clone the repository a person typed the address of into `~/projects/<its name>`. A folder that

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

@@ -1,14 +1,14 @@
-/** An account the git host's tool knows, as its package said it. */
+/** One of OpenAgent's own accounts on the git host, 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;
     /** On a server: the computer of the person's whose login it is. */
     from?: string;
+    /** Its public picture at the host, as the package said it: an https address. */
+    avatar?: string;
 }
 /** What a git host's package answers of it. */
 export interface GitHostProvider {

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

@@ -21,6 +21,10 @@ import { type CopiedKind, type UsageWindow } from './copied-logins.js';
  *
  * 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.
+ *
+ * An agent's GitHub account (Rom's design: an agent is the same on every device) goes further:
+ * to every saved device of the person's, server or not, told to use this computer's logins or
+ * not, as soon as the agent is saved and every minute after. A git host's token goes as it is.
  */
 /** One of this computer's accounts, as a server gets it. */
 export interface LocalLogin {
@@ -97,6 +101,8 @@ export declare const syncWiring: {
     }>;
     /** This computer's own logins. */
     local: () => Promise<LocalLogin[]>;
+    /** The GitHub logins the agents name. */
+    agentLogins: () => Promise<string[]>;
     /** How full each of this computer's accounts is, as its own page reads it. */
     usage: () => Promise<{
         kind: CopiedKind;
@@ -119,8 +125,26 @@ export declare function claudeOwnAccount(env?: NodeJS.ProcessEnv): {
 } | 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. */
+/** How an agent's GitHub accounts stand on one device of the person's. */
+export interface AgentLoginsOn {
+    machineId: string;
+    label: string;
+    /** It answered when last asked; not reached, the states are as last read. */
+    reachable: boolean;
+    /** By login: there, or why it did not get there. */
+    github: Record<string, {
+        state: 'there' | 'failed';
+        error?: string;
+    }>;
+}
+/**
+ * Bring every server that uses this computer's logins up to them, and every device of the
+ * person's up to the GitHub accounts the agents name; note how each stands. A saved machine that
+ * is no server of the person's is left out of the servers' list.
+ */
 export declare function syncLogins(): Promise<ServerLogins[]>;
+/** How the agents' GitHub accounts stand on each device of the person's, as last read: read anew when none were read yet. */
+export declare function agentLoginsOn(): Promise<AgentLoginsOn[]>;
 /** 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[]>;
 /**

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

@@ -46,7 +46,7 @@ export interface Overview {
     /** The most recently active projects (capped). */
     recent: RecentProject[];
 }
-/** One recent session, tagged with the project it belongs to, for the cross-project rail. */
+/** One recent session, tagged with the project it belongs to, for the cross-project rail; a session with no project is tagged {@link SESSIONS_ID}, with no name. */
 export interface RecentAgent {
     projectId: string;
     projectName: string;
@@ -56,9 +56,11 @@ export interface RecentAgent {
 export interface RecentAgentsDeps {
     /** A project's runs: off its folder for one of this computer's, as its computer says them for another's. */
     agents?: (project: ProjectSummary) => Promise<AgentMeta[]>;
+    /** The sessions with no project; none when absent. */
+    sessions?: () => Promise<AgentMeta[]>;
 }
 /**
- * Every project's sessions pooled and sorted newest-first (capped), so the shared sidebar (#shared-
+ * Every project's sessions, and the sessions with no project, pooled and sorted newest-first (capped), so the shared sidebar (#shared-
  * shell) can show recents on the home/Overview where no single project is selected. Each row carries
  * the project it belongs to, so selecting it jumps into that project's session. Forgiving — a project
  * whose agents cannot be read simply contributes nothing.

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

@@ -1,17 +1,19 @@
-import { type GitHostFor } from '../store/git-host.js';
+import { type PersonRecord } from '@openagt/agent-data';
 /**
- * The person at this dashboard, as the foot of its sidebar shows them: a name, and a picture
- * where a git host knows one. The name is git's own `user.name`, the one every commit of theirs
- * carries, else the git host's name for them, else their login there, else this computer's user.
- * The picture is asked of the git host of the first project that has one: OpenAgent names no git
- * host, so a project's own package answers (`me`).
+ * The person at this dashboard, as the foot of its sidebar shows them: their name, and a picture
+ * when they have one. Both are the person's own (`person.json` in the personal folder, the same on
+ * every computer of theirs): what they typed in Settings, or copied once from a GitHub profile.
+ * With none set, the name is git's own `user.name`, else this computer's user, and no picture;
+ * no git host is ever asked.
  */
 export interface Person {
     name: string;
-    /** Their login at the git host, when one answered. */
-    login?: string;
     /** A picture of them: an https address. */
     avatar?: string;
+    /** The GitHub login the name and picture were copied from. */
+    github?: string;
+    /** Whether the person set their name in OpenAgent, rather than it being the computer's. */
+    own?: true;
 }
 /**
  * Who a call came from, when the door in front of OpenAgent says (the devices package): the name
@@ -27,9 +29,8 @@ export declare function callerAtPage(): string | undefined;
 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[]>;
+/** The person this computer's OpenAgent knows: their own record, else git's name or this computer's user. */
+export declare function readPerson(deps?: {
+    record?: () => Promise<PersonRecord | undefined>;
     gitName?: () => Promise<string | undefined>;
-    gitHost?: GitHostFor;
 }): Promise<Person>;

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

@@ -0,0 +1,74 @@
+/** A Git repository found on this computer. */
+export interface FoundRepo {
+    /** Its folder, absolute. */
+    path: string;
+    /** The folder's name. */
+    name: string;
+    /** Its `origin` remote's address, when it has one. */
+    url?: string;
+}
+/** How far into a folder the crawl goes: `~/Projects/org/repo` is 3 deep. */
+export declare const CRAWL_DEPTH = 4;
+/** The strict limit of a crawl someone waits on: past it, what was found is the list. */
+export declare const CRAWL_LIMIT_MS = 2000;
+/** The limit of a crawl nobody waits on: behind a kept list. */
+export declare const CRAWL_BEHIND_LIMIT_MS = 20000;
+/** How old the kept list may be before a read crawls again, in the background. */
+export declare const REPOS_MAX_AGE_MS = 60000;
+/** The fs a crawl reads through, so a test can count and slow its reads. */
+export interface CrawlFs {
+    /** The folder's entries, with whether each is a folder; a folder that cannot be read has none. */
+    entries(path: string): Promise<{
+        name: string;
+        directory: boolean;
+    }[]>;
+    /** A file's text, or undefined when it cannot be read. */
+    read(path: string): Promise<string | undefined>;
+}
+/** The {@link CrawlFs} of this computer's disk. A link is not followed: its folder is found where it is. */
+export declare function nodeCrawlFs(): CrawlFs;
+/** The `url` of `[remote "origin"]` in a repository's `.git/config`; undefined when it has none. */
+export declare function originUrlOf(config: string): string | undefined;
+/** What a crawl is told: where to look, and how far and how long. */
+export interface CrawlOptions {
+    depth?: number;
+    limitMs?: number;
+    fs?: CrawlFs;
+    now?: () => number;
+}
+/** What a crawl found, and whether it looked everywhere or the time was up first. */
+export interface Crawl {
+    repos: FoundRepo[];
+    whole: boolean;
+}
+/**
+ * The repositories under `roots`, each found once, by name. A root that is itself a
+ * repository is one, and is still looked through: a home folder can be a repository of its own
+ * settings. Any other folder with a `.git` (a folder, or a worktree's file) is a repository, and the
+ * crawl goes no further into it. The crawl reads a level of folders at once, and stops when the
+ * time is up, between reads: what it found until then is the answer.
+ */
+export declare function crawlRepos(roots: readonly string[], options?: CrawlOptions): Promise<Crawl>;
+/** The repos as kept, and whether a crawl with more time is looking for the rest of them. */
+export interface RepoRead {
+    repos: FoundRepo[];
+    looking: boolean;
+}
+/** The kept repo list and how it is read again. */
+export interface RepoIndex {
+    /** The repos as last found: the first read waits on a crawl, a read of an old or cut-short list crawls again in the background. */
+    read(): Promise<RepoRead>;
+    /** Crawl now, and answer what this crawl found: after a folder is added. */
+    refresh(): Promise<RepoRead>;
+}
+/** A {@link RepoIndex} over the folders `roots` names when a crawl starts. */
+export declare function repoIndex(roots: () => Promise<string[]>, options?: {
+    crawl?: (roots: string[], limitMs: number) => Promise<Crawl>;
+    now?: () => number;
+    maxAgeMs?: number;
+}): RepoIndex;
+/**
+ * This computer's repos: one list for the daemon, first crawled when a page asks. It looks in the home folder
+ * and in the folders the person added (`repoFolders` in the registry).
+ */
+export declare function thisComputersRepos(): RepoIndex;

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

@@ -1,4 +1,4 @@
-import { type GitRunner } from '@openagt/agent-data';
+import { type GitRunner, type RemoteAccount } from '@openagt/agent-data';
 import { type GitHostFor } from '../store/git-host.js';
 /**
  * A project's skills sent to where its agents start from (#2023): what "Save and send" and "Send"
@@ -11,6 +11,10 @@ import { type GitHostFor } from '../store/git-host.js';
  * Nothing else the person has is pushed: the folder's branch is pushed as it is only when it is the
  * default branch and holds nothing past the remote's but skill files; else the skills' files are
  * written onto the remote's branch in a commit of their own, made without touching the folder.
+ *
+ * The remote is talked with as one of OpenAgent's accounts (`pushAccount`, the one kept at the
+ * project's Share switch, else the one runs use), never as the person's own login: with none,
+ * nothing is sent and the reason is said.
  */
 /** The branch the skills go to when the default branch takes no push: one, so a second send updates the open pull request. */
 export declare const SKILLS_BRANCH = "openagent/skills";
@@ -47,4 +51,11 @@ export type SendSkillsResult =
 export declare function sendSkills(cwd: string, names: readonly string[], deps?: {
     git?: GitRunner;
     gitHost?: GitHostFor;
+    pushAccount?: (cwd: string) => Promise<{
+        ok: true;
+        account?: RemoteAccount;
+    } | {
+        ok: false;
+        error: string;
+    }>;
 }): Promise<SendSkillsResult>;

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

@@ -67,21 +67,6 @@ export type RemoveProjectResult = {
     ok: false;
     error: string;
 };
-/**
- * What the Onboarding checklist (#958) needs and no other read carries: the server's own
- * working directory, offered as the one-click first project.
- *
- * Both fields are null where adding projects is not wired (the relay), so a public host
- * never discloses its filesystem layout.
- */
-export interface OnboardingSuggestion {
-    /** The server's working directory, or null when it cannot be offered: the home folder is where a service runs, not a project. */
-    cwd: string | null;
-    /** The project id for {@link cwd} when it is already registered, else null. */
-    cwdProjectId: string | null;
-    /** Whether this computer can show a window to pick a folder in: one with no screen, as a server, cannot. */
-    canPickFolder: boolean;
-}
 /**
  * What a Start carries besides its prompt (#1774): the person's picks, handed to the project's
  * `start` hook line as `DRIVER`, `MODEL`, `PUBLISH` and `BASE`. Absent leaves each to the tool the line names.
@@ -117,6 +102,32 @@ export interface StartAgentOptions {
      * start is forwarded, so the machine starts an ordinary local run and does not relay onward.
      */
     machine?: string;
+    /**
+     * The repos a session with no project has as context, by their folders on this computer: each is
+     * copied into the session's folder. Refused for a project, which works in its own checkout.
+     */
+    repos?: string[];
+    /**
+     * The account at the git host this session works as, by its login: one of the accounts the
+     * computer the run goes to has there. Absent, the one that computer's runs use. The run's record
+     * keeps it, and a resume goes on as it.
+     */
+    account?: string;
+    /**
+     * The agent the session is on, by its id (`~/.openagent/agents/<id>.json`): its skills and
+     * accounts. Absent, the default agent. The run's record keeps it, and a resume goes on with it.
+     */
+    agent?: string;
+    /** Skills the session gets on top of its agent's, by name: the "Skills" menu's picks for this session. Absent, none. */
+    skillsOn?: string[];
+    /** Skills of its agent's the session does not get, by name. Absent, none. */
+    skillsOff?: string[];
+    /**
+     * Which of the project's own skills stay in the session's checkout: `none`, or their names.
+     * Absent, every one. Refused for a session with no project. The run's record keeps these three,
+     * and a resume goes on with them.
+     */
+    projectSkills?: 'none' | string[];
 }
 /**
  * The outcome of a Start attempt (#345): the id of the run the project's start hook began, or why

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

@@ -0,0 +1,63 @@
+import { type AgentAccounts, type AgentRecord } from '@openagt/agent-data';
+import { type AccountResult } from './accounts.js';
+import { type AgentLoginsOn } from '../dashboard/logins-sync.js';
+export type { AgentAccounts, AgentRecord } from '@openagt/agent-data';
+export type { AgentLoginsOn } from '../dashboard/logins-sync.js';
+/** One skill an agent can be given. */
+export interface AgentSkillChoice {
+    name: string;
+    /** The one line the skill's text says of itself. */
+    description: string;
+}
+export interface AgentsView {
+    /** Every agent, the default first. */
+    agents: AgentRecord[];
+    /** The skills to pick from, in groups: the default agent's first, then the catalogue's. */
+    skills: {
+        title: string;
+        skills: AgentSkillChoice[];
+    }[];
+    /** OpenAgent's GitHub accounts on this computer. */
+    github?: {
+        accounts: string[];
+    };
+    /** The Claude accounts of the Permissions page, by id and name. */
+    claude: {
+        id: string;
+        name: string;
+    }[];
+    /** The Codex accounts, the same way. */
+    codex: {
+        id: string;
+        name: string;
+    }[];
+}
+/** Every agent, and what one can be given. (`onAgents` names the runs' list already.) */
+export declare function onAgentsList(): Promise<AgentsView>;
+/** What the page sends to save an agent: a new one has no id yet. */
+export interface AgentChange {
+    id?: string;
+    name: string;
+    skills: string[];
+    accounts: AgentAccounts;
+    /** Whether its sessions get the project's own skills. */
+    projectSkills: boolean;
+}
+/**
+ * Save an agent: a new one under the id its name gives, an existing one under its own. The name
+ * must give an id, every skill must be one this computer carries, and every account one it knows;
+ * else nothing is written and the reason is said.
+ */
+export declare function sendSaveAgent(change: AgentChange): Promise<({
+    ok: true;
+    id: string;
+} | {
+    ok: false;
+    error: string;
+}) & Partial<AccountResult>>;
+/** How the agents' GitHub accounts stand on each device of the person's. A server copies to no device: none. */
+export declare function onAgentLogins(): Promise<AgentLoginsOn[]>;
+/** Copy the agents' GitHub accounts to every device again, now: the press for one that failed. */
+export declare function sendCopyAgentLogins(): Promise<AccountResult>;
+/** Remove an agent; the default agent stays. */
+export declare function sendRemoveAgent(id: string): Promise<AccountResult>;

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

@@ -0,0 +1,35 @@
+/** Data that is not backed up. */
+export interface BackupGap {
+    /** The person's own folder, or one shared project's data. */
+    kind: 'personal' | 'project';
+    /** The project, for a shared project's data. */
+    projectId?: string;
+    /** The project's name, for a shared project's data. */
+    project?: string;
+    /** The repository it syncs with, as shown: `github.com/me/agent`. */
+    address: string;
+    /** The repository's page, when it has one. */
+    url?: string;
+    /** The git host it is sent to. */
+    host: string;
+    /** Changes made here that wait, when they can be counted. */
+    waiting?: number;
+}
+export interface BackupView {
+    gaps: BackupGap[];
+}
+/** Everything not backed up now. OpenAgent's accounts that could back it up are the git hosts' own read (`onGitHosts`). */
+export declare function onBackup(): Promise<BackupView>;
+/**
+ * Back up `gap` as `login`, one of OpenAgent's accounts at its host, from now on: what waited is
+ * sent now. A send the repository refuses leaves it as it was, the reason said.
+ */
+export declare function sendBackUpAs(gap: {
+    kind: 'personal' | 'project';
+    projectId?: string;
+}, login: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;

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

@@ -23,7 +23,7 @@ export type CopiedView = {
     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. */
+/** What this device keeps from the person's computers, without how full each is: what a computer compares its own with. A device that is no server keeps git hosts' accounts alone. */
 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

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

@@ -0,0 +1,41 @@
+/** A repository at a git host, not looked for on this computer. */
+export interface HostedRepo {
+    /** `<host>/<owner>/<name>`: what a clone is asked for. */
+    address: string;
+    url: string;
+    private: boolean;
+    description?: string;
+    /** Why it is listed: the account it is one of, or the owner the person named. */
+    from: string;
+}
+/** How old the kept lists may be before a read asks the hosts again, behind the answer. */
+export declare const HOSTED_MAX_AGE_MS: number;
+/** How long a first read waits for the hosts before it answers with nothing yet. */
+export declare const HOSTED_FIRST_WAIT_MS = 1500;
+/** What a read answers: the lists as kept, and whether the hosts are being asked now. */
+export interface HostedRead {
+    repos: HostedRepo[];
+    loading: boolean;
+}
+/** What a listing is asked through: the host's package, and OpenAgent's accounts and the person's owners. */
+export declare const hostedWiring: {
+    run: (host: string, args: string[]) => Promise<{
+        ok: true;
+        output: unknown;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    hosts: () => Promise<import("./send-as.js").SendAsHost[]>;
+    owners: () => Promise<string[]>;
+    now: () => number;
+};
+/**
+ * The hosts' repositories as kept. The first read waits {@link HOSTED_FIRST_WAIT_MS} at most, and
+ * then says they are still being read; a read of old lists answers them and asks again behind.
+ */
+export declare function readHosted(): Promise<HostedRead>;
+/** Ask the hosts again now, and answer what they listed: after the person named another owner. */
+export declare function refreshHosted(): Promise<HostedRepo[]>;
+/** Forget the kept lists: for a test. */
+export declare function forgetHosted(): void;

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

@@ -1,7 +1,7 @@
 export { onAgents, onStartedName, onModuleAgents, onAgent, onAgentsDoing, onDocs, onQueue, onOverview, onRecentAgents, onInterventions, onActivity, onDashboard, onGitHostHome, onRepositoryOffer, onGitStatus, onProjectFiles, onRetainedWorktrees, onAgentWorktree, onAgentMainBranch, onAgentHandoff, onBridgeQuestion, onBridgeStatus, onBridgeToken, onBridgeEvents, onBridgeAnswer, onBridgeBrowser } from './reads.js';
 export { sendStop, sendChoice, sendBridgeAnswer, sendBridgeAnswerCancel, sendBridgeBrowser, sendMessage, sendStart, sendOpenInApp, sendRemoveWorktree, sendDeleteAgent, sendOpenPullRequest, sendPush, sendMergeBranch, sendMerge, sendCreateRepository } from './control.js';
 export { streamAgentEvents, type LiveFeedEvent, type PartialMessage, type StreamSync } from './events.js';
-export { onProjects, sendAddProject, sendStartedAgain, onCloneTarget, sendAddProjectFromAddress, sendRemoveProject, sendShareRecords, sendPickProjectDirectory, onOnboarding, onCommands, onStartBranches, onStartCheck, onCloneCheck, type ProjectLauncher } from './projects.js';
+export { onProjects, sendAddProject, sendStartedAgain, onCloneTarget, sendAddProjectFromAddress, sendRemoveProject, sendShareRecords, sendPickProjectDirectory, onRepos, sendAddRepoFolder, onCommands, onStartBranches, onStartCheck, onCloneCheck, type ProjectLauncher } from './projects.js';
 export { onPreferences, savePreferences, patchPreferences, onProjectPresets, saveProjectPresets, onEditors, type SavePreferencesResult, type PatchPreferencesResult, } from './preferences.js';
 export { type EditorInfo } from '../dashboard/open-in-app.js';
 export { onQuota } from './quota.js';
@@ -11,7 +11,8 @@ export { onModules, runModuleCommand, runComputerCommand, runComputerCommandOn,
 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, sendForgetGitHostAccount, sendGitHostLogin, sendGitHostInstall, onAgentState, sendAgentFix, onProjectAccounts, sendProjectAccounts, type GitHostsView, type GitHostRow, type GitHostAccount, type GitHostProvider, type AgentState, type ProjectAccountsView, type ProjectAgentAccounts } from './logins.js';
+export { onAgentsList, sendSaveAgent, sendRemoveAgent, onAgentLogins, sendCopyAgentLogins, type AgentsView, type AgentChange, type AgentSkillChoice, type AgentLoginsOn } from './agents.js';
+export { onGitHosts, sendUseGitHostAccount, sendForgetGitHostAccount, sendGitHostLogin, sendGitHostInstall, onAgentState, sendAgentFix, type GitHostsView, type GitHostRow, type GitHostAccount, type GitHostProvider, type AgentState } from './logins.js';
 export { onPersonalFolder, sendSyncPersonalFolder, sendStopSyncingPersonalFolder, type PersonalFolderView } from './personal-folder.js';
 export { onProjectAgentData, type ProjectAgentData, type KeptData } from './project-agent-data.js';
 export { onServerLogins, sendUseLoginsOn, sendAllowLogins, sendSettleLogin, type ServerLoginsView, type ServerLogins, type LoginThere } from './server-logins.js';

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

@@ -47,7 +47,7 @@ export declare const gitHostPackages: {
         error: string;
     }>;
 };
-/** Runs use `login` at `host` from now on; the terminal's own account stays as it is. */
+/** Runs use `login`, one of OpenAgent's own accounts at `host`, from now on. */
 export declare function sendUseGitHostAccount(host: string, login: string): Promise<AccountResult>;
 /**
  * Take an account off at `host`, on this computer: its tool forgets it, and its token goes on
@@ -65,6 +65,8 @@ export declare function sendGitHostLogin(host: string): Promise<{
     ok: false;
     error: string;
 }>;
+/** Give up the login under way at `host`: its tool stops waiting, and the press to add an account is back. */
+export declare function sendStopGitHostLogin(host: string): Promise<AccountResult>;
 /** 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. */
@@ -91,35 +93,3 @@ export declare function onAgentState(driver?: string): Promise<AgentState>;
  * 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/modules.d.ts

@@ -15,9 +15,10 @@ export interface DashboardModule {
 }
 /**
  * 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
+ * there with no project added. Then every module whose pages a registered project shows, with
+ * the projects that show them: 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
  * project's own command. A project that cannot be read contributes nothing.
  */

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

@@ -1,4 +1,37 @@
 import { type Person } from '../dashboard/person.js';
 export type { Person } from '../dashboard/person.js';
-/** The person at this dashboard, for the foot of its sidebar (`readPerson`): another person's, for a page their device opened. */
+/** The person at this dashboard, for the foot of its sidebar and Settings › Profile (`readPerson`): another person's, for a page their device opened. */
 export declare function onPerson(): Promise<Person>;
+/** Call the person `name` in OpenAgent, on every computer of theirs: the picture stays as it was. */
+export declare function sendSavePersonName(name: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Show no picture of the person: their initials instead. */
+export declare function sendRemovePersonPicture(): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/**
+ * Copy the name and picture of GitHub's public profile of `login` into the person's own, once:
+ * read with no login, and never again after this press.
+ */
+export declare function sendSyncPersonFromGitHub(login: string): Promise<{
+    ok: true;
+    changed: boolean;
+    login: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Forget the person's own name and picture: git's name, or this computer's user, again. */
+export declare function sendForgetPerson(): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;