@blario/react-native 0.0.0 → 0.1.1

package/src/agent-mode/controller.ts

@@ -0,0 +1,459 @@
+import type { AgentCommandData } from '../actions/types.ts';
+import type { Admission, AgentStage } from '../agent/stage.ts';
+import { type AgentBubble, isShowing, keepOnly, markLeaving, readingTimeMs, without } from './bubbles.ts';
+import { type AgentModeEvent, isBubbleRole } from './frames.ts';
+import type { KeepAwake } from './keep-awake.ts';
+import { isResumable, shouldResumeAgentMode } from './resume.ts';
+import { NO_RUN_MEMORY, type RunMemory } from './run-memory.ts';
+import { type AgentModePhase, AgentModeStateMachine } from './state.ts';
+import { type AgentStatus, EXECUTING, isStepMessage, THINKING } from './status.ts';
+import { SYSTEM_TIMERS, 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;
+}
+
+interface Waiting {
+  admission: Admission;
+  resolve: (admitted: boolean) => void;
+}
+
+type Listener = (snapshot: AgentModeSnapshot) => void;
+
+export const PENDING_MS = 2_000;
+export const RUN_IDLE_TIMEOUT_MS = 120_000;
+export const QUEUED_CHIP_MS = 5_000;
+export const BUBBLE_EXIT_MS = 300;
+export const HANDOFF_WAIT_MS = 30_000;
+
+const TERMINAL_STATUSES: readonly string[] = ['waiting', 'cancelled', 'idle'];
+
+export class AgentModeController implements AgentStage {
+  private readonly machine = new AgentModeStateMachine();
+
+  private readonly listeners = new Set<Listener>();
+
+  private readonly bubbleTimers = new Map<string, unknown[]>();
+
+  private waiting: Waiting[] = [];
+
+  private status: AgentStatus = THINKING;
+
+  private bubbles: AgentBubble[] = [];
+
+  private queued: QueuedChip | null = null;
+
+  private runGeneration = 0;
+
+  private cancelledRun: number | null = null;
+
+  private bubbleCounter = 0;
+
+  private pendingTimer: unknown = null;
+
+  private watchdog: unknown = null;
+
+  private queuedTimer: unknown = null;
+
+  private handoffWatchdog: unknown = null;
+
+  private absorbCompletion = false;
+
+  private snapshot: AgentModeSnapshot;
+
+  constructor(
+    private readonly effects: AgentModeEffects,
+    private readonly keepAwake: KeepAwake,
+    private readonly memory: RunMemory = NO_RUN_MEMORY,
+    private readonly timers: Timers = SYSTEM_TIMERS,
+  ) {
+    this.snapshot = this.buildSnapshot();
+  }
+
+  getSnapshot(): AgentModeSnapshot {
+    return this.snapshot;
+  }
+
+  subscribe(listener: Listener): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  connecting(sessionId: number): ResumeDecision {
+    const run = this.memory.recall();
+    const now = this.timers.now();
+    if (shouldResumeAgentMode({ run, sessionId, phase: this.machine.getPhase(), now })) {
+      this.enterActive();
+      this.beginHandoffWait();
+      return 'resumed';
+    }
+    if (run !== null && !isResumable(run, sessionId, now)) {
+      this.memory.forget();
+      return 'discarded';
+    }
+    return run === null ? 'none' : 'kept';
+  }
+
+  received(): void {
+    this.rememberRun();
+  }
+
+  admit(admission: Admission): Promise<boolean> {
+    this.noteActivity();
+    this.noteHandoffActivity();
+    if (this.machine.isActive()) {
+      this.openRun(admission);
+      this.publish();
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve) => {
+      this.waiting.push({ admission, resolve });
+      if (this.machine.getPhase() === 'idle') {
+        this.enterPending();
+      }
+    });
+  }
+
+  beforeAction(command: AgentCommandData): void {
+    if (!this.machine.isActive() || command.action.type === 'highlight') {
+      return;
+    }
+    if (command.teaching_explanation !== null) {
+      this.showBubble(command.teaching_explanation);
+    }
+    this.status = EXECUTING;
+    this.publish();
+  }
+
+  settled(): void {
+    if (this.machine.isActive()) {
+      this.status = THINKING;
+      this.publish();
+    }
+  }
+
+  isCancelled(): boolean {
+    return this.cancelledRun !== null && this.cancelledRun === this.runGeneration;
+  }
+
+  stop(): void {
+    const phase = this.machine.getPhase();
+    if (phase === 'idle') {
+      return;
+    }
+    this.effects.sendCancel(phase === 'pending' ? 'user_cancelled' : 'user_requested');
+    this.latch();
+    this.exit();
+  }
+
+  endClosedRun(): void {
+    this.memory.forget();
+    if (this.machine.getPhase() !== 'idle') {
+      this.latch();
+      this.exit();
+    }
+  }
+
+  socketFailed(): void {
+    this.exit();
+  }
+
+  handleEvent(event: AgentModeEvent): void {
+    switch (event.kind) {
+      case 'progress':
+        this.noteActivity();
+        this.showProgress(event.message, event.progressType);
+        return;
+      case 'message':
+        this.noteActivity();
+        this.showMessage(event.role, event.text, event.waitForResponse);
+        return;
+      case 'queued':
+        this.showQueued(event.message);
+        return;
+      case 'execution_complete':
+      case 'acknowledged':
+        if (this.absorbCompletion) {
+          this.absorbCompletion = false;
+          this.armHandoffWatchdog();
+          return;
+        }
+        this.latch();
+        this.exit();
+        return;
+      case 'cancelled':
+      case 'session_closed':
+        this.latch();
+        this.exit();
+        return;
+      case 'history':
+        this.applyHistory(event.agentModeActive, event.agentStatus);
+        return;
+      case 'thinking':
+        this.noteActivity();
+        this.keepAwake.hold('ai-turn');
+        return;
+      case 'thinking_stop':
+        this.keepAwake.release('ai-turn');
+        return;
+      case 'session_started':
+        return;
+    }
+  }
+
+  dispose(): void {
+    this.clearTimer(this.pendingTimer);
+    this.clearTimer(this.watchdog);
+    this.clearTimer(this.queuedTimer);
+    this.clearTimer(this.handoffWatchdog);
+    this.bubbleTimers.forEach((handles) => handles.forEach((handle) => this.timers.clear(handle)));
+    this.bubbleTimers.clear();
+    this.waiting.splice(0).forEach((entry) => entry.resolve(false));
+    this.keepAwake.releaseAll();
+    this.machine.forceIdle();
+    this.listeners.clear();
+  }
+
+  private enterPending(): void {
+    if (!this.machine.transition('pending')) {
+      return;
+    }
+    this.pendingTimer = this.timers.set(() => this.finishPending(), PENDING_MS);
+    this.publish();
+  }
+
+  private finishPending(): void {
+    this.pendingTimer = null;
+    this.enterActive();
+    const admitted = this.waiting.splice(0);
+    admitted.forEach((entry) => this.openRun(entry.admission));
+    this.publish();
+    admitted.forEach((entry) => entry.resolve(true));
+  }
+
+  private enterActive(): void {
+    if (!this.machine.transition('active')) {
+      return;
+    }
+    this.cancelledRun = null;
+    this.status = THINKING;
+    this.keepAwake.hold('agent-run');
+    this.rememberRun();
+    this.armWatchdog();
+    this.effects.onActive();
+    this.publish();
+  }
+
+  private applyHistory(agentModeActive: boolean, agentStatus: string | null): void {
+    if (agentStatus !== null && TERMINAL_STATUSES.includes(agentStatus)) {
+      this.exit();
+      return;
+    }
+    if (agentModeActive && this.machine.getPhase() === 'idle') {
+      this.enterActive();
+    }
+  }
+
+  private openRun(admission: Admission): void {
+    this.runGeneration += 1;
+    this.replaceBubbles(keepOnly(this.bubbles, admission.kind === 'command' ? admission.keepText : null));
+  }
+
+  private latch(): void {
+    this.cancelledRun = this.runGeneration;
+  }
+
+  private exit(): void {
+    this.memory.forget();
+    const phase = this.machine.getPhase();
+    if (phase === 'pending') {
+      this.leavePending();
+      return;
+    }
+    this.teardown();
+    if (!this.machine.transition('exiting')) {
+      return;
+    }
+    this.publish();
+    this.machine.transition('idle');
+    this.status = THINKING;
+    this.replaceBubbles([]);
+    this.queued = null;
+    this.publish();
+    this.waiting.splice(0).forEach((entry) => entry.resolve(false));
+    this.effects.onIdle();
+  }
+
+  private leavePending(): void {
+    this.clearTimer(this.pendingTimer);
+    this.pendingTimer = null;
+    this.machine.transition('idle');
+    this.waiting.splice(0).forEach((entry) => entry.resolve(false));
+    this.publish();
+  }
+
+  private teardown(): void {
+    this.clearTimer(this.watchdog);
+    this.watchdog = null;
+    this.clearTimer(this.queuedTimer);
+    this.queuedTimer = null;
+    this.clearHandoffWait();
+    this.keepAwake.release('agent-run');
+    this.keepAwake.release('ai-turn');
+  }
+
+  private showProgress(message: string, progressType: string | null): void {
+    if (!this.machine.isActive() || message.length === 0) {
+      return;
+    }
+    if (isStepMessage(message, progressType)) {
+      this.showBubble(message);
+    } else {
+      this.status = { kind: 'text', text: message };
+    }
+    this.publish();
+  }
+
+  private showMessage(role: string, text: string, waitForResponse: boolean): void {
+    if (!this.machine.isActive()) {
+      return;
+    }
+    if (isBubbleRole(role) && text.length > 0) {
+      this.showBubble(text);
+      this.publish();
+    }
+    if (waitForResponse) {
+      this.exit();
+    }
+  }
+
+  private showQueued(message: string | null): void {
+    if (!this.machine.isActive()) {
+      return;
+    }
+    this.clearTimer(this.queuedTimer);
+    this.queued = { message };
+    this.queuedTimer = this.timers.set(() => {
+      this.queuedTimer = null;
+      this.queued = null;
+      this.publish();
+    }, QUEUED_CHIP_MS);
+    this.publish();
+  }
+
+  private showBubble(text: string): void {
+    if (isShowing(this.bubbles, text)) {
+      return;
+    }
+    this.bubbleCounter += 1;
+    const id = `bubble-${this.bubbleCounter}`;
+    this.bubbles = [...this.bubbles, { id, text, leaving: false }];
+    const leave = this.timers.set(() => {
+      this.bubbles = markLeaving(this.bubbles, id);
+      this.publish();
+      const remove = this.timers.set(() => {
+        this.bubbleTimers.delete(id);
+        this.bubbles = without(this.bubbles, id);
+        this.publish();
+      }, BUBBLE_EXIT_MS);
+      this.bubbleTimers.set(id, [remove]);
+    }, readingTimeMs(text));
+    this.bubbleTimers.set(id, [leave]);
+  }
+
+  private replaceBubbles(next: AgentBubble[]): void {
+    const kept = new Set(next.map((bubble) => bubble.id));
+    for (const [id, handles] of this.bubbleTimers) {
+      if (!kept.has(id)) {
+        handles.forEach((handle) => this.timers.clear(handle));
+        this.bubbleTimers.delete(id);
+      }
+    }
+    this.bubbles = next;
+  }
+
+  private noteActivity(): void {
+    if (this.machine.isEngaged()) {
+      this.armWatchdog();
+      this.rememberRun();
+    }
+  }
+
+  private rememberRun(): void {
+    if (this.machine.isEngaged()) {
+      this.memory.remember(this.timers.now());
+    }
+  }
+
+  private beginHandoffWait(): void {
+    this.clearHandoffWait();
+    this.absorbCompletion = true;
+    this.armHandoffWatchdog();
+  }
+
+  private armHandoffWatchdog(): void {
+    this.clearTimer(this.handoffWatchdog);
+    this.handoffWatchdog = this.timers.set(() => {
+      this.handoffWatchdog = null;
+      this.absorbCompletion = false;
+      if (this.machine.isEngaged()) {
+        this.exit();
+      }
+    }, HANDOFF_WAIT_MS);
+  }
+
+  private noteHandoffActivity(): void {
+    if (this.absorbCompletion) {
+      this.armHandoffWatchdog();
+    } else if (this.handoffWatchdog !== null) {
+      this.clearHandoffWait();
+    }
+  }
+
+  private clearHandoffWait(): void {
+    this.absorbCompletion = false;
+    this.clearTimer(this.handoffWatchdog);
+    this.handoffWatchdog = null;
+  }
+
+  private armWatchdog(): void {
+    this.clearTimer(this.watchdog);
+    this.watchdog = this.timers.set(() => {
+      this.watchdog = null;
+      this.latch();
+      this.exit();
+    }, RUN_IDLE_TIMEOUT_MS);
+  }
+
+  private clearTimer(handle: unknown): void {
+    if (handle !== null) {
+      this.timers.clear(handle);
+    }
+  }
+
+  private publish(): void {
+    this.snapshot = this.buildSnapshot();
+    this.listeners.forEach((listener) => listener(this.snapshot));
+  }
+
+  private buildSnapshot(): AgentModeSnapshot {
+    return { phase: this.machine.getPhase(), status: this.status, bubbles: this.bubbles, queued: this.queued };
+  }
+}

package/src/agent-mode/cursor-follow.ts

@@ -0,0 +1,43 @@
+import type { Clock } from '../actions/settle.ts';
+import type { Rect } from '../host/rect.ts';
+
+export const FOLLOW_MIN_MS = 350;
+export const FOLLOW_MAX_MS = 1400;
+export const FOLLOW_POLL_MS = 33;
+
+const SETTLE_STABLE_SAMPLES = 2;
+
+export interface Follow {
+  measure: () => Promise<Rect | null>;
+  place: (rect: Rect) => void;
+  isLive: () => boolean;
+  clock: Clock;
+}
+
+function sameRect(first: Rect | null, second: Rect): boolean {
+  return first !== null && first.x === second.x && first.y === second.y && first.width === second.width && first.height === second.height;
+}
+
+export async function followUntilLanded({ measure, place, isLive, clock }: Follow): Promise<void> {
+  const startedAt = clock.now();
+  let last: Rect | null = null;
+  let stable = 0;
+  for (;;) {
+    const rect = await measure();
+    if (!isLive()) {
+      return;
+    }
+    if (rect !== null && !sameRect(last, rect)) {
+      last = rect;
+      stable = 0;
+      place(rect);
+    } else {
+      stable += 1;
+    }
+    const elapsed = clock.now() - startedAt;
+    if ((stable >= SETTLE_STABLE_SAMPLES && elapsed >= FOLLOW_MIN_MS) || elapsed > FOLLOW_MAX_MS) {
+      return;
+    }
+    await clock.sleep(FOLLOW_POLL_MS);
+  }
+}

package/src/agent-mode/cursor.ts

@@ -0,0 +1,118 @@
+import type { Clock } from '../actions/settle.ts';
+import type { Rect } from '../host/rect.ts';
+import { followUntilLanded } from './cursor-follow.ts';
+
+export interface CursorSnapshot {
+  tap: number;
+  target: Rect | null;
+  landed: boolean;
+}
+
+export interface CursorEnvironment {
+  clock: Clock;
+  isForeground: () => boolean;
+}
+
+type Listener = (snapshot: CursorSnapshot) => void;
+
+export const ATTACH_MAX_MS = 1000;
+export const PRESS_MS = 450;
+
+export class CursorController {
+  private snapshot: CursorSnapshot = { tap: 0, target: null, landed: false };
+
+  private readonly listeners = new Set<Listener>();
+
+  private arrival: Promise<void> = Promise.resolve();
+
+  private sessionEnded = false;
+
+  private move = 0;
+
+  private attached = false;
+
+  private onAttached: (() => void) | null = null;
+
+  constructor(private readonly environment: CursorEnvironment) {}
+
+  getSnapshot(): CursorSnapshot {
+    return this.snapshot;
+  }
+
+  subscribe(listener: Listener): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  beginSession(): void {
+    this.sessionEnded = false;
+  }
+
+  moveTo(measure: () => Promise<Rect | null>): void {
+    if (this.sessionEnded) {
+      return;
+    }
+    this.move += 1;
+    const move = this.move;
+    this.publish({ tap: move, target: null, landed: false });
+    this.arrival = this.tap(measure, move, () => !this.sessionEnded && move === this.move);
+  }
+
+  attach(): void {
+    this.attached = true;
+    this.onAttached?.();
+    this.onAttached = null;
+  }
+
+  detach(): void {
+    this.attached = false;
+  }
+
+  whenLanded(): Promise<void> {
+    return this.arrival;
+  }
+
+  endSession(): void {
+    this.sessionEnded = true;
+    this.move += 1;
+    if (this.snapshot.target !== null) {
+      this.publish({ ...this.snapshot, target: null });
+    }
+  }
+
+  private async tap(measure: () => Promise<Rect | null>, move: number, isLive: () => boolean): Promise<void> {
+    if (!this.environment.isForeground()) {
+      return;
+    }
+    await this.untilAttached();
+    if (!isLive()) {
+      return;
+    }
+    const place = (target: Rect): void => this.publish({ tap: move, target, landed: false });
+    await followUntilLanded({ measure, place, isLive, clock: this.environment.clock });
+    if (!isLive() || this.snapshot.target === null) {
+      return;
+    }
+    this.publish({ ...this.snapshot, landed: true });
+    void this.environment.clock.sleep(PRESS_MS).then(() => {
+      if (isLive()) {
+        this.publish({ ...this.snapshot, target: null });
+      }
+    });
+  }
+
+  private untilAttached(): Promise<void> {
+    if (this.attached) {
+      return Promise.resolve();
+    }
+    const attached = new Promise<void>((resolve) => {
+      this.onAttached = resolve;
+    });
+    return Promise.race([attached, this.environment.clock.sleep(ATTACH_MAX_MS)]);
+  }
+
+  private publish(next: CursorSnapshot): void {
+    this.snapshot = next;
+    this.listeners.forEach((listener) => listener(next));
+  }
+}

package/src/agent-mode/frames.ts

@@ -0,0 +1,70 @@
+import { isRecord, nonEmptyString, type UnknownRecord } from '../fiber/narrow.ts';
+
+export type AgentModeEvent =
+  | { kind: 'progress'; message: string; progressType: string | null }
+  | { kind: 'message'; role: string; text: string; waitForResponse: boolean }
+  | { kind: 'queued'; message: string | null }
+  | { kind: 'execution_complete' }
+  | { kind: 'acknowledged' }
+  | { kind: 'cancelled' }
+  | { kind: 'session_closed' }
+  | { kind: 'history'; agentModeActive: boolean; intent: string | null; agentStatus: string | null }
+  | { kind: 'thinking' }
+  | { kind: 'thinking_stop' }
+  | { kind: 'session_started'; sessionId: number };
+
+const BUBBLE_ROLES: readonly string[] = ['ai', 'agent', 'system'];
+
+function readMessage(message: unknown): AgentModeEvent | null {
+  if (!isRecord(message) || message.is_draft === true || message.is_ephemeral === true) {
+    return null;
+  }
+  const role = nonEmptyString(message.role);
+  if (role === null) {
+    return null;
+  }
+  const text = nonEmptyString(message.text) ?? nonEmptyString(message.body) ?? '';
+  return { kind: 'message', role, text, waitForResponse: message.wait_for_response === true };
+}
+
+function readHistory(frame: UnknownRecord): AgentModeEvent {
+  return {
+    kind: 'history',
+    agentModeActive: frame.agent_mode_active === true,
+    intent: nonEmptyString(frame.agent_mode_intent),
+    agentStatus: nonEmptyString(frame.agent_status),
+  };
+}
+
+export function readAgentModeEvent(frame: UnknownRecord): AgentModeEvent | null {
+  switch (frame.type) {
+    case 'ai_progress':
+      return { kind: 'progress', message: typeof frame.message === 'string' ? frame.message : '', progressType: nonEmptyString(frame.progress_type) };
+    case 'message':
+      return readMessage(frame.message);
+    case 'message_queued':
+      return { kind: 'queued', message: nonEmptyString(frame.message) };
+    case 'agent_execution_complete':
+      return { kind: 'execution_complete' };
+    case 'agent_acknowledged':
+      return { kind: 'acknowledged' };
+    case 'agent_cancelled':
+      return { kind: 'cancelled' };
+    case 'session_closed':
+      return { kind: 'session_closed' };
+    case 'history':
+      return readHistory(frame);
+    case 'ai_thinking':
+      return { kind: 'thinking' };
+    case 'ai_thinking_stop':
+      return { kind: 'thinking_stop' };
+    case 'activation_session_started':
+      return typeof frame.session_id === 'number' ? { kind: 'session_started', sessionId: frame.session_id } : null;
+    default:
+      return null;
+  }
+}
+
+export function isBubbleRole(role: string): boolean {
+  return BUBBLE_ROLES.includes(role);
+}