@openagt/dashboard 0.8.0 → 0.9.0

package/dist/widget-types/dashboard/lib/rpc.d.ts

@@ -1,31 +0,0 @@
-import type { LiveFeedEvent } from '../../src/dashboard-rpc/index.js';
-/**
- * A typed stub for one RPC. `F` is the implementation's own signature, so the call is checked
- * against the real thing and a rename that misses a caller is a type error rather than a 404.
- *
- * Arguments and return value go through JSON, which is what they always did — the wire has no
- * opinion about `Date` or `Map` here because none of these RPCs pass one.
- */
-export declare function rpc<F extends (...args: never[]) => unknown>(name: string): (...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>>;
-/**
- * A live feed of one agent's events.
- *
- * The contract the dashboard relies on, unchanged from the Channel it replaced: `listen` per
- * event, and `onClose` telling a clean end (the server is done — an unknown project, a finished
- * relay stream) apart from a dropped one (retry with backoff). That distinction is the whole
- * reason the feed can say "the daemon is not answering" instead of looking like a quiet agent.
- */
-export interface EventChannel {
-    listen(onEvent: (event: LiveFeedEvent) => void): void;
-    onClose(onClosed: (err?: Error) => void): void;
-    close(): void;
-}
-/**
- * Subscribe to an agent's events over SSE. Rejects when the subscription itself fails, which the
- * caller retries; a stream that opens and later dies closes with an error instead.
- *
- * Read with `fetch` rather than `EventSource` because `EventSource` reconnects on its own
- * schedule, which would fight the caller's backoff and erase the clean-vs-dropped distinction —
- * it reports every end as an error and retries even the ones that meant "done".
- */
-export declare function openEvents(projectId: string, agentId?: string): Promise<EventChannel>;

package/dist/widget-types/dashboard/lib/use-action.d.ts

@@ -1,25 +0,0 @@
-/**
- * What an action did: `ok` says whether it succeeded, and only then is there a `value`.
- *
- * Said as a pair rather than as "the value, or `undefined` when it did not succeed", because an
- * action that succeeds with nothing to report is not a failure: with the value alone, a `sendStop`
- * that resolves void was indistinguishable from one that threw, and every such caller had to map
- * its success to a stand-in value to tell the two apart.
- */
-export type ActionOutcome<T> = {
-    ok: true;
-    value: Succeeded<T>;
-} | {
-    ok: false;
-};
-/** What is left of an action's result once its own refusal branch is ruled out. */
-type Succeeded<T> = Exclude<T, {
-    ok: false;
-}>;
-export declare function useAction(): {
-    busy: boolean;
-    error: string | null;
-    reset: () => void;
-    run: <T>(fn: () => Promise<T>, fallback?: string) => Promise<ActionOutcome<T>>;
-};
-export {};

package/dist/widget-types/dashboard/lib/use-async.d.ts

@@ -1,39 +0,0 @@
-import { type DependencyList } from 'react';
-/**
- * What a read shows when its deps change, until the new answer lands. By default, nothing: the
- * `initial` value, so one target's data is never shown as another's.
- *
- * - `'previous'`: the last answer, whatever it was for. For a read whose target barely matters
- *   to the eye (the git host page of a project), where blanking would only flicker.
- * - `{ remember: key }`: the last answer read under this key, marked loaded, or nothing when no
- *   answer was. For a page a person goes back and forth between (a run's facts): going back shows
- *   what was read last time at once, and the read is made again all the same, so it is replaced
- *   the moment the fresh answer lands. The key names the target, so no other target's answer is
- *   ever shown.
- */
-export type Keep = 'previous' | {
-    remember: string;
-};
-/** Forget every remembered answer. For tests. */
-export declare function forgetRemembered(): void;
-/**
- * Read once, and again whenever `deps` change.
- *
- * Pass `null` for `load` when there is nothing to read yet (no project selected): the
- * value stays `initial` and no read is made. `load` must close over exactly `deps`.
- */
-export declare function useLoaded<T>(load: (() => Promise<T>) | null, initial: T, deps: DependencyList, keep?: Keep): T;
-/**
- * Read now, again every `everyMs`, and again whenever `deps` change. Polling stops on
- * unmount. `reload` reads immediately, for when a local action means the next tick is
- * too late to wait for.
- *
- * Pass `null` for `load` when there is nothing to read yet. `load` must close over
- * exactly `deps`. `loaded` is false until the first successful read, and again after
- * a dep change — for callers that must tell "not there" from "not read yet".
- */
-export declare function usePolled<T>(load: (() => Promise<T>) | null, initial: T, everyMs: number, deps: DependencyList, keep?: Keep): {
-    value: T;
-    reload: () => void;
-    loaded: boolean;
-};

package/dist/widget-types/dashboard/lib/use-widgets.d.ts

@@ -1,42 +0,0 @@
-import type { LinkAction, WidgetCard, WidgetPage } from '../widget/index.js';
-/** A widget page as the shell mounts it: the page, plus the package it came from and the projects that have it. */
-export interface MountedPage extends WidgetPage {
-    package: string;
-    projects: string[];
-}
-/** A link action as the shell mounts it (#1774): the action, plus the package it came from and the projects that have it. */
-export interface MountedLinkAction extends LinkAction {
-    package: string;
-    projects: string[];
-}
-/** A card as the shell mounts it (#1818): the card, plus the package it came from and the projects that have it. */
-export interface MountedCard extends WidgetCard {
-    package: string;
-    projects: string[];
-}
-/** What the installed widgets bring, once loaded: their pages, their cards and their link actions. */
-export interface MountedWidgets {
-    pages: MountedPage[];
-    /** The Overview's cards, in the order they are drawn: by `order`, then by package name. */
-    cards: MountedCard[];
-    linkActions: MountedLinkAction[];
-    /** True once the widget list was read and every module in it imported or skipped. */
-    loaded: boolean;
-}
-/**
- * What the registered projects' widgets add (#1774), in package order: the pages, a segment two
- * widgets claim going to the first, the cards (#1818), sorted by their order then their package, and the link actions, every one of them, each carrying the
- * package it came from and the projects that have it. `loaded` is false until the widget list has
- * been read and every module in it imported, so the shell can tell "no such page" from "not
- * loaded yet".
- */
-export declare function useWidgets(): MountedWidgets;
-/**
- * The mounted widgets, for any component in the shell (#1774): the shell reads them once with
- * {@link useWidgets} and provides them here, so a page deep in the tree finds the link actions
- * without the shell threading them through every prop. Outside the provider: nothing mounted,
- * not loaded.
- */
-export declare const WidgetsContext: import("react").Context<MountedWidgets>;
-/** The installed widgets' pages and link actions, as the shell mounted them. */
-export declare function useMountedWidgets(): MountedWidgets;

package/dist/widget-types/dashboard/lib/utils.d.ts

@@ -1,3 +0,0 @@
-import { type ClassValue } from 'clsx';
-/** shadcn's class combiner: merge conditional classes, de-duping Tailwind conflicts. */
-export declare function cn(...inputs: ClassValue[]): string;

package/dist/widget-types/dashboard/rpc/widgets.d.ts

@@ -1,4 +0,0 @@
-import type * as impl from '../../src/dashboard-rpc/widgets.js';
-export type * from '../../src/dashboard-rpc/widgets.js';
-export declare const onWidgets: () => Promise<impl.DashboardWidget[]>;
-export declare const runWidgetCommand: (projectId: string, pkg: string, args: string[], command?: string | undefined, acts?: boolean | undefined) => Promise<import("@gemstack/agent-data").PackageCommandResult>;

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

@@ -1,207 +0,0 @@
-import { type ComponentType } from 'react';
-import type { AgentStatus } from '../../src/index.js';
-import type { WidgetCommandResult } from '../rpc/widgets.js';
-export type { WidgetCommandResult, AgentStatus };
-/** A registered project that has the widget's package, as a page gets it. */
-export interface WidgetProject {
-    id: string;
-    name: string;
-}
-/**
- * What a widget page is rendered with. A page reads its sub-path and navigates within itself
- * through {@link WidgetHost.openPage}; the dashboard's own pages reach it the same way, by the
- * link convention below.
- *
- * A link into a project's files (`WidgetLink.href` such as `tickets/2026-01-01_x.md`) opens the
- * mounted page named by its first segment, at `/<segment>/<projectId>/<rest…>`: the path a page
- * gets for it is `[projectId, ...rest]`. So a page that shows one project's file under its own
- * segment is where every such link in the dashboard lands, and the dashboard names no page.
- */
-export interface WidgetPageProps {
-    /** The registered projects whose dependencies include the widget's package, in the registry's order. */
-    projects: WidgetProject[];
-    /** The URL's segments after the page's own, decoded: `/logs/a` gives `['a']`. */
-    path: string[];
-}
-/** A page a widget adds: its own URL segment and its row in the sidebar. */
-export interface WidgetPage {
-    /** The page's URL, `/<segment>`: a lowercase letter, then lowercase letters and digits (never a project's id, which always has a dash). */
-    segment: string;
-    /** The sidebar row's label. */
-    label: string;
-    /** The sidebar row's icon; a generic one when absent. */
-    icon?: ComponentType<{
-        className?: string;
-        'aria-hidden'?: boolean;
-    }>;
-    /** The page itself. */
-    Page: ComponentType<WidgetPageProps>;
-}
-/**
- * A link a dashboard page shows (#1774): the name of some work and where it points. What a
- * {@link LinkAction} is given. The dashboard knows nothing of what the link names; the page that
- * shows it does, and says so in these three fields.
- */
-export interface WidgetLink {
-    /** The link's text: the name of the work. */
-    text: string;
-    /**
-     * Where the link points: a path inside the project's repository (`tickets/2026-01-01_x.md`) or an
-     * absolute URL. Absent for plain text that names work without pointing anywhere.
-     */
-    href?: string;
-    /** How urgent the page says the work is, 0 (only if capacity) to 10 (critical); absent when the page does not say. */
-    priority?: number;
-}
-/** What a link action did: done, or stopped, with the reason the action or its command gave. */
-export type LinkActionResult = {
-    ok: true;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * An action a widget offers on the links dashboard pages show (#1774): one verb, done by the
- * widget package's own command. The dashboard shows it as a button beside any link whose project
- * has the widget's package, with no page naming the widget: the page shows links, the widget acts
- * on links, the dashboard puts the two together.
- */
-export interface LinkAction {
-    /** The button's label, a short verb phrase: "Add to queue". */
-    label: string;
-    /** What the button says once the action is done: "Queued". The label with a check mark otherwise. */
-    doneLabel?: string;
-    /** The button's icon; none otherwise. */
-    icon?: ComponentType<{
-        className?: string;
-        'aria-hidden'?: boolean;
-    }>;
-    /**
-     * Act on the links, in the order given, all in one project. `host` runs the widget package's
-     * own commands in that project. A batch stops at its first failure and says why.
-     */
-    run(host: WidgetHost, projectId: string, links: WidgetLink[]): Promise<LinkActionResult>;
-}
-/** What a widget card is rendered with: the projects that have its package. A card has no URL and no sub-path. */
-export interface WidgetCardProps {
-    /** The registered projects whose dependencies include the widget's package, in the registry's order. */
-    projects: WidgetProject[];
-}
-/**
- * A card a widget adds to the Overview (#1818): the package's own summary of its data across the
- * projects that have it, drawn beside the dashboard's own cards. A project none of whose packages
- * declares a card sees none.
- */
-export interface WidgetCard {
-    /** Which card this is, for the shell's key and its error line; never shown as a title. */
-    id: string;
-    /** Its place among every installed package's cards, lower first; 50 when unsaid, ties by package name. */
-    order?: number;
-    /** The card itself. */
-    Card: ComponentType<WidgetCardProps>;
-}
-/** What a widget module default-exports. */
-export interface WidgetDefinition {
-    /** The pages the widget adds, each with a sidebar row. */
-    pages?: WidgetPage[];
-    /** The cards the widget adds to the Overview. */
-    cards?: WidgetCard[];
-    /** The actions the widget offers on the links dashboard pages show, wherever the link's project has the widget's package. */
-    linkActions?: LinkAction[];
-    /** A stylesheet to load with the widget, relative to the widget module's own URL. */
-    stylesheet?: string;
-}
-/** Type the default export: `export default defineWidget({ ... })`. */
-export declare function defineWidget(definition: WidgetDefinition): WidgetDefinition;
-/** A run of a project as the dashboard knows it (#1774): enough for a page to name one and link to it. */
-export interface WidgetAgent {
-    /** The run's id, the one {@link WidgetHost.openAgent} takes. */
-    id: string;
-    /** The run's branch, the name the agent gave its work, when its record carries one. */
-    name?: string;
-    /** What the run was asked, as typed or as queued; absent when its record carries none. */
-    ask?: string;
-    status: AgentStatus;
-    /** ISO 8601. */
-    startedAt: string;
-}
-/** What starting a run answered: the run's id, or in words why there is none. */
-export type StartRunResult = {
-    ok: true;
-    agentId: string;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * What the dashboard gives the widget it is rendering. Every service is generic — a project, a
- * run, a page, a command — and none names a skill: what a widget composes out of them is its own.
- */
-export interface WidgetHost {
-    /** The package the widget came from: the one whose commands {@link runCommand} runs. */
-    package: string;
-    /**
-     * Run one of the widget package's own commands in one project and get its JSON output: the
-     * same command an agent runs (`npx <command> …`). `command` names one when the package has several.
-     */
-    runCommand(projectId: string, args: string[], command?: string): Promise<WidgetCommandResult>;
-    /**
-     * The same, for a command that changes the project's data (a claim released, an entry added):
-     * the dashboard then syncs the project's data with origin and forgets what it had read, so the
-     * change shows at once instead of at the next sync. A link action's host runs every command so.
-     */
-    act(projectId: string, args: string[], command?: string): Promise<WidgetCommandResult>;
-    /** Open one agent's page in the dashboard: its live feed while it runs, its record after. */
-    openAgent(projectId: string, agentId: string): void;
-    /** Open a page a widget adds (this one's or another's), at a sub-path: `openPage('tickets', [projectId, file])`. */
-    openPage(segment: string, path?: string[]): void;
-    /**
-     * Start a run in one project with this prompt, with the person's own picks (which tool, which
-     * model, where it runs), and land on it, unless `land` is false: then the dashboard stays where
-     * it is, for a widget that starts several runs in a row. Answers the run's id, or why there is none.
-     */
-    startRun(projectId: string, prompt: string, opts?: {
-        land?: boolean;
-    }): Promise<StartRunResult>;
-    /** Open the project's launcher with this prompt drafted in, to set it up before sending: "Configure first, then run". */
-    configureRun(projectId: string, prompt: string): void;
-    /** The project's runs the dashboard knows: the ones running, and the recorded ones when the project records them. */
-    agents(projectId: string): Promise<WidgetAgent[]>;
-}
-/** What the dashboard knows about the widget it is serving: every service but the commands, which it binds to the package. */
-export type WidgetHostBase = Omit<WidgetHost, 'runCommand' | 'act'>;
-/**
- * The host for one widget: the dashboard's services, and its commands bound to the widget's own
- * package. `acts` marks every command as an action on the project rather than a page's read: the
- * dashboard builds a link action's host with it, so what the action wrote is read back at once.
- */
-export declare function widgetHost(base: WidgetHostBase, opts?: {
-    acts?: boolean;
-}): WidgetHost;
-/**
- * Set by the dashboard around every widget page it renders: the widget's package and the
- * dashboard's services. A test of a widget page provides a whole host here, commands included,
- * and {@link useWidgetHost} hands it over as it is.
- */
-export declare const WidgetHostContext: import("react").Context<WidgetHost | WidgetHostBase | null>;
-/** The dashboard's services for the widget being rendered. Only valid inside a widget page. */
-export declare function useWidgetHost(): WidgetHost;
-export { Button, buttonVariants, type ButtonProps } from '../components/ui/button.js';
-export { Badge } from '../components/ui/badge.js';
-export { Card, CardHeader, CardTitle, CardContent } from '../components/ui/card.js';
-export { Skeleton } from '../components/ui/skeleton.js';
-export { Checkbox } from '../components/ui/checkbox.js';
-export { Input } from '../components/ui/input.js';
-export { Popover, PopoverContent, PopoverTrigger } from '../components/ui/popover.js';
-export { RangeSlider } from '../components/ui/slider.js';
-export { Separator } from '../components/ui/separator.js';
-export { ScrollArea } from '../components/ui/scroll-area.js';
-export { Tooltip, TooltipTrigger, TooltipContent } from '../components/ui/tooltip.js';
-export { DropdownMenu, DropdownMenuContent, DropdownMenuCheckboxItem, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger } from '../components/ui/dropdown-menu.js';
-export { Markdown } from '../components/Markdown.js';
-export { StartAgentButton } from '../components/StartAgentButton.js';
-export { LinkActions, type ProjectLinks, type LinkTargets } from '../components/LinkActions.js';
-export { cn } from '../lib/utils.js';
-export { formatRelative, formatDateTime, formatDuration, formatAge } from '../lib/format-date.js';
-export { usePolled, useLoaded } from '../lib/use-async.js';
-export { useAction } from '../lib/use-action.js';

package/dist/widget-types/src/agent-id.d.ts

@@ -1,12 +0,0 @@
-/**
- * An agent's id, derived from the moment it starts. Pure — no node imports — because the sweep
- * that mints ids ahead of a claim (#1748) is reachable from the dashboard's browser bundle.
- */
-/** Filesystem-safe, lexicographically-sortable agent id from an ISO start time. */
-export declare function agentIdFromStartedAt(startedAt: string): string;
-/**
- * The inverse of {@link agentIdFromStartedAt}, for a caller that has the id but not the meta
- * (#1251): picking which PR is the agent's needs the start time to tell the agent's own PR from a
- * predecessor's on the same branch name. Undefined for an id that is not one of ours.
- */
-export declare function startedAtFromAgentId(id: string): string | undefined;

package/dist/widget-types/src/agent-locks.d.ts

@@ -1,2 +0,0 @@
-/** Run `fn` once every earlier holder of `checkout`'s lock has settled. */
-export declare function withAgentLock<T>(checkout: string, fn: () => Promise<T>): Promise<T>;

package/dist/widget-types/src/agent-view.d.ts

@@ -1,38 +0,0 @@
-import type { FrameworkEvent } from './events.js';
-/** One error of a run: one the agent reported through an `error` block (#1500), or one its tool wrote in the diary. */
-export interface AgentError {
-    /** What is wrong, in one line. */
-    headline: string;
-    /** What it ran and what that said, when the agent wrote any. */
-    detail?: string;
-}
-/**
- * Every error of the run (#1500), oldest first — the count the dashboard shows on the session, and
- * the latest headline it shows beside it. Two sources: the `error` lines the run's tool writes in
- * the diary when the coding agent or its transport fails (the message's first line is the
- * headline, the rest the detail), and the `error` blocks of runs recorded before the daemon
- * stopped running agents.
- *
- * A fold over the log rather than state of its own: an error is an event that happened, so the
- * list only ever grows, and reopening a finished agent shows exactly what it showed while it ran.
- */
-export declare function agentErrors(events: readonly FrameworkEvent[]): AgentError[];
-/** The wrapped agent session (#431): its id and a deep link, when one is known. */
-export interface SessionInfo {
-    sessionId?: string;
-    sessionLink?: string;
-    /**
-     * The directory the agent ran in (#1195), from the opening `session` event.
-     *
-     * Taken from the event rather than the filesystem on purpose: an agent that finishes cleanly has
-     * its worktree removed (`tearDownWorktree`), so the event is the only surviving record of where
-     * the session lived — and that path is exactly what `claude --resume` needs to find it again.
-     */
-    workspace?: string;
-}
-/**
- * The session behind the agent (#431): the workspace from the opening `session`
- * event, then the id and any deep link from the latest `session-update`. Null before the
- * session opens. The link is what the old dashboard surfaced as "open session".
- */
-export declare function sessionInfo(events: readonly FrameworkEvent[]): SessionInfo | null;

package/dist/widget-types/src/bridge-browser.d.ts

@@ -1,216 +0,0 @@
-/**
- * The bridge browser (#1332): a Chrome for Testing the daemon launches and owns, with the Claude
- * web bridge extension installed, signed in to claude.ai once by the user and kept minimized.
- *
- * The bridge's far end is a browser signed in to claude.ai. Until now that was the user's own
- * Chrome with the extension loaded, so a web run could only start — and a parked question could
- * only be noticed — while that Chrome happened to be open. The spike on #1332 settled what a
- * browser nobody attends has to be: headed, because claude.ai's Cloudflare gate never clears a
- * headless one; Chrome for Testing, because branded Chrome stopped loading unpacked extensions
- * from the command line; and installed over CDP with developer mode on, because an extension
- * loaded any other way is disabled the first time it reloads itself (#1712).
- *
- * Nothing here talks to claude.ai. The daemon launches the browser, hands the extension the
- * bridge token, and from then on the extension's Driver tab does exactly what it does in the
- * user's own Chrome — the daemon only keeps the window out of the way and brings it up when the
- * user has to sign in.
- */
-/** The directory holding the bridge browser's profile and binary, next to the registry file. */
-export declare const BRIDGE_BROWSER_DIR = "the-framework-browser";
-/**
- * Where the bridge browser lives: `$XDG_CONFIG_HOME/the-framework-browser` when set, else the
- * dotted `$HOME/.the-framework-browser`. Beside the registry, so the same variable that isolates
- * a test's registry isolates its browser, and a machine's real one is never touched from a test.
- * The profile inside it is persistent on purpose: the user signs in once and the sign-in outlives
- * every daemon restart.
- */
-export declare function bridgeBrowserDir(env: NodeJS.ProcessEnv): string;
-/**
- * The launch flags. Headed (no `--headless`): claude.ai's bot gate rejects a headless browser
- * outright, and a headed one whose window is minimized passes. The unsafe-extension-debugging
- * flag is what lets `Extensions.loadUnpacked` install the extension over CDP. The keychain flags
- * keep the cookie-encryption key out of the OS keychain (macOS asks for the login password on
- * every launch otherwise, and Linux for the wallet) — the same choice Puppeteer makes; the profile
- * directory's own permissions are what guard the sign-in.
- */
-export declare function bridgeBrowserLaunchArgs(port: number, profileDir: string): string[];
-/** Where the extension's files are, and whether that is a checkout, where they are edited in place. */
-export interface BridgeExtensionSource {
-    dir: string;
-    checkout: boolean;
-}
-/**
- * The extension's files (#1720): the checkout's `packages/chrome-extension` next to this package,
- * so an edit there reaches the browser through the extension's self-reload; else the copy the
- * build puts in `dist/chrome-extension`, which is what an installed package has. A folder counts
- * only when its manifest names the bridge extension. Undefined when neither is there.
- * `moduleUrl` is this file's URL; tests point it elsewhere.
- */
-export declare function bridgeExtensionSource(moduleUrl?: string): BridgeExtensionSource | undefined;
-/**
- * The process holding a profile's singleton lock, or undefined when nothing does. Chrome leaves
- * the lock behind as a symlink whose target is `<host>-<pid>`; a daemon that died without closing
- * its browser leaves that browser running, and a second Chrome on the same profile would hand its
- * command line to the first and exit at once.
- */
-export declare function profileLockOwner(profileDir: string, readLink?: (path: string) => Promise<string>): Promise<number | undefined>;
-/** One page, worker or browser-internal target Chrome lists. */
-export interface CdpTarget {
-    id: string;
-    type: string;
-    url: string;
-    webSocketDebuggerUrl?: string;
-}
-/** A session on one target: the calls go to that page or worker rather than to the browser. */
-export interface CdpTargetSession {
-    send(method: string, params?: Record<string, unknown>): Promise<unknown>;
-    close(): void;
-}
-/** How the daemon talks to its browser. Injectable: the real one speaks WebSocket to Chrome. */
-export interface BridgeBrowserCdp {
-    /** A browser-level call: installing the extension, opening and closing targets, window bounds. */
-    call(method: string, params?: Record<string, unknown>): Promise<unknown>;
-    /** Every target Chrome lists — pages, the extension's worker, browser-internal pages. */
-    targets(): Promise<CdpTarget[]>;
-    /** Attach to one target. */
-    attach(target: CdpTarget): Promise<CdpTargetSession>;
-    /** Drop the browser-level connection. The browser keeps running. */
-    close(): void;
-}
-/** The real connection: the browser socket from `/json/version`, targets from `/json/list`. */
-export declare function connectBridgeBrowser(browserUrl: string): Promise<BridgeBrowserCdp>;
-/** Install the extension from its directory. Chrome answers with the extension's id. */
-export declare function installExtension(cdp: BridgeBrowserCdp, extensionDir: string): Promise<string>;
-/**
- * The developer-mode switch on Chrome's extensions page, flipped on if it is off. Chrome (137
- * and later) disables an unpacked extension on reload while the mode is off, and the extension
- * reloads itself whenever its files change (#1712), so without this the bridge would die on the
- * first edit or pull. The profile remembers the setting, but writing the preference into the
- * profile directly does nothing — the switch is the one way that works.
- */
-export declare const DEVELOPER_MODE_ON = "(() => {\n  const manager = document.querySelector('extensions-manager')?.shadowRoot\n  const toggle = manager?.querySelector('extensions-toolbar')?.shadowRoot?.querySelector('#devMode')\n  if (!toggle) return 'missing'\n  if (!toggle.checked) toggle.click()\n  return 'on'\n})()";
-/** Open Chrome's extensions page in the background, switch developer mode on, close the page. */
-export declare function enableDeveloperMode(cdp: BridgeBrowserCdp, sleep: (ms: number) => Promise<void>): Promise<void>;
-/**
- * What the extension is told, run inside its own worker: the daemon's address and the bridge
- * token go into the storage its options page would have written, and the Driver tab is opened
- * as the one pinned claude.ai/code tab — the shape the extension adopts as its Driver — in place
- * of the blank page the browser started on. Opened here rather than left to the extension
- * because the extension opens no Driver tab while the daemon lists no cloud session, and the user
- * signs in on that tab before any session exists.
- */
-export declare function seedExpression(daemonUrl: string, token: string): string;
-/** Hand the freshly installed extension its daemon and token, in its service worker. */
-export declare function seedExtension(cdp: BridgeBrowserCdp, extensionId: string, daemonUrl: string, token: string, sleep: (ms: number) => Promise<void>): Promise<void>;
-/** The bridge browser once it runs. */
-export interface BridgeBrowser {
-    extensionId: string;
-    /** The path the claude.ai tab is on (`/login` while signed out), or undefined without such a tab. */
-    page(): Promise<string | undefined>;
-    /** Restore the window and bring the browser to the front, for the user to sign in. */
-    show(): Promise<void>;
-    /** Minimize the window again. */
-    hide(): Promise<void>;
-    /** Called once if Chrome exits on its own — the user quit it, or it crashed. */
-    onExit(listener: (detail: string) => void): void;
-    /** Close the browser. Safe to call twice. */
-    close(): Promise<void>;
-}
-/** The Chrome process, as much of it as this module needs. */
-export interface BridgeBrowserProcess {
-    pid?: number | undefined;
-    kill(signal?: NodeJS.Signals): unknown;
-    on(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): unknown;
-    on(event: 'error', listener: (err: Error) => void): unknown;
-}
-/** Everything the launch touches outside its own logic. Injectable so the sequence is testable without a Chrome. */
-export interface BridgeBrowserDeps {
-    /** The Chrome for Testing binary, downloaded into `cacheDir` if none is there yet. */
-    binary(cacheDir: string, report: (detail: string) => void): Promise<string>;
-    /** The process holding the profile's lock, if any. */
-    lockOwner(profileDir: string): Promise<number | undefined>;
-    alive(pid: number): boolean;
-    kill(pid: number, signal: NodeJS.Signals): void;
-    port(): Promise<number>;
-    spawn(binary: string, args: string[]): BridgeBrowserProcess;
-    ready(browserUrl: string): Promise<boolean>;
-    connect(browserUrl: string): Promise<BridgeBrowserCdp>;
-    /** Bring the browser application to the front (macOS: activate the app bundle). */
-    activate(binary: string): void;
-    sleep(ms: number): Promise<void>;
-}
-/**
- * The Chrome for Testing binary in `cacheDir`, or the current stable one downloaded there (about
- * 150 MB, once). Chrome for Testing rather than whatever Chrome the machine has: branded Chrome
- * ignores an unpacked extension handed to it from outside, and the agent's own browser lookup
- * would find exactly that.
- */
-export declare function bridgeBrowserBinary(cacheDir: string, report: (detail: string) => void): Promise<string>;
-/** macOS: the `.app` bundle the binary lives in, which `open` activates. Undefined elsewhere. */
-export declare function appBundle(binary: string): string | undefined;
-/** The real dependencies. */
-export declare function bridgeBrowserDeps(): BridgeBrowserDeps;
-/**
- * Make sure nothing else holds the profile: a browser a dead daemon left behind is stopped,
- * gently first. It is the framework's own profile, so whatever holds it is the framework's own
- * leftover; nothing the user runs shares it.
- */
-export declare function freeProfile(profileDir: string, deps: BridgeBrowserDeps): Promise<boolean>;
-/** What a launch needs to know. */
-export interface BridgeBrowserOptions {
-    /** Where the daemon listens — what the extension is told to call. */
-    daemonUrl: string;
-    /** The bridge token the extension presents on every call. */
-    token: string;
-    /** The bridge browser's directory: the profile and the binary live under it. */
-    dir: string;
-    /** The extension's files. Default: `bridgeExtensionSource()`. */
-    extension?: BridgeExtensionSource | undefined;
-    /** Progress, one line at a time, for the dashboard to show while the launch runs. */
-    report?: ((detail: string) => void) | undefined;
-}
-/**
- * Launch the bridge browser and get it ready: binary, profile, extension, developer mode, token,
- * Driver tab, minimized. Throws with the step that failed; the browser is closed again on a
- * failure after the spawn, so a half-set-up browser is never left running.
- */
-export declare function startBridgeBrowser(opts: BridgeBrowserOptions, deps?: BridgeBrowserDeps): Promise<BridgeBrowser>;
-/** Where the bridge browser stands, for the dashboard. */
-export type BridgeBrowserStatus = {
-    state: 'off';
-} | {
-    state: 'starting';
-    detail: string;
-}
-/** `signIn`: the claude.ai tab is on the sign-in page, so a person has to sign in before anything is served. */
- | {
-    state: 'running';
-    since: string;
-    visible: boolean;
-    signIn: boolean;
-} | {
-    state: 'stopped';
-    detail: string;
-};
-/** What the dashboard can ask of the bridge browser. */
-export type BridgeBrowserAction = 'show' | 'hide' | 'restart';
-/** The daemon's handle on its bridge browser: one at a time, started and stopped from the preference and the dashboard. */
-export interface BridgeBrowserOwner {
-    /** Where the browser stands; a running one is asked which page its claude.ai tab is on. */
-    status(): Promise<BridgeBrowserStatus>;
-    /** Launch it, unless it is running or on its way. Resolves once the launch is over, either way. */
-    start(): Promise<void>;
-    /** Close it, or cancel a launch under way. */
-    stop(): Promise<void>;
-    act(action: BridgeBrowserAction): Promise<void>;
-}
-/** How the owner launches a browser: the daemon's real launch, or a test's fake. */
-export type BridgeBrowserLauncher = (report: (detail: string) => void) => Promise<BridgeBrowser>;
-/**
- * The one bridge browser a daemon runs. A launch is slow — the first one downloads Chrome — so
- * the status carries the step it is on, and a stop that lands mid-launch closes the browser the
- * launch then hands over rather than leaving it running unowned. A browser that exits on its own
- * (the user quit it) is reported as stopped with the reason, and not relaunched: quitting it was
- * an act, and the dashboard offers a restart.
- */
-export declare function bridgeBrowserOwner(launch: BridgeBrowserLauncher, log?: (line: string) => void): BridgeBrowserOwner;

package/dist/widget-types/src/browser-stream.d.ts

@@ -1,19 +0,0 @@
-/**
- * The DevTools connection to a Chrome the daemon owns: the bridge browser's (#1332). Chrome
- * refuses DevTools socket connections carrying an `Origin` header unless launched with
- * `--remote-allow-origins`, and opening that up would let any page the user happens to visit
- * drive the browser. So the debug port stays unreachable from the web, and this process is the
- * only one that talks to it.
- */
-/** What a caller needs from a CDP connection, so a test can stand in for Chrome. */
-export interface CdpSession {
-    send(method: string, params?: Record<string, unknown>): Promise<unknown>;
-    close(): void;
-}
-/** How a caller reaches a browser or a page. Injectable: the real one speaks WebSocket to Chrome. */
-export type CdpConnect = (webSocketDebuggerUrl: string) => Promise<CdpSession>;
-/**
- * Talk CDP to Chrome over its debugger socket. Node's global WebSocket is enough, which is
- * what keeps this dependency-free.
- */
-export declare const connectCdp: CdpConnect;