@adhdev/daemon-core 0.5.20 → 0.5.23

package/src/agent-stream/manager.ts

@@ -145,7 +145,7 @@ export class DaemonAgentStreamManager {
             } else {
                 try {
                     const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                        cdp.evaluateInSession(agent.sessionId, expr, timeout);
+                        cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
                     const state = await agent.adapter.readChat(evaluate);
                     agent.lastState = state;
                     agent.lastError = null;
@@ -183,7 +183,7 @@ export class DaemonAgentStreamManager {
         if (!agent) return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSession(agent.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
             await agent.adapter.sendMessage(evaluate, text);
             return true;
         } catch (e) {
@@ -198,7 +198,7 @@ export class DaemonAgentStreamManager {
         if (!agent) return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSession(agent.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
             return await agent.adapter.resolveAction(evaluate, action);
         } catch (e) {
             this.logFn(`[AgentStream] resolveAction(${agentType}) error: ${(e as Error).message}`);
@@ -212,7 +212,7 @@ export class DaemonAgentStreamManager {
         if (!agent) return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSession(agent.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
             await agent.adapter.newSession(evaluate);
             return true;
         } catch (e) {
@@ -233,7 +233,7 @@ export class DaemonAgentStreamManager {
         if (!agent || typeof agent.adapter.listChats !== 'function') return [];
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSession(agent!.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent!.sessionId, expr, timeout);
             return await agent.adapter.listChats(evaluate);
         } catch (e) {
             this.logFn(`[AgentStream] listChats(${agentType}) error: ${(e as Error).message}`);
@@ -252,7 +252,7 @@ export class DaemonAgentStreamManager {
         if (!agent || typeof agent.adapter.switchSession !== 'function') return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSession(agent!.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent!.sessionId, expr, timeout);
             return await agent.adapter.switchSession(evaluate, sessionId);
         } catch (e) {
             this.logFn(`[AgentStream] switchSession(${agentType}) error: ${(e as Error).message}`);
@@ -265,7 +265,7 @@ export class DaemonAgentStreamManager {
         if (!agent || typeof agent.adapter.focusEditor !== 'function') return false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
-                cdp.evaluateInSession(agent.sessionId, expr, timeout);
+                cdp.evaluateInSessionFrame(agent.sessionId, expr, timeout);
             await agent.adapter.focusEditor(evaluate);
             return true;
         } catch (e) {

package/src/cdp/devtools.ts

@@ -115,7 +115,7 @@ export class CdpDomHandlers {
 
             let result;
             if (sessionId) {
-                result = await this.getCdp()!.evaluateInSession(sessionId, expression);
+                result = await this.getCdp()!.evaluateInSessionFrame(sessionId, expression);
             } else {
                 result = await this.getCdp()!.evaluate(expression, 30000);
             }
@@ -182,7 +182,7 @@ export class CdpDomHandlers {
         try {
             let raw;
             if (sessionId) {
-                raw = await this.getCdp()!.evaluateInSession(sessionId, expression);
+                raw = await this.getCdp()!.evaluateInSessionFrame(sessionId, expression);
             } else {
                 raw = await this.getCdp()!.evaluate(expression, 15000);
             }
@@ -321,7 +321,7 @@ export class CdpDomHandlers {
         try {
             let raw;
             if (sessionId) {
-                raw = await this.getCdp()!.evaluateInSession(sessionId, expression);
+                raw = await this.getCdp()!.evaluateInSessionFrame(sessionId, expression);
             } else {
                 raw = await this.getCdp()!.evaluate(expression, 30000);
             }

package/src/cdp/manager.ts

@@ -839,6 +839,72 @@ export class DaemonCdpManager {
         });
     }
 
+ /**
+  * Evaluate inside the child frame of an attached session.
+  * Extension webviews have a nested iframe structure:
+  *   outer (vscode-webview://) → inner (extension React app)
+  * This method navigates into the inner frame using CDP Page.getFrameTree.
+  * Falls back to evaluateInSession if no child frame is found.
+  */
+    async evaluateInSessionFrame(sessionId: string, expression: string, timeoutMs = 15000): Promise<unknown> {
+        const ws = this._browserConnected ? this.browserWs : this.ws;
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            throw new Error('CDP not connected');
+        }
+
+        const sendViaSession = (method: string, params: Record<string, unknown> = {}): Promise<any> => {
+            return new Promise((resolve, reject) => {
+                const pendingMap = this._browserConnected ? this.browserPending : this.pending;
+                const id = this._browserConnected ? this.browserMsgId++ : this.msgId++;
+                pendingMap.set(id, { resolve, reject });
+                ws.send(JSON.stringify({ id, sessionId, method, params }));
+                setTimeout(() => {
+                    if (pendingMap.has(id)) {
+                        pendingMap.delete(id);
+                        reject(new Error(`CDP session timeout: ${method}`));
+                    }
+                }, timeoutMs);
+            });
+        };
+
+        try {
+            // 1. Get frame tree to find child frame
+            const { frameTree } = await sendViaSession('Page.getFrameTree');
+            const childFrame = frameTree?.childFrames?.[0]?.frame;
+
+            if (!childFrame) {
+                // No child frame — fall back to outer frame evaluation
+                return this.evaluateInSession(sessionId, expression, timeoutMs);
+            }
+
+            // 2. Create isolated world in the child frame
+            const { executionContextId } = await sendViaSession('Page.createIsolatedWorld', {
+                frameId: childFrame.id,
+                worldName: 'adhdev-agent-eval',
+                grantUniveralAccess: true,
+            });
+
+            // 3. Evaluate expression in isolated world
+            const result = await sendViaSession('Runtime.evaluate', {
+                expression,
+                returnByValue: true,
+                awaitPromise: true,
+                contextId: executionContextId,
+            });
+
+            if (result?.result?.subtype === 'error') {
+                throw new Error(result.result.description);
+            }
+            return result?.result?.value;
+        } catch (e) {
+            // On Page.getFrameTree failure, fall back to direct session evaluation
+            if ((e as Error).message?.includes('getFrameTree')) {
+                return this.evaluateInSession(sessionId, expression, timeoutMs);
+            }
+            throw e;
+        }
+    }
+
     async detachAgent(sessionId: string): Promise<void> {
         try {
             const sendFn = this._browserConnected ? this.sendBrowser.bind(this) : this.sendInternal.bind(this);

package/src/commands/handler.ts

@@ -155,7 +155,7 @@ export class DaemonCommandHandler implements CommandHelpers {
                 sessionId = this.getExtensionSessionId(provider);
             }
             if (!sessionId) return null;
-            const result = await cdp.evaluateInSession(sessionId, script, timeout);
+            const result = await cdp.evaluateInSessionFrame(sessionId, script, timeout);
             return { result, category: 'extension' };
         }
 

package/src/commands/stream-commands.ts

@@ -252,7 +252,7 @@ export async function handleExtensionScript(h: CommandHelpers, args: any, script
             if (!targetSessionId) {
                 return { success: false, error: `No active session found for ${agentType}` };
             }
-            result = await cdp.evaluateInSession(targetSessionId, scriptCode);
+            result = await cdp.evaluateInSessionFrame(targetSessionId, scriptCode);
         } else if (hasWebviewScript && cdp.evaluateInWebviewFrame) {
             const matchText = provider.webviewMatchText;
             const matchFn = matchText ? (body: string) => body.includes(matchText) : undefined;