@adhdev/daemon-core 0.5.41 → 0.5.43

package/providers/_builtin/extension/codex/scripts/1.0/send_message.js

@@ -12,35 +12,15 @@
     
     // Find ProseMirror editor
     const editor = document.querySelector('.ProseMirror');
-    if (!editor) return JSON.stringify({ error: 'ProseMirror editor not found' });
+    if (!editor) return JSON.stringify({ error: 'Editor not found' });
 
     // Focus the editor
     editor.focus();
 
-    // Clear existing content
-    const existingP = editor.querySelector('p');
-    if (existingP) {
-      existingP.textContent = message;
-      // Dispatch input event for ProseMirror to detect the change
-      editor.dispatchEvent(new InputEvent('input', {
-        bubbles: true,
-        cancelable: true,
-        inputType: 'insertText',
-        data: message,
-      }));
-    } else {
-      // Fallback: create new paragraph
-      const p = document.createElement('p');
-      p.textContent = message;
-      editor.innerHTML = '';
-      editor.appendChild(p);
-      editor.dispatchEvent(new InputEvent('input', {
-        bubbles: true,
-        cancelable: true,
-        inputType: 'insertText',
-        data: message,
-      }));
-    }
+    // Use execCommand to safely insert text. This avoids TrustedHTML errors 
+    // and naturally triggers ProseMirror's state updates and Keyboard/Input events.
+    document.execCommand('selectAll', false, null);
+    document.execCommand('insertText', false, message);
 
     // Wait a tick then submit via Enter key
     setTimeout(() => {

package/providers/_builtin/extension/codex/scripts/1.0/set_mode.js

@@ -0,0 +1,165 @@
+/**
+ * Codex Extension — set_mode
+ *
+ * Opens the mode dropdown (same discovery as list_modes), selects an item matching ${MODE}.
+ *
+ * Placeholder: ${MODE}
+ */
+(() => {
+  try {
+    const targetMode = ${MODE};
+
+    function resolveDoc() {
+      let doc = document;
+      let root = doc.getElementById('root');
+      if (!root) {
+        const iframes = doc.querySelectorAll('iframe');
+        for (const iframe of iframes) {
+          try {
+            const innerDoc = iframe.contentDocument || iframe.contentWindow?.document;
+            if (innerDoc?.getElementById('root')) {
+              doc = innerDoc;
+              root = innerDoc.getElementById('root');
+              break;
+            }
+          } catch (e) { /* cross-origin */ }
+        }
+      }
+      return { doc, root };
+    }
+
+    function isModelText(text) {
+      return /^(GPT-|gpt-|o\d|claude-|sonnet|opus)/i.test(text);
+    }
+
+    /**
+     * Find the mode menu button using multi-root strategy (matching readChat).
+     */
+    function findModeButton(doc) {
+      for (const d of [doc, document]) {
+        const searchRoots = [
+          d.querySelector('[class*="thread-composer-max-width"]'),
+          d.querySelector('[class*="thread-composer"]'),
+          d.querySelector('[class*="pb-2"]'),
+          d.body,
+        ].filter(Boolean);
+
+        for (const searchRoot of searchRoots) {
+          const menuBtns = Array.from(searchRoot.querySelectorAll('button[aria-haspopup="menu"]'))
+            .filter(b => b.offsetWidth > 0);
+          for (const btn of menuBtns) {
+            const text = (btn.textContent || '').trim();
+            if (!isModelText(text) && text.length > 0 && text.length < 30) {
+              return btn;
+            }
+          }
+        }
+      }
+      return null;
+    }
+
+    function openMenu(btn) {
+      const rect = btn.getBoundingClientRect();
+      const cx = rect.left + rect.width / 2;
+      const cy = rect.top + rect.height / 2;
+      btn.dispatchEvent(
+        new PointerEvent('pointerdown', { bubbles: true, clientX: cx, clientY: cy, pointerId: 1 }),
+      );
+      btn.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, clientX: cx, clientY: cy }));
+      btn.dispatchEvent(
+        new PointerEvent('pointerup', { bubbles: true, clientX: cx, clientY: cy, pointerId: 1 }),
+      );
+      btn.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, clientX: cx, clientY: cy }));
+      btn.dispatchEvent(new MouseEvent('click', { bubbles: true, clientX: cx, clientY: cy }));
+    }
+
+    function clickItem(el) {
+      const ir = el.getBoundingClientRect();
+      const ix = ir.left + ir.width / 2;
+      const iy = ir.top + ir.height / 2;
+      el.dispatchEvent(
+        new PointerEvent('pointerdown', { bubbles: true, clientX: ix, clientY: iy }),
+      );
+      el.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, clientX: ix, clientY: iy }));
+      el.dispatchEvent(new PointerEvent('pointerup', { bubbles: true, clientX: ix, clientY: iy }));
+      el.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, clientX: ix, clientY: iy }));
+      el.dispatchEvent(new MouseEvent('click', { bubbles: true, clientX: ix, clientY: iy }));
+    }
+
+    const { doc, root } = resolveDoc();
+    if (!root) return JSON.stringify({ success: false, error: 'no root' });
+
+    const want =
+      typeof targetMode === 'string'
+        ? targetMode.trim()
+        : targetMode != null
+          ? String(targetMode).trim()
+          : '';
+    if (!want) return JSON.stringify({ success: false, error: 'empty mode' });
+
+    const modeBtn = findModeButton(doc);
+    if (!modeBtn) return JSON.stringify({ success: false, error: 'mode menu button not found' });
+
+    const menuDoc = modeBtn.ownerDocument || doc;
+
+    const currentLabel = (modeBtn.textContent || '').trim();
+    if (currentLabel.toLowerCase() === want.toLowerCase()) {
+      return JSON.stringify({ success: true, mode: currentLabel, changed: false });
+    }
+
+    openMenu(modeBtn);
+
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        let menu = menuDoc.querySelector('[role="menu"][data-state="open"]');
+        if (!menu) menu = menuDoc.querySelector('[role="menu"]');
+
+        if (!menu) {
+          menuDoc.dispatchEvent(
+            new KeyboardEvent('keydown', { key: 'Escape', code: 'Escape', keyCode: 27, bubbles: true }),
+          );
+          return resolve(JSON.stringify({ success: false, error: 'mode menu did not open' }));
+        }
+
+        const items = Array.from(
+          menu.querySelectorAll(
+            '[role="menuitem"], [role="menuitemradio"], [role="option"], div[class*="cursor-interaction"]',
+          ),
+        );
+
+        const norm = (s) => (s || '').trim().toLowerCase();
+        const wantN = norm(want);
+
+        let match = items.find((el) => norm(el.textContent) === wantN);
+        if (!match) {
+          match = items.find((el) => norm(el.textContent).includes(wantN) || wantN.includes(norm(el.textContent)));
+        }
+
+        if (!match) {
+          menuDoc.dispatchEvent(
+            new KeyboardEvent('keydown', { key: 'Escape', code: 'Escape', keyCode: 27, bubbles: true }),
+          );
+          const available = items
+            .map((el) => (el.textContent || '').trim())
+            .filter((t) => t.length > 0 && t.length < 80);
+          return resolve(
+            JSON.stringify({
+              success: false,
+              error: `mode "${want}" not found`,
+              available,
+            }),
+          );
+        }
+
+        const picked = (match.textContent || '').trim();
+        clickItem(match);
+
+        setTimeout(() => {
+          resolve(JSON.stringify({ success: true, mode: picked, changed: true }));
+        }, 350);
+      }, 550);
+    });
+  } catch (e) {
+    return JSON.stringify({ success: false, error: e.message || String(e) });
+  }
+})();

package/src/config/chat-history.ts

@@ -164,16 +164,17 @@ export function readChatHistory(
         const dir = path.join(HISTORY_DIR, sanitized);
         if (!fs.existsSync(dir)) return { messages: [], hasMore: false };
 
- // JSONL file list — only matching prefix if instanceId is specified
+ // JSONL file list — filter by instanceId prefix if specified
         const sanitizedInstance = instanceId?.replace(/[^a-zA-Z0-9_-]/g, '_');
         const files = fs.readdirSync(dir)
             .filter(f => {
                 if (!f.endsWith('.jsonl')) return false;
                 if (sanitizedInstance) {
+                    // With instanceId: only that instance's files
                     return f.startsWith(`${sanitizedInstance}_`);
                 }
- // Without instanceId, only files without prefix (legacy compatible)
-                return !f.includes('_') || f.match(/^\d{4}-\d{2}-\d{2}\.jsonl$/);
+                // Without instanceId: include ALL files (legacy + instanced)
+                return true;
             })
             .sort()
             .reverse();

package/src/config/config.ts

@@ -30,6 +30,12 @@ export interface ADHDevConfig {
 
  // User preferences
     autoConnect: boolean;
+    /**
+     * @deprecated Not read at runtime. Notification preferences are now managed by:
+     * - Web UI layer: useNotificationPrefs (localStorage)
+     * - Daemon layer: per-provider settings (approvalAlert, longGeneratingAlert)
+     * Kept for backward config compat — will be removed in v0.7+.
+     */
     notifications: boolean;
 
  // Auth

package/src/providers/ide-provider-instance.ts

@@ -36,6 +36,7 @@ export class IdeProviderInstance implements ProviderInstance {
     private tickBusy = false;
     private monitor: StatusMonitor;
     private historyWriter: ChatHistoryWriter;
+    private autoApproveBusy = false;
 
  // IDE meta
     private ideVersion: string = '';
@@ -361,6 +362,11 @@ export class IdeProviderInstance implements ProviderInstance {
             this.lastAgentStatuses.set(agentKey, agentStatus);
         }
 
+ // Auto-approve: when waiting_approval + settings.autoApprove → auto-click approve via CDP
+        if (agentStatus === 'waiting_approval' && this.settings.autoApprove && !this.autoApproveBusy) {
+            this.autoApproveViaScript(chatData);
+        }
+
  // Monitor check (cooldown based notification)
         const monitorEvents = this.monitor.check(agentKey, agentStatus, now);
         for (const me of monitorEvents) {
@@ -384,4 +390,40 @@ export class IdeProviderInstance implements ProviderInstance {
     updateCdp(cdp: InstanceContext['cdp']): void {
         if (this.context) this.context.cdp = cdp;
     }
+
+ // ─── Auto-approve via CDP script ────────────────────
+
+    private async autoApproveViaScript(_chatData: any): Promise<void> {
+        const cdp = this.context?.cdp;
+        if (!cdp?.isConnected) return;
+
+        // Check if provider has resolveAction script
+        const scriptFn = this.provider.scripts?.resolveAction;
+        if (typeof scriptFn !== 'function') {
+            LOG.debug('IdeInstance', `[IdeInstance:${this.type}] autoApprove: no resolveAction script available`);
+            return;
+        }
+
+        this.autoApproveBusy = true;
+        try {
+            const script = scriptFn({ action: 'approve', button: '', buttonText: '' });
+            if (!script) return;
+
+            LOG.info('IdeInstance', `[IdeInstance:${this.type}] autoApprove: executing resolveAction`);
+            const result = await cdp.evaluate(script, 10000);
+            LOG.info('IdeInstance', `[IdeInstance:${this.type}] autoApprove result: ${JSON.stringify(result)?.slice(0, 200)}`);
+
+            this.pushEvent({
+                event: 'agent:auto_approved',
+                chatTitle: _chatData?.title || this.provider.name,
+                timestamp: Date.now(),
+                ideType: this.type,
+            });
+        } catch (e: any) {
+            LOG.warn('IdeInstance', `[IdeInstance:${this.type}] autoApprove error: ${e?.message}`);
+        } finally {
+            // Debounce: prevent rapid re-approval for at least 500ms
+            setTimeout(() => { this.autoApproveBusy = false; }, 500);
+        }
+    }
 }

package/src/providers/status-monitor.ts

@@ -1,28 +1,28 @@
 /**
- * StatusMonitor — status monitoring notification system
+ * StatusMonitor — Status monitoring notification system
  *
- * Common across all Provider categories (IDE/Extension/CLI).
- * - approval wait(waiting_approval) occur when notification
+ * Common across all Provider categories (IDE/Extension/CLI/ACP).
+ * - Approval waiting (waiting_approval) notification
  * - Notification when generating persists for extended duration
- * - all config Provider Settingstoggle possible
+ * - All config toggleable via Provider Settings
  */
 
 export interface MonitorConfig {
  /** Enable awaiting-approval notification */
     approvalAlert: boolean;
- /** prolonged generating notification enabled */
+ /** Prolonged generating notification enabled */
     longGeneratingAlert: boolean;
  /** Prolonged threshold (seconds) */
     longGeneratingThresholdSec: number;
- /** repeat notification cooldown (seconds) */
+ /** Repeat notification cooldown (seconds) */
     alertCooldownSec: number;
 }
 
 export const DEFAULT_MONITOR_CONFIG: MonitorConfig = {
     approvalAlert: true,
     longGeneratingAlert: true,
-    longGeneratingThresholdSec: 180,   // 3minutes
-    alertCooldownSec: 60,              // 1minutes cooldown
+    longGeneratingThresholdSec: 180,   // 3 minutes
+    alertCooldownSec: 60,              // 1 minute cooldown
 };
 
 export interface MonitorEvent {
@@ -42,24 +42,24 @@ export class StatusMonitor {
         this.config = { ...DEFAULT_MONITOR_CONFIG, ...config };
     }
 
- /** Config update (called from Provider Settings) */
+ /** Update config (called from Provider Settings) */
     updateConfig(partial: Partial<MonitorConfig>): void {
         Object.assign(this.config, partial);
     }
 
- /** current config return */
+ /** Return current config */
     getConfig(): MonitorConfig {
         return { ...this.config };
     }
 
  /**
- * Check status transition → return notification event array
- * each onTick()from call.
- */
+  * Check status transition → return notification event array.
+  * Called from each onTick() or detectStatusTransition().
+  */
     check(agentKey: string, status: string, now: number): MonitorEvent[] {
         const events: MonitorEvent[] = [];
 
- // 1. approval wait notification
+ // 1. Approval waiting notification
         if (this.config.approvalAlert && status === 'waiting_approval') {
             if (this.shouldAlert(agentKey + ':approval', now)) {
                 events.push({
@@ -71,7 +71,7 @@ export class StatusMonitor {
             }
         }
 
- // 2. Detect prolonged generating (identical for IDE/Extension/CLI)
+ // 2. Detect prolonged generating (identical for IDE/Extension/CLI/ACP)
         if (status === 'generating' || status === 'streaming') {
             if (!this.generatingStartTimes.has(agentKey)) {
                 this.generatingStartTimes.set(agentKey, now);