assistme 0.3.3 → 0.3.5

package/dist/index.js

@@ -171,22 +171,36 @@ async function getConversationHistory(conversationId, excludeMessageId, limit =
 }
 
 // src/db/event.ts
+var MAX_EMIT_RETRIES = 2;
+var EMIT_RETRY_DELAY_MS = 500;
+async function emitWithRetry(messageId, eventType, eventData, seq) {
+  for (let attempt = 0; attempt <= MAX_EMIT_RETRIES; attempt++) {
+    try {
+      await callMcpHandler("event.emit", {
+        message_id: messageId,
+        event_type: eventType,
+        event_data: eventData,
+        seq
+      });
+      return;
+    } catch (err) {
+      if (attempt < MAX_EMIT_RETRIES) {
+        await new Promise((r) => setTimeout(r, EMIT_RETRY_DELAY_MS * (attempt + 1)));
+      } else {
+        log.warn(
+          `Failed to emit event after ${MAX_EMIT_RETRIES + 1} attempts: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    }
+  }
+}
 var eventSequence = 0;
 function resetEventSequence() {
   eventSequence = 0;
 }
 async function emitEvent(messageId, eventType, eventData) {
   eventSequence++;
-  try {
-    await callMcpHandler("event.emit", {
-      message_id: messageId,
-      event_type: eventType,
-      event_data: eventData,
-      seq: eventSequence
-    });
-  } catch (err) {
-    log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
-  }
+  await emitWithRetry(messageId, eventType, eventData, eventSequence);
 }
 
 // src/db/action.ts
@@ -346,6 +360,8 @@ var BrowserController = class {
   connected = false;
   currentTabId = null;
   refCache = /* @__PURE__ */ new Map();
+  frameContexts = /* @__PURE__ */ new Map();
+  // refId → contextId
   constructor(port = 9222) {
     this.debugPort = port;
   }
@@ -639,13 +655,46 @@ URL: ${info.url}`;
     const result = await this.send("Runtime.evaluate", {
       expression: `
         (function() {
-          const el = document.querySelector(${selectorJS});
+          var el = document.querySelector(${selectorJS});
+
+          // If not found in main document, search same-origin iframes
+          if (!el) {
+            var iframes = document.querySelectorAll('iframe');
+            for (var i = 0; i < iframes.length; i++) {
+              try {
+                var iframeDoc = iframes[i].contentDocument;
+                if (iframeDoc) {
+                  el = iframeDoc.querySelector(${selectorJS});
+                  if (el) break;
+                }
+              } catch(e) { /* cross-origin, skip */ }
+            }
+          }
+
           if (!el) return 'Element not found: ' + ${selectorJS};
 
           el.focus();
 
-          // Clear existing value
-          const nativeInputValueSetter = Object.getOwnPropertyDescriptor(
+          // Check if this is a contenteditable element (rich text editor)
+          var isContentEditable = el.isContentEditable ||
+            el.getAttribute('contenteditable') === 'true' ||
+            el.getAttribute('contenteditable') === '';
+
+          if (isContentEditable) {
+            // For contenteditable: select all content, then replace
+            var ownerDoc = el.ownerDocument;
+            var sel = ownerDoc.defaultView.getSelection();
+            var range = ownerDoc.createRange();
+            range.selectNodeContents(el);
+            sel.removeAllRanges();
+            sel.addRange(range);
+            // Use insertText command which respects undo stack and triggers input events
+            ownerDoc.execCommand('insertText', false, ${textJS});
+            return 'Typed into: ' + (el.tagName || '') + ' [contenteditable]';
+          }
+
+          // For input/textarea: clear and set value
+          var nativeInputValueSetter = Object.getOwnPropertyDescriptor(
             window.HTMLInputElement.prototype, 'value'
           )?.set || Object.getOwnPropertyDescriptor(
             window.HTMLTextAreaElement.prototype, 'value'
@@ -665,7 +714,27 @@ URL: ${info.url}`;
       `,
       returnByValue: true
     });
-    return result.result?.value || "Text entered.";
+    const textResult = result.result?.value || "";
+    if (textResult.startsWith("Element not found")) {
+      return this.typeAtFocus(text);
+    }
+    return textResult || "Text entered.";
+  }
+  /**
+   * Type text into the currently focused element using CDP Input.insertText.
+   * This bypasses DOM queries entirely and works with any focused element,
+   * including those inside cross-origin iframes or shadow DOM.
+   */
+  async typeAtFocus(text) {
+    this.ensureConnected();
+    const modKey = platform() === "darwin" ? "Meta" : "Control";
+    await this.pressKey(`${modKey}+a`);
+    await new Promise((r) => setTimeout(r, 50));
+    await this.pressKey("Backspace");
+    await new Promise((r) => setTimeout(r, 50));
+    await this.send("Input.insertText", { text });
+    await new Promise((r) => setTimeout(r, 100));
+    return "Text entered (into focused element).";
   }
   async pressKey(key) {
     this.ensureConnected();
@@ -915,6 +984,7 @@ URL: ${info.url}`;
       inputType: r.type || "",
       box: r.box
     }));
+    await this.discoverCrossOriginFrameRefs(refs);
     if (annotate && refs.length <= 40) {
       const refsJson = JSON.stringify(refs);
       await this.send("Runtime.evaluate", {
@@ -989,6 +1059,197 @@ Refs:
     }
     return table;
   }
+  // ── Cross-Origin Iframe Discovery ────────────────────────────────
+  /**
+   * Use CDP's Page.getFrameTree + Runtime.evaluate with contextId to discover
+   * interactive elements inside cross-origin iframes (e.g., ProtonMail editor,
+   * Google Docs, embedded rich text editors).
+   *
+   * Same-origin iframes are already handled inline by the main snapshot JS.
+   * This method handles the ones that threw cross-origin errors.
+   */
+  async discoverCrossOriginFrameRefs(refs) {
+    this.frameContexts.clear();
+    try {
+      const frameTree = await this.send("Page.getFrameTree");
+      const mainFrameId = frameTree.frameTree?.frame?.id;
+      const childFrames = frameTree.frameTree?.childFrames || [];
+      if (childFrames.length === 0) return;
+      const contexts = await this.getFrameContexts(mainFrameId || "");
+      for (const child of childFrames) {
+        const frameId = child.frame.id;
+        const contextId = contexts.get(frameId);
+        if (!contextId) continue;
+        const iframeOffsetResult = await this.send("Runtime.evaluate", {
+          expression: `
+            (function() {
+              var iframes = document.querySelectorAll('iframe');
+              for (var i = 0; i < iframes.length; i++) {
+                try {
+                  // Match by frame src or name
+                  var f = iframes[i];
+                  if (f.contentWindow) {
+                    var r = f.getBoundingClientRect();
+                    if (r.width > 10 && r.height > 10) {
+                      return JSON.stringify({ x: r.x, y: r.y, width: r.width, height: r.height, index: i });
+                    }
+                  }
+                } catch(e) {}
+              }
+              return 'null';
+            })()
+          `,
+          returnByValue: true
+        });
+        let iframeOffset = { x: 0, y: 0 };
+        try {
+          const parsed = JSON.parse(
+            iframeOffsetResult.result?.value || "null"
+          );
+          if (parsed) iframeOffset = { x: parsed.x, y: parsed.y };
+        } catch {
+        }
+        const startRefId = refs.length + 1;
+        try {
+          const frameResult = await this.send("Runtime.evaluate", {
+            expression: `
+              (function() {
+                var selectors = [
+                  'a[href]', 'button', 'input:not([type="hidden"])', 'select', 'textarea',
+                  '[role="button"]', '[role="link"]', '[role="checkbox"]', '[role="radio"]',
+                  '[role="combobox"]', '[role="listbox"]', '[role="menuitem"]', '[role="tab"]',
+                  '[role="switch"]', '[role="slider"]', '[role="option"]', '[role="searchbox"]',
+                  '[onclick]', '[tabindex]:not([tabindex="-1"])',
+                  '[contenteditable="true"]', '[contenteditable=""]'
+                ].join(', ');
+
+                var all = document.querySelectorAll(selectors);
+                // Also check if the body itself is contenteditable
+                if (document.body && (document.body.isContentEditable || document.body.getAttribute('contenteditable') === 'true')) {
+                  all = [document.body].concat(Array.from(all));
+                }
+
+                var refs = [];
+                var startId = ${startRefId};
+                var vh = window.innerHeight;
+                var vw = window.innerWidth;
+
+                for (var i = 0; i < all.length && refs.length < 20; i++) {
+                  var el = all[i];
+                  var rect = el.getBoundingClientRect();
+                  if (rect.width < 5 || rect.height < 5) continue;
+                  var style = window.getComputedStyle(el);
+                  if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') continue;
+
+                  var role = el.getAttribute('role') || '';
+                  if (!role) {
+                    var tag = el.tagName.toLowerCase();
+                    if (tag === 'a') role = 'link';
+                    else if (tag === 'button') role = 'button';
+                    else if (tag === 'input') {
+                      var t = (el.type || 'text').toLowerCase();
+                      if (t === 'checkbox') role = 'checkbox';
+                      else if (t === 'radio') role = 'radio';
+                      else if (t === 'submit' || t === 'button') role = 'button';
+                      else role = 'textbox';
+                    }
+                    else if (tag === 'select') role = 'combobox';
+                    else if (tag === 'textarea') role = 'textbox';
+                    else if (el.isContentEditable) role = 'textbox';
+                    else role = tag;
+                  }
+
+                  var name = '';
+                  var ariaLabel = el.getAttribute('aria-label');
+                  if (ariaLabel) {
+                    name = ariaLabel;
+                  } else if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+                    name = el.getAttribute('placeholder') || el.getAttribute('name') || '';
+                  } else if (el.isContentEditable) {
+                    name = 'compose body';
+                  } else {
+                    name = (el.textContent || '').trim().slice(0, 60);
+                  }
+
+                  var refId = startId + refs.length;
+                  el.setAttribute('data-assistme-ref', String(refId));
+
+                  refs.push({
+                    id: refId,
+                    role: role,
+                    name: name,
+                    tag: el.tagName.toLowerCase(),
+                    type: el.getAttribute('type') || '',
+                    box: {
+                      x: Math.round(rect.x),
+                      y: Math.round(rect.y),
+                      width: Math.round(rect.width),
+                      height: Math.round(rect.height)
+                    },
+                    inFrame: true
+                  });
+                }
+
+                return JSON.stringify(refs);
+              })()
+            `,
+            contextId,
+            returnByValue: true
+          });
+          const frameRefs = JSON.parse(
+            frameResult.result?.value || "[]"
+          );
+          for (const r of frameRefs) {
+            refs.push({
+              id: r.id,
+              role: r.role,
+              name: r.name,
+              tag: r.tag,
+              inputType: r.type || "",
+              box: {
+                x: Math.round(r.box.x + iframeOffset.x),
+                y: Math.round(r.box.y + iframeOffset.y),
+                width: r.box.width,
+                height: r.box.height
+              }
+            });
+            this.frameContexts.set(r.id, contextId);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Get execution context IDs for each frame in the page.
+   * Uses Runtime.executionContextCreated events collected during the session,
+   * or falls back to evaluating in known frames.
+   */
+  async getFrameContexts(_mainFrameId) {
+    const contexts = /* @__PURE__ */ new Map();
+    try {
+      await this.send("Runtime.enable").catch(() => {
+      });
+      const frameTree = await this.send("Page.getFrameTree");
+      const childFrames = frameTree.frameTree?.childFrames || [];
+      for (const child of childFrames) {
+        try {
+          const world = await this.send("Page.createIsolatedWorld", {
+            frameId: child.frame.id,
+            worldName: "assistme-snapshot",
+            grantUniveralAccess: true
+          });
+          if (world.executionContextId) {
+            contexts.set(child.frame.id, world.executionContextId);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return contexts;
+  }
   // ── Ref Resolution ────────────────────────────────────────────────
   /**
    * Resolve a ref ID to its current center coordinates in the viewport.
@@ -1101,9 +1362,85 @@ Refs:
       returnByValue: true
     });
     const value = result.result?.value;
-    if (!value || value === "null") return null;
+    if (value && value !== "null") {
+      try {
+        return JSON.parse(value);
+      } catch {
+      }
+    }
+    const frameContextId = this.frameContexts.get(refId);
+    if (frameContextId) {
+      return this.resolveRefInFrame(refId, frameContextId, role, name);
+    }
+    return null;
+  }
+  /**
+   * Resolve a ref inside a cross-origin iframe using its execution context.
+   * Returns coordinates adjusted by the iframe's viewport offset.
+   */
+  async resolveRefInFrame(refId, contextId, role, name) {
+    const roleJS = JSON.stringify(role);
+    const nameJS = JSON.stringify(name);
     try {
-      return JSON.parse(value);
+      const offsetResult = await this.send("Runtime.evaluate", {
+        expression: `
+          (function() {
+            var iframes = document.querySelectorAll('iframe');
+            for (var i = 0; i < iframes.length; i++) {
+              var r = iframes[i].getBoundingClientRect();
+              if (r.width > 10 && r.height > 10) {
+                return JSON.stringify({ x: r.x, y: r.y });
+              }
+            }
+            return JSON.stringify({ x: 0, y: 0 });
+          })()
+        `,
+        returnByValue: true
+      });
+      const offset = JSON.parse(
+        offsetResult.result?.value || '{"x":0,"y":0}'
+      );
+      const frameResult = await this.send("Runtime.evaluate", {
+        expression: `
+          (function() {
+            var el = document.querySelector('[data-assistme-ref="${refId}"]');
+            if (!el && ${roleJS} && ${nameJS}) {
+              // Fallback: search by role
+              var candidates = document.querySelectorAll('*');
+              for (var i = 0; i < candidates.length; i++) {
+                var c = candidates[i];
+                if (c.isContentEditable || c.getAttribute('contenteditable') === 'true') {
+                  el = c; break;
+                }
+              }
+            }
+            if (!el) return 'null';
+
+            el.scrollIntoView({ block: 'center', behavior: 'instant' });
+            var r = el.getBoundingClientRect();
+            if (r.width < 1 || r.height < 1) return JSON.stringify({ error: 'Zero size' });
+
+            return JSON.stringify({
+              x: r.x + r.width / 2,
+              y: r.y + r.height / 2,
+              width: r.width,
+              height: r.height
+            });
+          })()
+        `,
+        contextId,
+        returnByValue: true
+      });
+      const value = frameResult.result?.value;
+      if (!value || value === "null") return null;
+      const parsed = JSON.parse(value);
+      if (parsed.error) return parsed;
+      return {
+        x: parsed.x + offset.x,
+        y: parsed.y + offset.y,
+        width: parsed.width,
+        height: parsed.height
+      };
     } catch {
       return null;
     }
@@ -1190,11 +1527,23 @@ Refs:
     await new Promise((r) => setTimeout(r, 50));
     await this.pressKey("Backspace");
     await new Promise((r) => setTimeout(r, 50));
-    const cleared = await this.send("Runtime.evaluate", {
+    const frameContextId = this.frameContexts.get(refId);
+    const clearEvalOpts = {
       expression: `
         (function() {
           var el = document.querySelector('[data-assistme-ref="${refId}"]');
           if (!el) return 'no_element';
+
+          // For contenteditable elements, check textContent instead of value
+          if (el.isContentEditable || el.getAttribute('contenteditable') === 'true') {
+            if (el.textContent && el.textContent.trim() !== '') {
+              el.textContent = '';
+              el.dispatchEvent(new Event('input', { bubbles: true }));
+              return 'js_cleared';
+            }
+            return 'ok';
+          }
+
           if (el.value !== undefined && el.value !== '') {
             // Ctrl+A didn't work (some frameworks intercept it) \u2014 clear via JS
             var setter = Object.getOwnPropertyDescriptor(
@@ -1212,9 +1561,13 @@ Refs:
         })()
       `,
       returnByValue: true
-    });
+    };
+    if (frameContextId) {
+      clearEvalOpts.contextId = frameContextId;
+    }
+    const cleared = await this.send("Runtime.evaluate", clearEvalOpts);
     const clearStatus = cleared.result?.value || "ok";
-    if (clearStatus === "no_element") {
+    if (clearStatus === "no_element" && !frameContextId) {
       return {
         success: false,
         message: `Ref ${refLabel} not found after click. Take a new snapshot.`
@@ -3797,7 +4150,7 @@ function createBrowserMcpServer() {
       ),
       tool(
         "browser_type",
-        "Type text into an input field in the user's browser.",
+        "Type text into an input field in the user's browser. If the CSS selector fails, automatically falls back to typing into the currently focused element. Works with contenteditable elements (rich text editors) and cross-origin iframes.",
         {
           selector: z.string().describe("CSS selector of the input element"),
           text: z.string().describe("Text to type")
@@ -4183,7 +4536,7 @@ function getCredentialStore() {
 
 // src/mcp/agent-tools-server.ts
 function createAgentToolsServer(deps) {
-  const { memoryManager, skillManager, taskId, sessionId } = deps;
+  const { memoryManager, skillManager, taskId, sessionId, onUserWaitStart, onUserWaitEnd } = deps;
   return createSdkMcpServer2({
     name: "assistme-agent",
     version: "1.0.0",
@@ -4688,52 +5041,56 @@ Use \`ask_user\` to request these from the user, or create them yourself (e.g. r
           try {
             await setActionRequest(taskId, actionData);
             log.info(`Ask user ${actionId}: "${args.question.slice(0, 80)}..."`);
-            emitEvent(taskId, "user_action_request", actionData).catch(() => {
-            });
-            emitEvent(taskId, "status_change", {
+            await emitEvent(taskId, "user_action_request", actionData);
+            await emitEvent(taskId, "status_change", {
               status: "waiting_for_user",
               message: args.question
-            }).catch(() => {
             });
+            onUserWaitStart?.();
             const startTime = Date.now();
             const pollInterval = 2e3;
-            while (Date.now() - startTime < timeout) {
-              const response = await pollActionResponse(taskId);
-              if (response && (!response.action_id || response.action_id === actionId)) {
-                const actionKey = response.action_key || "";
-                const text = response.text || "";
-                const label = response.label || actionKey || text;
-                log.info(`User responded: "${label}"`);
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: JSON.stringify({
-                        status: "responded",
-                        action_key: actionKey || "custom_input",
-                        label,
-                        text: text || label
-                      })
-                    }
-                  ]
-                };
+            try {
+              while (Date.now() - startTime < timeout) {
+                const response = await pollActionResponse(taskId);
+                if (response && (!response.action_id || response.action_id === actionId)) {
+                  const actionKey = response.action_key || "";
+                  const text = response.text || "";
+                  const label = response.label || actionKey || text;
+                  log.info(`User responded: "${label}"`);
+                  return {
+                    content: [
+                      {
+                        type: "text",
+                        text: JSON.stringify({
+                          status: "responded",
+                          action_key: actionKey || "custom_input",
+                          label,
+                          text: text || label
+                        })
+                      }
+                    ]
+                  };
+                }
+                await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
               }
-              await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+              log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify({
+                      status: "timeout",
+                      message: "User did not respond within the timeout period. Continue the task with a reasonable default or skip the step that required user input."
+                    })
+                  }
+                ]
+              };
+            } finally {
+              onUserWaitEnd?.();
             }
-            log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({
-                    status: "timeout",
-                    message: "User did not respond within the timeout period."
-                  })
-                }
-              ]
-            };
           } catch (err) {
             log.error(`ask_user failed: ${err}`);
+            onUserWaitEnd?.();
             return {
               content: [
                 {
@@ -5167,12 +5524,16 @@ Available capabilities:
    - Bash tool for shell commands
    - Glob and Grep for file search
 
-3. MEMORY:
+3. MEMORY & CREDENTIALS:
    - You can remember things about the user using memory_store
    - Use this when you learn preferences, important facts, or standing instructions
    - Your stored memories persist across conversations
    - PROACTIVELY use memory_store during tasks when you discover user preferences, habits, or important context
    - Before completing a task, consider if anything learned should be remembered for future conversations
+   - CRITICAL \u2014 Credential Storage: When you create, register, or receive any account credentials (username, password, API keys, tokens), you MUST use credential_set to save them locally. NEVER use memory_store for credentials \u2014 memory_store is for preferences and facts, credential_set is for secrets. Examples:
+     * After registering a new email/account \u2192 credential_set with type "login" and data { "username": "...", "password": "...", "email": "..." }
+     * After generating an API key \u2192 credential_set with type "api_key" and data { "api_key": "..." }
+     * Credentials saved via credential_set are encrypted on disk and viewable in the desktop app's Credentials panel
 
 4. SKILL-AWARE EXECUTION (CRITICAL \u2014 follow this for EVERY task):
    Step A \u2014 Search: Before executing ANY task, check if an existing skill matches (use skill_invoke or skill_search).
@@ -5252,6 +5613,42 @@ CRITICAL \u2014 Ask before you guess:
 Workspace path: {workspace_path}`;
 
 // src/agent/processor.ts
+var TaskTimeout = class {
+  constructor(abortController, timeoutMs) {
+    this.abortController = abortController;
+    this.remainingMs = timeoutMs;
+    this.resumedAt = Date.now();
+    this.schedule();
+  }
+  timeoutId = null;
+  remainingMs;
+  resumedAt;
+  schedule() {
+    this.timeoutId = setTimeout(() => {
+      this.abortController.abort();
+    }, this.remainingMs);
+  }
+  /** Pause the timeout (e.g. while waiting for user). */
+  pause() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+      const elapsed = Date.now() - this.resumedAt;
+      this.remainingMs = Math.max(0, this.remainingMs - elapsed);
+    }
+  }
+  /** Resume the timeout after user interaction completes. */
+  resume() {
+    this.resumedAt = Date.now();
+    this.schedule();
+  }
+  clear() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+};
 var MAX_HISTORY_ENTRIES = 10;
 var MAX_RESPONSE_LENGTH = 1500;
 var TaskProcessor = class {
@@ -5334,12 +5731,16 @@ var TaskProcessor = class {
         }
         systemPrompt += historyPrompt;
       }
+      const abortController = new AbortController();
+      const taskTimeout = new TaskTimeout(abortController, taskTimeoutMs);
       const browserServer = createBrowserMcpServer();
       const agentToolsServer = createAgentToolsServer({
         memoryManager: this.memoryManager,
         skillManager: this.skillManager,
         taskId: task.id,
-        sessionId: this.sessionId || void 0
+        sessionId: this.sessionId || void 0,
+        onUserWaitStart: () => taskTimeout.pause(),
+        onUserWaitEnd: () => taskTimeout.resume()
       });
       const eventHooks = createEventHooks(task.id, toolCallRecords);
       const allowedTools = [
@@ -5386,7 +5787,6 @@ var TaskProcessor = class {
           session_id: ""
         };
       }
-      const abortController = new AbortController();
       const options = {
         model: config.model,
         systemPrompt,
@@ -5404,9 +5804,6 @@ var TaskProcessor = class {
         abortController
       };
       const taskStartTime = Date.now();
-      const timeoutId = setTimeout(() => {
-        abortController.abort();
-      }, taskTimeoutMs);
       try {
         for await (const message of query2({
           prompt: promptMessages(),
@@ -5468,7 +5865,7 @@ var TaskProcessor = class {
           }
         }
       } finally {
-        clearTimeout(timeoutId);
+        taskTimeout.clear();
       }
       const MAX_CONTENT_LENGTH = 5e4;
       const truncatedResponse = finalResponse.length > MAX_CONTENT_LENGTH ? finalResponse.slice(0, MAX_CONTENT_LENGTH) + "\n\n[Response truncated]" : finalResponse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "AssistMe CLI Agent - AI-powered assistant that controls your real browser",
   "type": "module",
   "main": "dist/index.js",