@blario/react-native 0.0.0-stage → 0.1.0

package/dist/actions/services.d.ts

@@ -0,0 +1,20 @@
+import type { RegisteredElement } from '../snapshot/registry.ts';
+import type { CursorPort } from './landing.ts';
+import { NavigationDriver } from './navigation-driver.ts';
+import { TargetResolver, type TargetView } from './target.ts';
+export interface ReadingRequest extends TargetView {
+    text: string | null;
+}
+export interface ReadingPort {
+    read: (request: ReadingRequest) => Promise<boolean>;
+}
+export interface InputMemory {
+    last: RegisteredElement | null;
+}
+export interface ActionServices {
+    resolver: TargetResolver;
+    navigation: NavigationDriver;
+    reading: ReadingPort;
+    cursor: CursorPort;
+    inputMemory: InputMemory;
+}

package/dist/actions/settle.d.ts

@@ -0,0 +1,13 @@
+export interface SettleOptions {
+    minWaitMs: number;
+    quietMs: number;
+    capMs: number;
+    pollMs: number;
+}
+export interface Clock {
+    now: () => number;
+    sleep: (milliseconds: number) => Promise<void>;
+}
+export declare const DEFAULT_SETTLE: SettleOptions;
+export declare const SYSTEM_CLOCK: Clock;
+export declare function waitForSettle(sample: () => Promise<string>, options?: SettleOptions, clock?: Clock): Promise<string>;

package/dist/actions/switch.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedTarget } from './target.ts';
+import type { HandlerResult } from './types.ts';
+export declare function toggleSwitch(target: ResolvedTarget, desired: boolean | null): HandlerResult;

package/dist/actions/target.d.ts

@@ -0,0 +1,25 @@
+import type { Band, Rect } from '../host/rect.ts';
+import type { Fiber, Props } from '../fiber/types.ts';
+import { ElementRegistry, type RegisteredElement } from '../snapshot/registry.ts';
+export interface ResolvedTarget {
+    element: RegisteredElement;
+    fiber: Fiber;
+    ancestors: Fiber[];
+    props: Props;
+    host: Fiber | null;
+}
+export declare class TargetResolver {
+    private readonly registry;
+    private readonly getAnchorFiber;
+    constructor(registry: ElementRegistry, getAnchorFiber: () => Fiber | null);
+    resolveAgentId(agentId: string): ResolvedTarget | null;
+    resolveElement(element: RegisteredElement): ResolvedTarget | null;
+}
+export interface TargetView {
+    measure: () => Promise<Rect | null>;
+    radius: number;
+    reveal?: (band: Band) => Promise<void>;
+}
+export declare function measureTarget(target: ResolvedTarget): () => Promise<Rect | null>;
+export declare function viewOf(target: ResolvedTarget): TargetView;
+export declare function nameOf(target: ResolvedTarget): string | null;

package/dist/actions/text-input.d.ts

@@ -0,0 +1,9 @@
+import type { ActionServices } from './services.ts';
+import type { ResolvedTarget } from './target.ts';
+import type { AgentAction, HandlerResult } from './types.ts';
+type TypeAction = Extract<AgentAction, {
+    type: 'type';
+}>;
+export declare function typeText(target: ResolvedTarget, action: TypeAction, services: ActionServices): HandlerResult;
+export declare function submitInput(target: ResolvedTarget): HandlerResult;
+export {};

package/dist/actions/types.d.ts

@@ -0,0 +1,59 @@
+import type { UnknownRecord } from '../fiber/narrow.ts';
+export type ScrollDirectionName = 'up' | 'down' | 'left' | 'right';
+export type AgentAction = {
+    type: 'click';
+} | {
+    type: 'type';
+    value: string;
+    clear_first: boolean;
+} | {
+    type: 'check';
+    checked: boolean | null;
+} | {
+    type: 'press_key';
+    key: string;
+} | {
+    type: 'scroll';
+    direction: ScrollDirectionName;
+    amount: number | null;
+} | {
+    type: 'scroll_to';
+} | {
+    type: 'navigate';
+    route: string;
+    params: UnknownRecord | null;
+} | {
+    type: 'highlight';
+};
+export type ActionErrorCode = 'element_not_found' | 'element_not_interactable' | 'unsupported_action' | 'execution_error' | 'user_cancelled' | 'timeout';
+export type RiskLevel = 'safe' | 'reversible' | 'irreversible' | 'destructive';
+export type FailedResult = {
+    ok: false;
+    error: ActionErrorCode;
+    message: string;
+};
+export type HandlerResult = {
+    ok: true;
+    message?: string;
+} | FailedResult;
+export interface ActionOutcome {
+    success: boolean;
+    no_op: boolean;
+    error?: ActionErrorCode;
+    message?: string;
+}
+export interface PageContentRequest {
+    viewportOnly: boolean;
+    maxChars: number;
+}
+export interface AgentCommandData {
+    command_id: string;
+    action: AgentAction;
+    agent_id: string | null;
+    risk_level: RiskLevel;
+    confirmation_required: boolean;
+    teaching_explanation: string | null;
+    include_page_content: boolean;
+    page_content_options: PageContentRequest;
+    dom_settle_ms: number;
+}

package/dist/agent/batch-commands.d.ts

@@ -0,0 +1,17 @@
+import type { AgentCommandData, PageContentRequest } from '../actions/types.ts';
+export type BatchEntry = {
+    kind: 'action';
+    command: AgentCommandData;
+} | {
+    kind: 'dom_state';
+    commandId: string;
+} | {
+    kind: 'text_dom';
+    commandId: string;
+    options: PageContentRequest;
+} | {
+    kind: 'invalid';
+    commandId: string;
+    reason: string;
+};
+export declare function parseBatchEntries(data: unknown): BatchEntry[];

package/dist/agent/compose.d.ts

@@ -0,0 +1,23 @@
+import { type NavigationRefLike } from '../actions/navigation-driver.ts';
+import type { CursorPort } from '../actions/landing.ts';
+import type { ReadingPort } from '../actions/services.ts';
+import type { Fiber } from '../fiber/types.ts';
+import type { Size } from '../host/rect.ts';
+import type { ConfirmationPort } from '../confirmation/port.ts';
+import type { AgentStage } from './stage.ts';
+import type { AgentTransport } from '../transport/transport.ts';
+import { AgentController } from './controller.ts';
+export interface AgentEnvironment {
+    transport: AgentTransport;
+    getAnchorFiber: () => Fiber | null;
+    getViewport: () => Size;
+    getNavigationRef: () => NavigationRefLike | null;
+    getCaptureTarget: () => unknown;
+    reading: ReadingPort;
+    cursor: CursorPort;
+    confirmation: ConfirmationPort;
+    stage: AgentStage;
+    onCommit?: () => void;
+    onSettled?: () => void;
+}
+export declare function createAgentController(environment: AgentEnvironment): AgentController;

package/dist/agent/controller.d.ts

@@ -0,0 +1,28 @@
+import type { CommitWatch } from '../actions/commit-watch.ts';
+import { type MessageMetadata } from '../backend/message-metadata.ts';
+import type { Size } from '../host/rect.ts';
+import type { AgentTransport } from '../transport/transport.ts';
+import type { HandlerContext } from './handlers/context.ts';
+export interface ControllerDependencies {
+    transport: AgentTransport;
+    commitWatch: CommitWatch;
+    getViewport: () => Size;
+    context: Omit<HandlerContext, 'send'>;
+    onSettled?: () => void;
+}
+export declare class AgentController {
+    private readonly dependencies;
+    private queue;
+    private readonly context;
+    constructor(dependencies: ControllerDependencies);
+    start(): void;
+    stop(): void;
+    readMessageMetadata(options: {
+        includeTextDom: boolean;
+        tabId: string;
+    }): Promise<MessageMetadata>;
+    private receive;
+    private handle;
+    private route;
+    private send;
+}

package/dist/agent/frame-runner.d.ts

@@ -0,0 +1,9 @@
+import type { RoutedFrame } from './frames.ts';
+import type { Admission, AgentStage } from './stage.ts';
+export declare function admissionFor(frame: RoutedFrame): Admission | null;
+export interface FrameRunnerOptions {
+    stage: AgentStage;
+    handle: (frame: RoutedFrame) => Promise<void>;
+    onSettled?: () => void;
+}
+export declare function runFrame(frame: RoutedFrame, options: FrameRunnerOptions): Promise<void>;

package/dist/agent/frames.d.ts

@@ -0,0 +1,180 @@
+import type { ActionErrorCode, ActionOutcome, PageContentRequest } from '../actions/types.ts';
+export interface ScreenshotOptions {
+    quality: number;
+    maxWidth: number;
+}
+export type InboundFrame = {
+    kind: 'ping';
+} | {
+    kind: 'agent_command';
+    commandId: string;
+    data: unknown;
+} | {
+    kind: 'agent_command_batch';
+    commandId: string;
+    data: unknown;
+} | {
+    kind: 'request_dom_state';
+    commandId: string;
+} | {
+    kind: 'request_text_dom';
+    commandId: string;
+    options: PageContentRequest;
+} | {
+    kind: 'request_screenshot';
+    commandId: string;
+    options: ScreenshotOptions;
+} | {
+    kind: 'request_element_context';
+    commandId: string;
+    agentIds: string[];
+} | {
+    kind: 'unknown';
+    name: string;
+};
+export type RoutedFrame = Exclude<InboundFrame, {
+    kind: 'ping' | 'unknown';
+}>;
+export interface DomStateResponseData {
+    schema_version: 3;
+    platform: 'react-native';
+    url: string;
+    title: string;
+    screen: string;
+    routes: string[];
+    html_snapshot: string;
+}
+export interface TextDomResponseData {
+    url: string;
+    title: string;
+    screen: string;
+    text_tree: string;
+    refs: never[];
+}
+export interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ElementContextItem {
+    agent_id: string;
+    found: boolean;
+    tag_name?: string;
+    visible?: boolean;
+    line?: string;
+    bounding_box?: BoundingBox;
+    text_content?: string;
+    placeholder?: string;
+    nearest_label?: string;
+    sibling_text?: string[];
+}
+export interface ElementContextResponseData {
+    elements: ElementContextItem[];
+}
+export type PageContentSkipReason = 'no_op';
+export interface AgentCommandResponseData extends ActionOutcome {
+    page_content?: TextDomResponseData;
+    page_content_skipped?: PageContentSkipReason;
+}
+export interface BatchActionResult {
+    command_id: string;
+    success: boolean;
+    message: string;
+    error?: ActionErrorCode;
+    no_op?: boolean;
+    total_duration_ms: number;
+}
+export interface BatchDomStateResult {
+    command_id: string;
+    type: 'dom_state';
+    dom_state: DomStateResponseData;
+    total_duration_ms: number;
+}
+export interface BatchTextDomResult {
+    command_id: string;
+    type: 'text_dom';
+    text_dom: TextDomResponseData;
+    total_duration_ms: number;
+}
+export type BatchCommandResult = BatchActionResult | BatchDomStateResult | BatchTextDomResult;
+export interface BatchResponseData {
+    results: BatchCommandResult[];
+    stopped_at: number | null;
+    stopped_reason?: 'cancelled' | 'check_unreached';
+}
+export interface ScreenshotResponseData {
+    success: true;
+    image: string;
+    format: 'jpeg';
+    screen: string;
+    timestamp: number;
+    partial?: true;
+    omitted?: Array<'modal'>;
+}
+export interface ConsentScreenshotMetadata {
+    action_type: string;
+    element_description: string;
+    url: string;
+}
+export type ConsentScreenshotData = {
+    success: true;
+    image: string;
+    screenshot_metadata: ConsentScreenshotMetadata;
+    capture_duration_ms: number;
+    sent_at: number;
+} | {
+    success: false;
+    screenshot_error: 'CAPTURE_FAILED';
+    sent_at: number;
+};
+export type OutboundFrame = {
+    type: 'command_ack';
+    command_id: string;
+} | {
+    type: 'pong';
+} | {
+    type: 'sdk_response';
+    command_id: string;
+    response_type: 'dom_state_response';
+    data: DomStateResponseData;
+} | {
+    type: 'sdk_response';
+    command_id: string;
+    response_type: 'text_dom_response';
+    data: TextDomResponseData;
+} | {
+    type: 'sdk_response';
+    command_id: string;
+    response_type: 'element_context_response';
+    data: ElementContextResponseData;
+} | {
+    type: 'sdk_response';
+    command_id: string;
+    response_type: 'agent_command_response';
+    data: AgentCommandResponseData;
+} | {
+    type: 'sdk_response';
+    command_id: string;
+    response_type: 'agent_command_response';
+    data: ConsentScreenshotData;
+} | {
+    type: 'sdk_response';
+    command_id: string;
+    response_type: 'agent_command_batch_response';
+    data: BatchResponseData;
+} | {
+    type: 'sdk_response';
+    command_id: string;
+    response_type: 'screenshot_response';
+    data: ScreenshotResponseData;
+} | {
+    type: 'sdk_error';
+    command_id: string;
+    error: string;
+    code?: string;
+} | {
+    type: 'agent_cancel';
+    reason: string;
+};
+export declare function parseInboundFrame(raw: string): InboundFrame | null;

package/dist/agent/handlers/agent-command.d.ts

@@ -0,0 +1,5 @@
+import type { AgentCommandData } from '../../actions/types.ts';
+import type { AgentCommandResponseData } from '../frames.ts';
+import type { HandlerContext } from './context.ts';
+export declare function runAgentCommand(context: HandlerContext, command: AgentCommandData): Promise<AgentCommandResponseData>;
+export declare function handleAgentCommand(context: HandlerContext, commandId: string, data: unknown): Promise<void>;

package/dist/agent/handlers/batch.d.ts

@@ -0,0 +1,5 @@
+import { type BatchEntry } from '../batch-commands.ts';
+import type { BatchResponseData } from '../frames.ts';
+import type { HandlerContext } from './context.ts';
+export declare function runBatch(context: HandlerContext, entries: BatchEntry[]): Promise<BatchResponseData>;
+export declare function handleBatch(context: HandlerContext, batchId: string, data: unknown): Promise<void>;

package/dist/agent/handlers/consent-screenshot.d.ts

@@ -0,0 +1,4 @@
+import { type ResolvedTarget } from '../../actions/target.ts';
+import type { AgentCommandData } from '../../actions/types.ts';
+import type { HandlerContext } from './context.ts';
+export declare function sendConsentScreenshot(context: HandlerContext, command: AgentCommandData, target: ResolvedTarget | null): Promise<void>;

package/dist/agent/handlers/context.d.ts

@@ -0,0 +1,16 @@
+import type { ActionExecutor } from '../../actions/executor.ts';
+import type { ConfirmationPort } from '../../confirmation/port.ts';
+import type { Screenshotter } from '../../screenshot/screenshotter.ts';
+import type { SnapshotCapturer } from '../../snapshot/capture.ts';
+import type { ElementContextReader } from '../../snapshot/element-context.ts';
+import type { OutboundFrame } from '../frames.ts';
+import type { AgentStage } from '../stage.ts';
+export interface HandlerContext {
+    capturer: SnapshotCapturer;
+    executor: ActionExecutor;
+    screenshotter: Screenshotter;
+    elementContext: ElementContextReader;
+    confirmation: ConfirmationPort;
+    stage: AgentStage;
+    send: (frame: OutboundFrame) => void;
+}

package/dist/agent/handlers/dom-state.d.ts

@@ -0,0 +1,4 @@
+import type { DomStateResponseData } from '../frames.ts';
+import type { HandlerContext } from './context.ts';
+export declare function readDomState(context: HandlerContext): Promise<DomStateResponseData>;
+export declare function handleDomState(context: HandlerContext, commandId: string): Promise<void>;

package/dist/agent/handlers/element-context.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerContext } from './context.ts';
+export declare function handleElementContext(context: HandlerContext, commandId: string, agentIds: string[]): Promise<void>;

package/dist/agent/handlers/screenshot.d.ts

@@ -0,0 +1,3 @@
+import type { ScreenshotOptions } from '../frames.ts';
+import type { HandlerContext } from './context.ts';
+export declare function handleScreenshot(context: HandlerContext, commandId: string, options: ScreenshotOptions): Promise<void>;

package/dist/agent/handlers/text-dom.d.ts

@@ -0,0 +1,5 @@
+import type { PageContentRequest } from '../../actions/types.ts';
+import type { TextDomResponseData } from '../frames.ts';
+import type { HandlerContext } from './context.ts';
+export declare function readTextDom(context: HandlerContext, options: PageContentRequest): Promise<TextDomResponseData>;
+export declare function handleTextDom(context: HandlerContext, commandId: string, options: PageContentRequest): Promise<void>;

package/dist/agent/stage.d.ts

@@ -0,0 +1,13 @@
+import type { AgentCommandData } from '../actions/types.ts';
+export interface Admission {
+    kind: 'command' | 'batch';
+    keepText: string | null;
+}
+export interface AgentStage {
+    received: () => void;
+    admit: (admission: Admission) => Promise<boolean>;
+    beforeAction: (command: AgentCommandData) => void;
+    settled: () => void;
+    isCancelled: () => boolean;
+}
+export declare const OPEN_STAGE: AgentStage;

package/dist/agent-mode/action-description.d.ts

@@ -0,0 +1,3 @@
+import type { AgentAction } from '../actions/types.ts';
+import type { UiStrings } from '../ui/strings.ts';
+export declare function describeAction(action: AgentAction, strings: UiStrings): string;

package/dist/agent-mode/bubbles.d.ts

@@ -0,0 +1,10 @@
+export interface AgentBubble {
+    id: string;
+    text: string;
+    leaving: boolean;
+}
+export declare function readingTimeMs(text: string): number;
+export declare function isShowing(bubbles: readonly AgentBubble[], text: string): boolean;
+export declare function keepOnly(bubbles: readonly AgentBubble[], keepText: string | null): AgentBubble[];
+export declare function markLeaving(bubbles: readonly AgentBubble[], id: string): AgentBubble[];
+export declare function without(bubbles: readonly AgentBubble[], id: string): AgentBubble[];

package/dist/agent-mode/colors.d.ts

@@ -0,0 +1,12 @@
+export interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+export declare function parseHex(color: string): Rgb | null;
+export declare function luminance(color: string): number | null;
+export declare const ON_LIGHT = "#14161a";
+export declare const ON_DARK = "#ffffff";
+/** Text that reads on a brand-coloured surface: near-black on a light brand, white otherwise. */
+export declare function onColor(color: string): string;
+export declare function withAlpha(color: string, alpha: number): string;

package/dist/agent-mode/controller.d.ts

@@ -0,0 +1,92 @@
+import type { AgentCommandData } from '../actions/types.ts';
+import type { Admission, AgentStage } from '../agent/stage.ts';
+import { type AgentBubble } from './bubbles.ts';
+import { type AgentModeEvent } from './frames.ts';
+import type { KeepAwake } from './keep-awake.ts';
+import { type RunMemory } from './run-memory.ts';
+import { type AgentModePhase } from './state.ts';
+import { type AgentStatus } from './status.ts';
+import { type Timers } from './timers.ts';
+export type CancelReason = 'user_requested' | 'user_cancelled';
+export type ResumeDecision = 'resumed' | 'discarded' | 'kept' | 'none';
+export interface QueuedChip {
+    message: string | null;
+}
+export interface AgentModeSnapshot {
+    phase: AgentModePhase;
+    status: AgentStatus;
+    bubbles: AgentBubble[];
+    queued: QueuedChip | null;
+}
+export interface AgentModeEffects {
+    sendCancel: (reason: CancelReason) => void;
+    onActive: () => void;
+    onIdle: () => void;
+}
+type Listener = (snapshot: AgentModeSnapshot) => void;
+export declare const PENDING_MS = 2000;
+export declare const RUN_IDLE_TIMEOUT_MS = 120000;
+export declare const QUEUED_CHIP_MS = 5000;
+export declare const BUBBLE_EXIT_MS = 300;
+export declare const HANDOFF_WAIT_MS = 30000;
+export declare class AgentModeController implements AgentStage {
+    private readonly effects;
+    private readonly keepAwake;
+    private readonly memory;
+    private readonly timers;
+    private readonly machine;
+    private readonly listeners;
+    private readonly bubbleTimers;
+    private waiting;
+    private status;
+    private bubbles;
+    private queued;
+    private runGeneration;
+    private cancelledRun;
+    private bubbleCounter;
+    private pendingTimer;
+    private watchdog;
+    private queuedTimer;
+    private handoffWatchdog;
+    private absorbCompletion;
+    private snapshot;
+    constructor(effects: AgentModeEffects, keepAwake: KeepAwake, memory?: RunMemory, timers?: Timers);
+    getSnapshot(): AgentModeSnapshot;
+    subscribe(listener: Listener): () => void;
+    connecting(sessionId: number): ResumeDecision;
+    received(): void;
+    admit(admission: Admission): Promise<boolean>;
+    beforeAction(command: AgentCommandData): void;
+    settled(): void;
+    isCancelled(): boolean;
+    stop(): void;
+    endClosedRun(): void;
+    socketFailed(): void;
+    handleEvent(event: AgentModeEvent): void;
+    dispose(): void;
+    private enterPending;
+    private finishPending;
+    private enterActive;
+    private applyHistory;
+    private openRun;
+    private latch;
+    private exit;
+    private leavePending;
+    private teardown;
+    private showProgress;
+    private showMessage;
+    private showQueued;
+    private showBubble;
+    private replaceBubbles;
+    private noteActivity;
+    private rememberRun;
+    private beginHandoffWait;
+    private armHandoffWatchdog;
+    private noteHandoffActivity;
+    private clearHandoffWait;
+    private armWatchdog;
+    private clearTimer;
+    private publish;
+    private buildSnapshot;
+}
+export {};

package/dist/agent-mode/cursor-follow.d.ts

@@ -0,0 +1,12 @@
+import type { Clock } from '../actions/settle.ts';
+import type { Rect } from '../host/rect.ts';
+export declare const FOLLOW_MIN_MS = 350;
+export declare const FOLLOW_MAX_MS = 1400;
+export declare const FOLLOW_POLL_MS = 33;
+export interface Follow {
+    measure: () => Promise<Rect | null>;
+    place: (rect: Rect) => void;
+    isLive: () => boolean;
+    clock: Clock;
+}
+export declare function followUntilLanded({ measure, place, isLive, clock }: Follow): Promise<void>;

package/dist/agent-mode/cursor.d.ts

@@ -0,0 +1,37 @@
+import type { Clock } from '../actions/settle.ts';
+import type { Rect } from '../host/rect.ts';
+export interface CursorSnapshot {
+    tap: number;
+    target: Rect | null;
+    landed: boolean;
+}
+export interface CursorEnvironment {
+    clock: Clock;
+    isForeground: () => boolean;
+}
+type Listener = (snapshot: CursorSnapshot) => void;
+export declare const ATTACH_MAX_MS = 1000;
+export declare const PRESS_MS = 450;
+export declare class CursorController {
+    private readonly environment;
+    private snapshot;
+    private readonly listeners;
+    private arrival;
+    private sessionEnded;
+    private move;
+    private attached;
+    private onAttached;
+    constructor(environment: CursorEnvironment);
+    getSnapshot(): CursorSnapshot;
+    subscribe(listener: Listener): () => void;
+    beginSession(): void;
+    moveTo(measure: () => Promise<Rect | null>): void;
+    attach(): void;
+    detach(): void;
+    whenLanded(): Promise<void>;
+    endSession(): void;
+    private tap;
+    private untilAttached;
+    private publish;
+}
+export {};