@openagt/dashboard 0.8.0 → 0.9.0

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

@@ -1,94 +0,0 @@
-import { EventStream } from '../event-stream.js';
-import type { FrameworkEvent } from '../events.js';
-import type { AgentMeta } from '../store/index.js';
-import type { StartAgentOptions, StartAgentResult } from './types.js';
-/**
- * The server-side half of "run on a connected device" (#1067). The local daemon holds the saved
- * device's token, so it - not the browser - drives the remote daemon: it POSTs the agent to the
- * remote's `/_relay/start` and then fetch-streams the remote's `/_relay/events` back into a local
- * {@link EventStream}, which the dashboard reads over its normal same-origin `onEvents` channel. So
- * the browser never talks cross-origin and the token never leaves the two daemons (issue #1067 (b)).
- *
- * Authentication is the shared-token cookie (#1051), sent daemon-to-daemon: `Cookie: fw_daemon=<token>` with no
- * `Origin` header. The remote's guard admits a matching cookie without the browser-only `?token=`
- * 302, and its `/_rpc` CSRF check (absent Origin passes) is not even on these raw routes.
- */
-/** Where a relayed agent executes: the remote daemon's origin and its #1051 token. Memory-only. */
-export interface RemoteTarget {
-    url: string;
-    token: string;
-}
-/** The body a relay start forwards to the remote's `/_relay/start`. */
-export interface RelayStartBody {
-    prompt: string;
-    options: StartAgentOptions;
-}
-/**
- * Health-check a saved device (#1072): a cookie'd `GET /_relay/ping`, true on any 2xx, false on a
- * non-2xx, an unreachable host, or the timeout. The token stays in memory for the check only, never
- * persisted, same as {@link startRemoteAgent}. This is how the browser's status dots learn reachable
- * from not: it has the tokens, the daemon does the cross-origin request.
- */
-export declare function pingRemote(target: RemoteTarget): Promise<boolean>;
-/**
- * Start an agent on the remote daemon and return its {@link StartAgentResult} (with the remote's own run
- * id). A non-2xx or a transport failure surfaces as an `ok: false` result the dashboard shows, the
- * same shape a local refusal has, so the caller does not special-case remote errors.
- */
-export declare function startRemoteAgent(target: RemoteTarget, body: RelayStartBody): Promise<StartAgentResult>;
-/**
- * Relay one run-scoped RPC to the device that owns a remote agent (#1067 slice 2). The local daemon
- * holds the device token, so a read/diff/handoff/push/PR for a relayed agent runs ON the device: POST
- * {fn, args} to the remote's /_relay/rpc over the shared-token cookie (#1051) (no Origin), returning the device's
- * result. Throws on an unreachable device or a non-2xx so the caller falls back to its own empty/error
- * shape, the same way a failed local read does.
- */
-export declare function relayRpc(target: RemoteTarget, fn: string, args: unknown[]): Promise<unknown>;
-/**
- * Fetch-stream a remote agent's newline-delimited events into `onEvent` until the remote closes the
- * body, the agent ends, or `cancel()` is called. A 401 (the token was rotated) ends the stream
- * cleanly rather than as an error, so the dashboard sees a normal `done`, not a lost connection.
- * Returns a cancel function; calling it aborts the fetch and releases the reader.
- */
-export declare function streamRemoteEvents(target: RemoteTarget, agentId: string, onEvent: (event: FrameworkEvent) => void, onEnd?: () => void): () => void;
-/**
- * The local daemon's live relayed runs (#1067), keyed by the remote agent id. Registering an agent opens
- * an {@link EventStream} the dashboard reads through `onEvents`, fed by {@link streamRemoteEvents}
- * from the remote. This map is where a saved device's token lives daemon-side: in memory, for the
- * run's lifetime.
- *
- * The `targets` map outlives the event pump (#1067 slice 2): a finished remote agent's post-run reads,
- * open-PR and merge still have to reach the device after its event stream has ended, so the device
- * target is kept until {@link dispose} clears it, not dropped when the stream closes.
- *
- * The `metas` map (#1077) holds a local {@link AgentMeta} stub per relayed agent so `onAgents` can show a
- * remote run in the session list and re-open it after a dashboard reload; {@link list} projects it
- * per project. Same lifetime as `targets`: it outlives the event stream and is cleared on dispose.
- */
-export declare class RelayedAgents {
-    private readonly agents;
-    private readonly targets;
-    private readonly metas;
-    /** Open a local stream for a remote agent and start pumping the remote's events into it. */
-    register(agentId: string, target: RemoteTarget, meta: AgentMeta, projectId: string): void;
-    /** The live event stream for a relayed agent, or undefined when this daemon is not relaying it. */
-    get(agentId: string | undefined): EventStream<FrameworkEvent> | undefined;
-    /** The device a relayed agent runs on, kept past the event stream so post-run push/PR still reach it. */
-    target(agentId: string | undefined): RemoteTarget | undefined;
-    /** A project's relayed run stubs (#1077), newest-first, so `onAgents` can surface them in the list. */
-    list(projectId: string): AgentMeta[];
-    /** Fold each relayed event into the agent's list row via the store's own reducer (#1077), so the
-     *  local stub mirrors the device: the terminal status on `end`, the waiting flag while it is parked
-     *  (#785), the driver once its session starts. Events carry no write time, so this stamps its own. */
-    private apply;
-    /** Close a relayed agent's event stream (not its target). Idempotent. */
-    private endStream;
-    /** Stop every pump, close every stream, and forget every device target + list stub, on daemon shutdown. */
-    dispose(): void;
-}
-/**
- * Fold one relayed event into the memory-only row of a run on a device: what the device's own
- * card would say, kept here because that card is on the device. The events are the ones a run's
- * diary yields: the agent's session id, its cost, its end.
- */
-export declare function foldRelayedEvent(meta: AgentMeta, event: FrameworkEvent, at: string): AgentMeta;

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

@@ -1,102 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { FrameworkEvent } from '../events.js';
-import type { PreferencesStore } from '../registry.js';
-import type { QuotaSource } from './quota.js';
-import type { ModelsSource } from './models.js';
-import type { BridgeBrowserOwner } from '../bridge-browser.js';
-import type { ProjectErrorsReader } from '../project-errors.js';
-import type { AddProjectResult, StartAgentOptions, StartAgentResult } from './types.js';
-import type { AgentMeta } from '../store/index.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). */
-export type AddProjectHandler = (path: string) => AddProjectResult | Promise<AddProjectResult>;
-/** Resolve an agent to its live event stream: the relay feeds `onEvents` from its own in-memory stream
- * rather than a file on disk (#426), and the daemon feeds an agent it is relaying from a device (#1067).
- * Returns undefined when there is no in-memory stream, so `onEvents` falls back to tailing the log. */
-export type EventsSource = (projectId: string, agentId?: string) => AsyncIterable<FrameworkEvent> | undefined;
-/** Look up the device a relayed agent (#1067) executes on, or undefined for an ordinary local agent. The
- *  daemon wires this from its live relayed-agent map; a run-scoped RPC uses it to forward a remote agent's
- *  read/steer/handoff to that device instead of resolving a (nonexistent) local checkout. */
-export interface RemoteAgents {
-    target(agentId: string | undefined): {
-        url: string;
-        token: string;
-    } | undefined;
-    /** A project's relayed run stubs (#1077), so `onAgents` can show a remote agent in the list and re-open it after a reload. */
-    list(projectId: string): AgentMeta[];
-}
-/**
- * What every RPC acts through.
- *
- * Every field is required (D3). These used to be optional because three hosts served this same
- * surface — the daemon, a per-session foreground dashboard, and a public relay — each wiring a
- * different subset, so every RPC carried an "absent capability" branch and the client rendered a
- * degradation matrix. There is one host now, and it wires all of it.
- */
-export interface DashboardContext {
-    startAgent: StartAgentHandler;
-    addProject: AddProjectHandler;
-    /** The in-memory event stream for an agent relayed from a connected device (#1067), else undefined. */
-    eventsSource: EventsSource;
-    /** The relayed-agent lookup (#1067 slice 2), so a run-scoped RPC can tell a local agent from one
-     *  running on a connected device and forward the call there. */
-    remote: RemoteAgents;
-    /** The user-preferences store (#410), over the registry file. */
-    preferences: PreferencesStore;
-    /** The quota source behind the usage panel (#533). */
-    quota: QuotaSource;
-    /** Which models each coding agent offers, for the agent and model menu. */
-    models: ModelsSource;
-    /** What a project currently suffers from (#1500): the daemon's error state, read per project. */
-    projectErrors: ProjectErrorsReader;
-    /** The daemon's own bridge browser (#1332): status, and show/hide/restart on request. */
-    bridgeBrowser: BridgeBrowserOwner;
-}
-/**
- * CSRF guard for the state-changing RPCs. A browser attaches an `Origin`
- * header to every cross-site request, so we reject any POST whose Origin is not this
- * same server (or a loopback host) — otherwise a page on `evil.com` could `fetch()` the
- * localhost dashboard and start or steer a run. An absent Origin means a non-browser caller
- * (curl, the test suite) with no ambient session to abuse, so it passes. Lives here beside
- * the mount, its only caller.
- */
-export declare function isSameOriginRequest(req: IncomingMessage): boolean;
-/**
- * DNS-rebinding guard, the other half of the CSRF check above. A page on `evil.com` whose DNS
- * re-answers as `127.0.0.1` is *same-origin* with this server as far as the browser is concerned,
- * so its `fetch()` takes the passing branch of {@link isSameOriginRequest} — and every RPC behind
- * the mount, `sendStart` included, is reachable from a page the user merely visited.
- *
- * The `Host` header is what still gives the attacker away: it carries the name the browser was
- * asked for (`evil.com`), not the address it resolved to. So when we are bound to loopback, the
- * only `Host` a real user's browser can send is a loopback one (or the bound address itself) —
- * anything else is a rebound name and is rejected. An absent `Host` is rejected too when we are
- * enforcing: HTTP/1.1 requires it, and every browser sends it.
- *
- * A non-loopback bind (`--host`, #1051) is reached by a hostname we cannot predict, so there is
- * no allowlist to check against; that case gates behind the shared daemon token instead. Hosts
- * that never pass a bind host at all (the relay, which serves a public domain) are unaffected.
- */
-export declare function isExpectedHost(req: IncomingMessage, boundHost: string | undefined): boolean;
-/** Where the dashboard's RPCs live. One prefix, so the static handler can decline it by path. */
-export declare const RPC_PREFIX = "/_rpc";
-/**
- * Mount the dashboard's RPC surface (#405) on the daemon's `node:http` server: `POST /_rpc/<name>`
- * for the calls, `GET /_rpc/events` for the live stream. It runs in the daemon process, so
- * `sendStart` reaches the daemon's own `startAgent` through the wired {@link DashboardContext}.
- *
- * Cross-origin POSTs are rejected (CSRF: a page on evil.com must not steer or start a session), as
- * are requests carrying someone else's `Host` when we are bound to loopback (DNS rebinding: the
- * same page must not reach us by pointing its own name at `127.0.0.1`). Pass `opts.host` — the
- * address the server is bound to — to enable that second check. Returns whether the request was
- * the RPC surface's.
- *
- * This replaced Telefunc (F3), which required a build-time transform over every `.telefunc.ts`
- * file, a registration table pinning each RPC to the client-baked key of the *dashboard* source
- * path it was re-exported from, and a request-context indirection for wiring that never varied
- * per request. What it bought over this was type-safety across a package boundary that A7 removed.
- */
-export declare function makeRpcMount(context: DashboardContext, opts?: {
-    host?: string;
-}): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;

package/dist/widget-types/src/dashboard/run-inbox.d.ts

@@ -1,30 +0,0 @@
-import { type InboxLine } from 'agent-driver';
-/**
- * What a person says to a run (#1774): their own words, or their answer to the question the run
- * stopped on. The daemon runs no agent, so the line reaches the run through what the run's tool
- * reads: the inbox file in the run's checkout while the run works, the project's `resume` hook
- * line once it has ended. The framework names no tool in either.
- */
-/**
- * The inbox of a run, in its checkout's `.the-framework/`: the file agent-driver's session reads
- * when a turn ends, one JSON line per message or answer. The run's tool hands the session the
- * same path.
- */
-export declare const RUN_INBOX_FILE = "inbox.jsonl";
-/** What a write to a run came to: done, or why not, in words the surface shows. */
-export type SteerResult = {
-    ok: true;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * Hand one line to a run of the project at `cwd`. A run that is working takes it from its inbox
- * when its turn ends. A run that has ended (done, stopped, failed, or waiting on its question) is
- * continued through the project's `resume` hook. A run that ends while the line is on its way
- * would leave it in an inbox nobody reads, so the run is looked at again after the write, and
- * what is still in the inbox then is taken back and resumes the run instead.
- */
-export declare function sayToRun(cwd: string, agentId: string, line: InboxLine, deps?: {
-    isWorking?: (cwd: string, agentId: string) => Promise<boolean>;
-}): Promise<SteerResult>;

package/dist/widget-types/src/dashboard/scheduler-state.d.ts

@@ -1,64 +0,0 @@
-import type { ProjectSummary } from './projects.js';
-/** The file the scheduler keeps its state in, at the project's root; per user, hidden from git by the tool. */
-export declare const SCHEDULER_STATE_FILE = ".agent-scheduler/state.json";
-/** What the last tick decided for one scheduled command, one line for a person. */
-export interface SchedulerDecision {
-    command: string;
-    outcome: string;
-    /** The run's id when the tick started one: the same id the agent's record and checkout carry. */
-    run?: string;
-}
-/** The last tick as the state file remembers it. */
-export interface SchedulerTick {
-    /** ISO timestamp. */
-    at: string;
-    decisions: SchedulerDecision[];
-    /** Why the tick decided nothing, when it could not. */
-    note?: string;
-}
-/** One command of the project's schedule, as the scheduler's last tick read it, with this machine's switch. */
-export interface SchedulerCommand {
-    command: string;
-    /** How often at most, as written (`1d`). */
-    every?: string;
-    /** The check, when the line has one. */
-    when?: string;
-    /** Whether it runs on this machine: the machine's switch, else what the line says. */
-    on: boolean;
-}
-/** A project's scheduler as the card shows it. */
-export interface SchedulerState {
-    /** Whether the state file exists and parses: a project without it has no scheduler set up. */
-    present: boolean;
-    /** Whether ticks start agents. */
-    on: boolean;
-    /** Whether the scheduler's process outlives the dashboard that started it. */
-    keepAlive: boolean;
-    /** Whether the scheduler's own process is alive on this machine. */
-    running: boolean;
-    /** The model every run starts on. */
-    model?: string;
-    /** How far past the quota boundary this project's unattended runs may start, in percentage points. */
-    spendOffset?: number;
-    lastTick?: SchedulerTick;
-    /** The schedule's commands with their switches; empty until the scheduler has ticked once with a schedule. */
-    commands: SchedulerCommand[];
-}
-export interface ProjectScheduler extends SchedulerState {
-    projectId: string;
-    projectName: string;
-}
-/**
- * Read one project's scheduler state. `isAlive` is the process probe; injectable so a test can
- * decide what "running" means without holding a process.
- */
-export declare function readSchedulerState(cwd: string, isAlive?: (pid: number) => boolean): Promise<SchedulerState>;
-/** Every registered project's scheduler, one row per project in registry order, a failing read as not set up. */
-export declare function collectSchedulers(projects: ProjectSummary[], read?: (cwd: string) => Promise<SchedulerState>): Promise<ProjectScheduler[]>;
-/**
- * The spend offset the usage panel draws (#960), read off the projects' schedulers: the loosest
- * one, since it is the one that lets unattended work spend the furthest; `undefined` when no
- * scheduler names one. The panel's slider writes it back through each project's `offset` hook,
- * so the schedulers agree unless one was set by hand.
- */
-export declare function loosestSpendOffset(states: readonly SchedulerState[]): number | undefined;

package/dist/widget-types/src/dashboard/tickets.d.ts

@@ -1,28 +0,0 @@
-import { type Ticket, type TicketDetail, type TicketsMeta } from '@gemstack/skill-tickets';
-export type { TicketsMeta, TicketGithubLink } from '@gemstack/skill-tickets';
-/**
- * A ticket as the dashboard shows it: the `tickets` skill's row, with the holder of its claim
- * resolved against this project's own agents (#1748). A lock names an agent id — the same id
- * the agent's checkout is named with — so a claim the daemon minted, or an agent on this machine
- * made with the `tickets` command, resolves to the agent's page and its session name; a holder
- * this project has no record of (another machine's agent, a cloud session's branch name) is
- * shown as written.
- */
-export interface WorkspaceTicket extends Ticket {
-    /** The agent whose id the lock names, when it is one of this project's: its id and, once named, its session name. */
-    lockedByAgent?: {
-        id: string;
-        name?: string;
-    };
-}
-/** One ticket with its entire markdown, for its own page. */
-export interface WorkspaceTicketDetail extends WorkspaceTicket, TicketDetail {
-}
-/** The project's tickets, off the skill's checkout under `.branches/agent-data`, holders resolved. */
-export declare function readTickets(cwd: string): Promise<WorkspaceTicket[]>;
-/** One ticket by filename, full text included; `null` when there is no such ticket. */
-export declare function readTicket(cwd: string, file: string): Promise<WorkspaceTicketDetail | null>;
-/** Whether the project has any ticket at all (#958): a listing, for the onboarding checklist's poll. */
-export declare function hasTickets(cwd: string): Promise<boolean>;
-/** When the tickets last caught up with GitHub (#1208), or `{}` when nothing has recorded it. */
-export declare function readTicketsMeta(cwd: string): Promise<TicketsMeta>;

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

@@ -1,99 +0,0 @@
-import type { LinkedPr } from './pull-requests.js';
-/** The outcome of removing a retained worktree (#737). */
-export type RemoveWorktreeResult = {
-    ok: true;
-} | {
-    ok: false;
-    error: string;
-};
-/** The outcome of deleting a session — its records and worktree (#1032). */
-export type DeleteAgentResult = {
-    ok: true;
-} | {
-    ok: false;
-    error: string;
-};
-/** The outcome of an add-project attempt (#396): registered, or was already, or why not. */
-export type AddProjectResult = {
-    ok: true;
-    alreadyActivated: boolean;
-} | {
-    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. */
-    cwd: string | null;
-    /** The project id for {@link cwd} when it is already registered, else null. */
-    cwdProjectId: string | null;
-}
-/**
- * What a Start carries besides its prompt (#1774): the person's picks, handed to the project's
- * `start` hook line as `DRIVER` and `MODEL`. Absent leaves each to the tool the line names.
- */
-export interface StartAgentOptions {
-    /** The model to run on. */
-    model?: string;
-    /** Which coding agent the run is on: `claude-code` or `codex`. */
-    driver?: string;
-    /**
-     * The follow-up's prompt: once the run ends done with a pull request, a fresh agent works its
-     * branch from it before the request merges. The launcher's "Post-merge cleanup" box.
-     */
-    then?: string;
-    /**
-     * Run this session on a connected device (#1067): the local daemon relays the start to the remote
-     * daemon at `url` (authenticating with `token` as the `fw_daemon` cookie) and streams its events
-     * back into the local agent view. The device `label` rides along (memory-only, like `url`/`token`) so
-     * the local session list + notice can show which device the agent is on after a reload (#1077).
-     * Memory-only relay config the dashboard sets at submit time from a saved device. NEVER persisted to
-     * Preferences or the registry: a device token is a per-browser secret. Absent = run locally.
-     * Stripped before the start is forwarded, so the remote starts an ordinary local run and does not
-     * relay onward.
-     */
-    remote?: {
-        url: string;
-        token: string;
-        label?: string;
-    };
-}
-/** The outcome of a Start attempt (#345): the id of the run the project's start hook began, or why there is none. */
-export type StartAgentResult = {
-    ok: true;
-    agentId: string;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * Where a session is working (#798): its checkout, its branch, and what it is holding. Read by
- * the dashboard so a session's action bar can say which worktree it has, rather than leaving the
- * user to infer it from an agent id.
- *
- * Only what is true of the run: once its checkout is gone there is no tree to be clean or dirty,
- * so {@link checkout} is absent and the branch is the one the run recorded.
- */
-export interface AgentWorktree {
-    /** The run's own checkout while it exists. */
-    checkout?: {
-        /** Absolute path of the checkout. */
-        path: string;
-        /** Uncommitted changes present in it. */
-        dirty: boolean;
-        /** Size on disk, bytes. Only read once nothing is writing to it, and best-effort even then. */
-        sizeBytes?: number;
-    };
-    /** The branch the run's work is on: its checkout's while it has one, else the one it recorded. */
-    branch?: string;
-    /** The PR opened for this run's branch (#809), when there is one. */
-    pr?: LinkedPr;
-    /** The PR is not known yet, rather than absent (#1028): the lookup is still running. */
-    prPending?: boolean;
-}

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

@@ -1,14 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { type ProjectsProvider } from './projects.js';
-import { type ProjectWidget } from '../project-widgets.js';
-/** Where widget files are served: `/_widgets/<project id>/<package>/<file>`, each segment encoded. */
-export declare const WIDGETS_PREFIX = "/_widgets";
-/** The URL a widget's module is served at from one project. */
-export declare function widgetUrl(projectId: string, widget: Pick<ProjectWidget, 'package' | 'entry'>): string;
-/**
- * Serve one widget file (#1774): the project must be registered, the package must be a widget of
- * that project, and the file must sit inside the widget module's own directory. Anything else is a
- * 404, never a fallback: a widget URL is asked for by the dashboard's loader, not typed by a person.
- * Served as `no-cache`, since a widget is rebuilt in place under the same name.
- */
-export declare function serveWidgetFile(req: IncomingMessage, res: ServerResponse, pathname: string, projects?: ProjectsProvider): Promise<void>;

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

@@ -1,53 +0,0 @@
-import { type ProjectsProvider } from '../dashboard/projects.js';
-import type { DashboardContext, EventsSource, RemoteAgents } from '../dashboard/rpc-serve.js';
-import type { PreferencesStore } from '../registry.js';
-import type { QuotaSource } from '../dashboard/quota.js';
-import type { ModelsSource } from '../dashboard/models.js';
-import type { ProjectErrorsReader } from '../project-errors.js';
-import type { BridgeBrowserOwner } from '../bridge-browser.js';
-/** Wire the dashboard's capabilities. The daemon calls this once at start-up; a test calls it per case. */
-export declare function setDashboardContext(context: DashboardContext): void;
-/** The projects every RPC resolves a project id against: the global registry. */
-export declare function contextProjects(): ProjectsProvider;
-/** The workspace path for a project id, or undefined when no project has that id. */
-export declare function resolveProjectPath(projectId: string): Promise<string | undefined>;
-/**
- * The checkout a call should act on: a live agent's own worktree when `agentId` names one (#738/#749),
- * else the project root. Since #736 an agent reads and writes inside its worktree — its event log,
- * its control log, its working tree — so anything addressed at a *run* has to resolve here, not
- * at the project path, or it reads an empty log and steers an agent that is not listening. The
- * resolution itself (and its #766 first-seconds subtlety) lives in the store's
- * {@link resolveAgentCheckout}, shared with the daemon; this adds only the project-id lookup.
- */
-export declare function resolveAgentPath(projectId: string, agentId?: string): Promise<string | undefined>;
-/**
- * The in-memory {@link EventsSource} (#426). It answers only for a run this daemon is relaying
- * from a connected device (#1067) — such a run has no diary on this machine, since it works in a
- * checkout over there — and returns undefined for an ordinary local run, whose diary `onEvents`
- * tails off disk.
- */
-export declare function contextEventsSource(): EventsSource;
-/**
- * The relayed-agent lookup (#1067 slice 2). A run-scoped RPC uses it to tell an ordinary local agent
- * (resolve a local checkout) from one running on a connected device (forward the call there).
- *
- * The one accessor with a default rather than a throw, because "unwired" has a real meaning here:
- * a call arriving over `/_relay/rpc` is the *device* side of the relay, and the agent it names is
- * local to that device. Forwarding it onward would be a loop, so the honest answer there is that
- * nothing is relayed from here.
- */
-export declare function contextRemote(): RemoteAgents;
-/** The user-preferences store (#410), over the registry file. */
-export declare function contextPreferences(): PreferencesStore;
-/** The quota source behind the usage panel (#533). */
-export declare function contextQuota(): QuotaSource;
-/** Which models each coding agent offers. */
-export declare function contextModels(): ModelsSource;
-/** What a project currently suffers from (#1500), as the daemon's background jobs last recorded it. */
-export declare function contextProjectErrors(): ProjectErrorsReader;
-/** The daemon's own bridge browser (#1332). */
-export declare function contextBridgeBrowser(): BridgeBrowserOwner;
-/** The daemon's own `startAgent`, so a start from the dashboard is the same start the CLI makes. */
-export declare function contextStartAgent(): DashboardContext['startAgent'];
-/** Install + register a repo (#433), which only the daemon can do. */
-export declare function contextAddProject(): DashboardContext['addProject'];

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

@@ -1,108 +0,0 @@
-import { type SteerResult } from '../dashboard/run-inbox.js';
-export type { SteerResult };
-import { type OpenTarget, type OpenResult } from '../dashboard/open-in-app.js';
-import type { BridgeBrowserAction } from '../bridge-browser.js';
-import { type HandoffResult } from '../dashboard/agent-handoff.js';
-import type { DeleteAgentResult, RemoveWorktreeResult, StartAgentOptions, StartAgentResult } from '../dashboard/types.js';
-/**
- * The key every action on one run locks under (`agent-locks.ts`): a Remove, a Delete and an Open
- * PR on the same run each run their own git; serialized, whichever runs second finds the state
- * the first one left and acts on that. The project and the run's id, not the checkout's path:
- * the path is the branches provider's to know, and an Open PR on a run whose checkout is gone
- * still locks the run.
- */
-export declare function agentLockKey(cwd: string, agentId: string): string;
-/**
- * Stop a live agent (the Stop button): SIGINT to the process the run's own card names, when it is
- * this machine's and alive. The card is the file the dashboard shows the run from, and its pid is
- * whoever runs the agent; the framework names no tool. Nothing else: a run without a live pid
- * here has nothing to stop.
- */
-export declare function sendStop(projectId: string, agentId?: string): Promise<void>;
-/**
- * Answer the question a run stopped on (#304, #1774). `pick` is one option id, or the chosen
- * subset of a multi-select; the answer handed to the run is the chosen labels, read off the
- * question as the run's own diary holds it, so only what the agent offered can be answered.
- */
-export declare function sendChoice(projectId: string, id: string, pick: string | string[], agentId?: string): Promise<SteerResult>;
-/**
- * Queue the user's pick for the question a Claude web session is parked on (#1237).
- *
- * Not a line for a run like {@link sendChoice}: a cloud agent has no run here to hand it to, so
- * the pick goes to the bridge store, where the browser extension collects it, types
- * it into the session's composer and submits. Only labels of the currently parked question are
- * accepted — one, or a multi-select's subset — and the daemon composes the text typed from them,
- * so this can never put arbitrary text in front of another product's agent. Local only, no
- * relay: the bridge lives on the daemon the extension talks to.
- */
-export declare function sendBridgeAnswer(sessionId: string, labels: string[]): Promise<{
-    ok: boolean;
-    error?: string;
-}>;
-/** Withdraw a queued bridge answer (#1237). A no-op once the extension has delivered it. */
-export declare function sendBridgeAnswerCancel(sessionId: string): Promise<void>;
-/**
- * Say something to a run (#714, #1774): the person's own words, the next prompt of the same
- * conversation. A run that is working takes them when its turn ends; an ended run is resumed
- * with them. Empty messages are dropped.
- */
-export declare function sendMessage(projectId: string, text: string, agentId?: string): Promise<SteerResult>;
-/**
- * Remove a retained worktree (#737). An agent that failed or was stopped keeps its checkout so you
- * can inspect it; this is the explicit cleanup for one, since nothing removes them on a timer.
- *
- * The checks and the removal are {@link removeProjectWorktree}'s, shared with the CLI's removal
- * path (#982) so the surfaces cannot drift again; this adds only the agent lock around them.
- */
-export declare function sendRemoveWorktree(projectId: string, agentId: string): Promise<RemoveWorktreeResult>;
-/**
- * Delete a session (#1032): remove it from the dashboard, records and all — the sibling of
- * {@link sendRemoveWorktree}, and the one destructive-of-history action, so its surface confirms
- * first. The checks, the worktree removal and what it leaves behind (the branch and its
- * commits) are all {@link deleteProjectAgent}'s; this adds only the agent lock around them.
- */
-export declare function sendDeleteAgent(projectId: string, agentId: string): Promise<DeleteAgentResult>;
-/**
- * Start a run in the project (#405, #1774): the project's own `start` hook line, reached through
- * the daemon's wired `startAgent` (which relays to a connected device when the options name
- * one). Answers the id of the run the hook began, or why there is none: a project without the
- * line cannot start a run from here.
- */
-export declare function sendStart(projectId: string, prompt: string, options?: StartAgentOptions): Promise<StartAgentResult>;
-/**
- * Open a project in the OS file manager or an editor (#490). Localhost-only: the daemon
- * spawns a local command against the project's own registered path. A public host has no
- * local path to resolve, so it returns an error rather than spawning anything.
- *
- * With a `agentId` it opens that session's own checkout instead (#798) — the whole point of
- * opening it is to look at what the agent is doing, which is not in the project's tree.
- */
-export declare function sendOpenInApp(projectId: string, target: OpenTarget, agentId?: string): Promise<OpenResult>;
-/**
- * Open a PR for a finished session's branch (#799): the project's branches provider pushes it
- * first if the remote lacks it (#1774).
- *
- * The title and body come from what the agent already recorded: the branch the agent named its
- * work with and the intent the user asked for. Nothing new is invented and nothing extra is asked
- * of the user, which is the point of "offer the next step rather than describe it".
- */
-export declare function sendOpenPullRequest(projectId: string, agentId: string): Promise<HandoffResult>;
-/**
- * The user's Push action (#1820): push a finished run's branch, the last step where the project has
- * no git host package. Under the agent lock, as Open PR is, so the push cannot race a Remove.
- */
-export declare function sendPush(projectId: string, agentId: string): Promise<HandoffResult>;
-/**
- * The user's Merge action (#1391): merge a finished run's open pull request, directly. A run
- * that is still working has no Merge: its agent publishes its own work, and the button comes
- * with the ended view.
- */
-export declare function sendMerge(projectId: string, agentId: string): Promise<HandoffResult>;
-/**
- * Ask the daemon's bridge browser to show its window (for the one-time sign-in), hide it again,
- * or restart (#1332). Anything else is refused; a browser that is not running ignores show/hide.
- */
-export declare function sendBridgeBrowser(action: BridgeBrowserAction): Promise<{
-    ok: boolean;
-    error?: string;
-}>;

package/dist/widget-types/src/dashboard-rpc/devices.d.ts

@@ -1,8 +0,0 @@
-/** One device to health-check: its profile id plus the origin and token to reach it with. */
-export interface DeviceCheck {
-    id: string;
-    url: string;
-    token: string;
-}
-/** Ping each saved device and map its id to whether it answered (#1072). Bad entries are dropped. */
-export declare function checkDevices(devices: DeviceCheck[]): Promise<Record<string, boolean>>;