feat(stage-tamagotchi,computer-use-mcp): implement browser-native DOM action routing

apps/stage-tamagotchi/electron.vite.config.ts

@@ -133,6 +133,11 @@ export default defineConfig({
       alias: {
         '@proj-airi/server-sdk': resolve(join(import.meta.dirname, '..', '..', 'packages', 'server-sdk', 'src')),
         '@proj-airi/i18n': resolve(join(import.meta.dirname, '..', '..', 'packages', 'i18n', 'src')),
+        // NOTICE: the @proj-airi/stage-ui alias resolves to a directory; rolldown
+        // concatenates sub-paths without a file extension, so bare .ts files at the
+        // stores/ root (e.g. mcp-tool-bridge.ts) are not found.  Add explicit aliases
+        // for each such file that the renderer imports from @proj-airi/stage-ui.
+        '@proj-airi/stage-ui/stores/mcp-tool-bridge': resolve(join(import.meta.dirname, '..', '..', 'packages', 'stage-ui', 'src', 'stores', 'mcp-tool-bridge.ts')),
         '@proj-airi/stage-ui': resolve(join(import.meta.dirname, '..', '..', 'packages', 'stage-ui', 'src')),
         '@proj-airi/stage-pages': resolve(join(import.meta.dirname, '..', '..', 'packages', 'stage-pages', 'src')),
         '@proj-airi/stage-shared': resolve(join(import.meta.dirname, '..', '..', 'packages', 'stage-shared', 'src')),

apps/stage-tamagotchi/src/main/index.ts

@@ -207,7 +207,7 @@ app.whenReady().then(async () => {
     // provider depends on 'windows:desktop-overlay'.
     injeca.invoke({
       dependsOn: { desktopOverlay },
-      callback: noop,
+      callback: () => {},
     })
   }
 

apps/stage-tamagotchi/src/renderer/pages/desktop-overlay-polling.test.ts

@@ -1,5 +1,4 @@
-import type { McpCallToolResult } from '@proj-airi/stage-ui/tools/mcp'
-
+import type { ElectronMcpCallToolResult } from '../../shared/eventa'
 import type { OverlayState } from './desktop-overlay-polling'
 
 import { afterEach, describe, expect, it, vi } from 'vitest'
@@ -162,7 +161,7 @@ describe('createOverlayPollController', () => {
   it('calls tool and delivers state on successful poll', async () => {
     vi.useFakeTimers()
 
-    const mockResult: McpCallToolResult = {
+    const mockResult: ElectronMcpCallToolResult = {
       structuredContent: {
         runState: {
           lastGroundingSnapshot: {
@@ -176,7 +175,7 @@ describe('createOverlayPollController', () => {
       },
     }
 
-    const callTool = vi.fn<(name: string) => Promise<McpCallToolResult>>()
+    const callTool = vi.fn<(name: string) => Promise<ElectronMcpCallToolResult>>()
       .mockResolvedValue(mockResult)
 
     const received: OverlayState[] = []
@@ -201,32 +200,10 @@ describe('createOverlayPollController', () => {
     controller.stop()
   })
 
-  it('clears the per-call timeout when the tool resolves before the timeout fires', async () => {
-    vi.useFakeTimers()
-
-    const callTool = vi.fn<(name: string) => Promise<McpCallToolResult>>()
-      .mockResolvedValue({ structuredContent: {} })
-
-    const controller = createOverlayPollController({
-      callTool,
-      onState: () => {},
-      intervalMs: 100,
-      callTimeoutMs: 500,
-    })
-
-    controller.start()
-    await vi.advanceTimersByTimeAsync(0)
-
-    // Only the next poll should remain scheduled. The per-call timeout must be cleared.
-    expect(vi.getTimerCount()).toBe(1)
-
-    controller.stop()
-  })
-
   it('stops polling after stop() is called', async () => {
     vi.useFakeTimers()
 
-    const callTool = vi.fn<(name: string) => Promise<McpCallToolResult>>()
+    const callTool = vi.fn<(name: string) => Promise<ElectronMcpCallToolResult>>()
       .mockResolvedValue({ structuredContent: {} })
 
     const controller = createOverlayPollController({
@@ -250,7 +227,7 @@ describe('createOverlayPollController', () => {
   it('continues polling after a single failure', async () => {
     vi.useFakeTimers()
 
-    const callTool = vi.fn<(name: string) => Promise<McpCallToolResult>>()
+    const callTool = vi.fn<(name: string) => Promise<ElectronMcpCallToolResult>>()
       .mockRejectedValueOnce(new Error('MCP down'))
       .mockResolvedValue({
         structuredContent: {
@@ -292,7 +269,7 @@ describe('createOverlayPollController', () => {
   it('is a no-op to call start() twice', async () => {
     vi.useFakeTimers()
 
-    const callTool = vi.fn<(name: string) => Promise<McpCallToolResult>>()
+    const callTool = vi.fn<(name: string) => Promise<ElectronMcpCallToolResult>>()
       .mockResolvedValue({ structuredContent: {} })
 
     const controller = createOverlayPollController({
@@ -313,8 +290,9 @@ describe('createOverlayPollController', () => {
   it('recovers from a hanging callTool via per-call timeout', async () => {
     vi.useFakeTimers()
 
-    const callTool = vi.fn<(name: string) => Promise<McpCallToolResult>>()
-      .mockImplementationOnce(() => new Promise<McpCallToolResult>(() => {}))
+    // First call hangs forever (simulates startup race when RPC not ready)
+    const callTool = vi.fn<(name: string) => Promise<ElectronMcpCallToolResult>>()
+      .mockImplementationOnce(() => new Promise(() => {})) // never resolves
       .mockResolvedValue({
         structuredContent: {
           runState: {
@@ -344,97 +322,15 @@ describe('createOverlayPollController', () => {
     expect(callTool).toHaveBeenCalledTimes(1)
     expect(received).toHaveLength(0)
 
-    // Advance past the timeout and several fallback windows. The controller
-    // should allow a bounded recovery retry even though the original invoke
-    // is still hung in the background.
-    await vi.advanceTimersByTimeAsync(500)
-    await vi.advanceTimersByTimeAsync(200)
-    expect(callTool).toHaveBeenCalledTimes(2)
-    expect(received).toHaveLength(1)
-    expect(received[0].snapshotId).toBe('dg_after_timeout')
-
-    controller.stop()
-  })
-
-  it('caps outstanding timed-out polls to avoid unbounded buildup', async () => {
-    vi.useFakeTimers()
-
-    const callTool = vi.fn<(name: string) => Promise<McpCallToolResult>>()
-      .mockImplementation(() => new Promise<McpCallToolResult>(() => {}))
-
-    const controller = createOverlayPollController({
-      callTool,
-      onState: () => {},
-      intervalMs: 100,
-      fallbackIntervalMs: 200,
-      callTimeoutMs: 500,
-    })
-
-    controller.start()
-
-    await vi.advanceTimersByTimeAsync(0)
-    expect(callTool).toHaveBeenCalledTimes(1)
-
-    await vi.advanceTimersByTimeAsync(500)
-    await vi.advanceTimersByTimeAsync(200)
-    expect(callTool).toHaveBeenCalledTimes(2)
-
+    // Advance past the 500ms timeout → catch triggers, schedules fallback
     await vi.advanceTimersByTimeAsync(500)
-    await vi.advanceTimersByTimeAsync(1000)
-    expect(callTool).toHaveBeenCalledTimes(2)
-
-    controller.stop()
-  })
-
-  it('recovers again once a timed-out hung-call slot lease expires', async () => {
-    vi.useFakeTimers()
-
-    const callTool = vi.fn<(name: string) => Promise<McpCallToolResult>>()
-      .mockImplementationOnce(() => new Promise<McpCallToolResult>(() => {}))
-      .mockImplementationOnce(() => new Promise<McpCallToolResult>(() => {}))
-      .mockResolvedValue({
-        structuredContent: {
-          runState: {
-            lastGroundingSnapshot: {
-              snapshotId: 'dg_after_lease',
-              targetCandidates: [],
-              staleFlags: { screenshot: false, ax: false, chromeSemantic: false },
-            },
-          },
-        },
-      })
-
-    const received: OverlayState[] = []
-
-    const controller = createOverlayPollController({
-      callTool,
-      onState: (state) => {
-        received.push(state)
-      },
-      intervalMs: 100,
-      fallbackIntervalMs: 200,
-      callTimeoutMs: 500,
-      hungCallLeaseMs: 1000,
-    })
-
-    controller.start()
-
-    await vi.advanceTimersByTimeAsync(0)
-    expect(callTool).toHaveBeenCalledTimes(1)
-
-    await vi.advanceTimersByTimeAsync(500)
-    await vi.advanceTimersByTimeAsync(200)
-    expect(callTool).toHaveBeenCalledTimes(2)
-
-    await vi.advanceTimersByTimeAsync(500)
-    await vi.advanceTimersByTimeAsync(200)
-    expect(callTool).toHaveBeenCalledTimes(2)
     expect(received).toHaveLength(0)
 
+    // Advance past the 200ms fallback interval → second poll fires and succeeds
     await vi.advanceTimersByTimeAsync(200)
-    expect(callTool).toHaveBeenCalledTimes(3)
+    expect(callTool).toHaveBeenCalledTimes(2)
     expect(received).toHaveLength(1)
-    expect(received[0].snapshotId).toBe('dg_after_lease')
+    expect(received[0].snapshotId).toBe('dg_after_timeout')
 
     controller.stop()
   })

apps/stage-tamagotchi/src/renderer/pages/desktop-overlay-polling.ts

@@ -5,7 +5,7 @@
  * without a DOM environment or Vue test-utils.
  */
 
-import type { McpCallToolResult } from '@proj-airi/stage-ui/tools/mcp'
+import type { ElectronMcpCallToolResult } from '../../shared/eventa'
 
 // ---------------------------------------------------------------------------
 // Types — minimal shapes matching RunState fields the overlay consumes
@@ -90,7 +90,7 @@ export function extractOverlayState(runState: Record<string, unknown>): OverlayS
  * Extract runState from an MCP call result.
  * Returns undefined if the result is an error or has no structured content.
  */
-export function extractRunStateFromResult(result: McpCallToolResult): Record<string, unknown> | undefined {
+export function extractRunStateFromResult(result: ElectronMcpCallToolResult): Record<string, unknown> | undefined {
   if (result.isError)
     return undefined
 
@@ -121,7 +121,7 @@ export interface OverlayPollController {
 
 export interface OverlayPollConfig {
   /** Function to call MCP tool. */
-  callTool: (name: string) => Promise<McpCallToolResult>
+  callTool: (name: string) => Promise<ElectronMcpCallToolResult>
   /** Callback with extracted state on each successful poll. */
   onState: (state: OverlayState) => void
   /** Normal poll interval in ms. Default: 250. */
@@ -130,15 +130,11 @@ export interface OverlayPollConfig {
   fallbackIntervalMs?: number
   /** Per-call timeout in ms. Default: 5000. Prevents poll loop hang on startup race. */
   callTimeoutMs?: number
-  /** How long a timed-out background call occupies a recovery slot before we probe again. */
-  hungCallLeaseMs?: number
 }
 
 const DEFAULT_INTERVAL = 250
 const DEFAULT_FALLBACK_INTERVAL = 500
 const DEFAULT_CALL_TIMEOUT = 5000
-const DEFAULT_HUNG_CALL_LEASE = 5000
-const MAX_BACKGROUND_HUNG_CALLS = 2
 
 /**
  * MCP server name for computer-use-mcp. Matches the key in mcp.json.
@@ -152,75 +148,21 @@ export const MCP_TOOL_NAME = 'computer_use::desktop_get_state'
 export function createOverlayPollController(config: OverlayPollConfig): OverlayPollController {
   const normalInterval = config.intervalMs ?? DEFAULT_INTERVAL
   const fallbackInterval = config.fallbackIntervalMs ?? DEFAULT_FALLBACK_INTERVAL
-  const hungCallLeaseMs = config.hungCallLeaseMs ?? DEFAULT_HUNG_CALL_LEASE
 
   let timer: ReturnType<typeof setTimeout> | null = null
   let running = false
-  let inFlightCall: Promise<McpCallToolResult> | null = null
-  let backgroundHungSlots: Array<{ expiresAt: number }> = []
-
-  function scheduleNext(nextInterval: number) {
-    if (running) {
-      timer = setTimeout(poll, nextInterval)
-    }
-  }
-
-  function pruneHungCallSlots(now: number) {
-    backgroundHungSlots = backgroundHungSlots.filter(slot => slot.expiresAt > now)
-  }
 
   async function poll() {
-    pruneHungCallSlots(Date.now())
-
-    if (inFlightCall || backgroundHungSlots.length >= MAX_BACKGROUND_HUNG_CALLS) {
-      scheduleNext(fallbackInterval)
-      return
-    }
-
     let nextInterval = normalInterval
-    let timeoutId: ReturnType<typeof setTimeout> | undefined
 
     try {
       // NOTICE: Wrap callTool with a timeout to prevent the poll loop from
       // hanging forever if the eventa invoke never resolves (e.g. during
       // startup when the main-process RPC handlers may not be ready yet).
-      // NOTICE: The bridge does not expose abort semantics, so a timed-out
-      // call may still be pending in the background. We therefore track
-      // timed-out calls as expiring lease slots: the cap bounds how many
-      // unrecoverable invokes we tolerate at once, while lease expiry still
-      // lets the overlay probe again after a cooling-off window.
-      let timedOutSlot: { expiresAt: number } | null = null
-      const currentCall = config.callTool(MCP_TOOL_NAME)
-      inFlightCall = currentCall
-      currentCall.then(() => {
-        if (timedOutSlot) {
-          backgroundHungSlots = backgroundHungSlots.filter(slot => slot !== timedOutSlot)
-        }
-        else if (inFlightCall === currentCall) {
-          inFlightCall = null
-        }
-      }, () => {
-        if (timedOutSlot) {
-          backgroundHungSlots = backgroundHungSlots.filter(slot => slot !== timedOutSlot)
-        }
-        else if (inFlightCall === currentCall) {
-          inFlightCall = null
-        }
-      })
-
       const result = await Promise.race([
-        currentCall,
+        config.callTool(MCP_TOOL_NAME),
         new Promise<never>((_, reject) =>
-          timeoutId = setTimeout(() => {
-            timedOutSlot = {
-              expiresAt: Date.now() + hungCallLeaseMs,
-            }
-            backgroundHungSlots = [...backgroundHungSlots, timedOutSlot]
-            if (inFlightCall === currentCall) {
-              inFlightCall = null
-            }
-            reject(new Error('callTool timeout'))
-          }, config.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT),
+          setTimeout(() => reject(new Error('callTool timeout')), config.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT),
         ),
       ])
       const runState = extractRunStateFromResult(result)
@@ -236,13 +178,10 @@ export function createOverlayPollController(config: OverlayPollConfig): OverlayP
       // MCP server not running, bridge disconnected, or timeout — graceful degradation
       nextInterval = fallbackInterval
     }
-    finally {
-      if (timeoutId !== undefined) {
-        clearTimeout(timeoutId)
-      }
-    }
 
-    scheduleNext(nextInterval)
+    if (running) {
+      timer = setTimeout(poll, nextInterval)
+    }
   }
 
   return {