@web-auto/camo 0.1.6 → 0.1.8

package/README.md

@@ -39,6 +39,15 @@ camo start --url https://example.com --alias main
 # Start headless worker (auto-kill after idle timeout)
 camo start worker-1 --headless --alias shard1 --idle-timeout 30m
 
+# Start with devtools (headful only)
+camo start worker-1 --devtools
+
+# Evaluate JS (devtools-style input in page context)
+camo devtools eval worker-1 "document.title"
+
+# Read captured console entries
+camo devtools logs worker-1 --levels error,warn --limit 50
+
 # Navigate
 camo goto https://www.xiaohongshu.com
 
@@ -71,7 +80,7 @@ camo create fingerprint --os <os> --region <region>
 ### Browser Control
 
 ```bash
-camo start [profileId] [--url <url>] [--headless] [--alias <name>] [--idle-timeout <duration>] [--width <w> --height <h>]
+camo start [profileId] [--url <url>] [--headless] [--devtools] [--alias <name>] [--idle-timeout <duration>] [--width <w> --height <h>]
 camo stop [profileId]
 camo stop --id <instanceId>
 camo stop --alias <alias>
@@ -85,6 +94,7 @@ camo shutdown                          # Shutdown browser-service (all sessions)
 If no saved size exists, it defaults to near-fullscreen (full width, slight vertical reserve).  
 Use `--width/--height` to override and update the saved profile size.
 For headless sessions, default idle timeout is `30m` (auto-stop on inactivity). Use `--idle-timeout` (e.g. `45m`, `1800s`, `0`) to customize.
+Use `--devtools` to open browser developer tools in headed mode (cannot be combined with `--headless`).
 
 ### Lifecycle & Cleanup
 
@@ -118,6 +128,14 @@ camo clear-highlight [profileId]               # Clear all highlights
 camo viewport [profileId] --width <w> --height <h>
 ```
 
+### Devtools
+
+```bash
+camo devtools logs [profileId] [--limit 120] [--since <unix_ms>] [--levels error,warn] [--clear]
+camo devtools eval [profileId] <expression> [--profile <id>]
+camo devtools clear [profileId]
+```
+
 ### Pages
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-auto/camo",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Camoufox Browser CLI - Cross-platform browser automation",
   "type": "module",
   "bin": {

package/src/autoscript/action-providers/xhs/comments.mjs

@@ -86,6 +86,43 @@ export function buildCommentsHarvestScript(params = {}) {
       }
       return null;
     };
+    const normalizeInlineText = (value) => String(value || '').replace(/\\s+/g, ' ').trim();
+    const sanitizeAuthorText = (raw, commentText = '') => {
+      const text = normalizeInlineText(raw);
+      if (!text) return '';
+      if (commentText && text === commentText) return '';
+      if (text.length > 40) return '';
+      if (/^(回复|展开|收起|查看更多|评论|赞|分享|发送)$/.test(text)) return '';
+      return text;
+    };
+    const readAuthor = (item, commentText = '') => {
+      const attrNames = ['data-user-name', 'data-username', 'data-user_nickname', 'data-nickname'];
+      for (const attr of attrNames) {
+        const value = sanitizeAuthorText(item.getAttribute?.(attr), commentText);
+        if (value) return value;
+      }
+      const selectors = [
+        '.comment-user .name',
+        '.comment-user .username',
+        '.comment-user .user-name',
+        '.author .name',
+        '.author',
+        '.user-name',
+        '.username',
+        '.name',
+        'a[href*="/user/profile/"]',
+        'a[href*="/user/"]',
+      ];
+      for (const selector of selectors) {
+        const node = item.querySelector(selector);
+        if (!node) continue;
+        const title = sanitizeAuthorText(node.getAttribute?.('title'), commentText);
+        if (title) return title;
+        const text = sanitizeAuthorText(node.textContent, commentText);
+        if (text) return text;
+      }
+      return '';
+    };
 
     const scroller = document.querySelector('.note-scroller')
       || document.querySelector('.comments-el')
@@ -105,9 +142,8 @@ export function buildCommentsHarvestScript(params = {}) {
       const nodes = Array.from(document.querySelectorAll('.comment-item, [class*="comment-item"]'));
       for (const item of nodes) {
         const textNode = item.querySelector('.content, .comment-content, p');
-        const authorNode = item.querySelector('.name, .author, .user-name, [class*="author"], [class*="name"]');
         const text = String((textNode && textNode.textContent) || '').trim();
-        const author = String((authorNode && authorNode.textContent) || '').trim();
+        const author = readAuthor(item, text);
         if (!text) continue;
         const key = author + '::' + text;
         if (commentMap.has(key)) continue;

package/src/autoscript/action-providers/xhs/interaction.mjs

@@ -74,6 +74,42 @@ function buildCollectLikeTargetsScript() {
       }
       return '';
     };
+    const sanitizeUserName = (raw, commentText = '') => {
+      const text = String(raw || '').replace(/\\s+/g, ' ').trim();
+      if (!text) return '';
+      if (commentText && text === commentText) return '';
+      if (text.length > 40) return '';
+      if (/^(回复|展开|收起|查看更多|评论|赞|分享|发送)$/.test(text)) return '';
+      return text;
+    };
+    const readUserName = (item, commentText = '') => {
+      const attrNames = ['data-user-name', 'data-username', 'data-user_nickname', 'data-nickname'];
+      for (const attr of attrNames) {
+        const value = sanitizeUserName(item.getAttribute?.(attr), commentText);
+        if (value) return value;
+      }
+      const selectors = [
+        '.comment-user .name',
+        '.comment-user .username',
+        '.comment-user .user-name',
+        '.author .name',
+        '.author',
+        '.user-name',
+        '.username',
+        '.name',
+        'a[href*="/user/profile/"]',
+        'a[href*="/user/"]',
+      ];
+      for (const selector of selectors) {
+        const node = item.querySelector(selector);
+        if (!node) continue;
+        const title = sanitizeUserName(node.getAttribute?.('title'), commentText);
+        if (title) return title;
+        const text = sanitizeUserName(node.textContent, commentText);
+        if (text) return text;
+      }
+      return '';
+    };
     const readAttr = (item, attrNames) => {
       for (const attr of attrNames) {
         const value = String(item.getAttribute?.(attr) || '').trim();
@@ -81,6 +117,15 @@ function buildCollectLikeTargetsScript() {
       }
       return '';
     };
+    const readUserId = (item) => {
+      const value = readAttr(item, ['data-user-id', 'data-userid', 'data-user_id']);
+      if (value) return value;
+      const anchor = item.querySelector('a[href*="/user/profile/"], a[href*="/user/"]');
+      const href = String(anchor?.getAttribute?.('href') || '').trim();
+      if (!href) return '';
+      const matched = href.match(/\\/user\\/(?:profile\\/)?([a-zA-Z0-9_-]+)/);
+      return matched && matched[1] ? matched[1] : '';
+    };
 
     const matchedSet = new Set(
       Array.isArray(state.matchedComments)
@@ -92,8 +137,8 @@ function buildCollectLikeTargetsScript() {
       const item = items[index];
       const text = readText(item, ['.content', '.comment-content', 'p']);
       if (!text) continue;
-      const userName = readText(item, ['.name', '.author', '.user-name', '.username', '[class*="author"]', '[class*="name"]']);
-      const userId = readAttr(item, ['data-user-id', 'data-userid', 'data-user_id']);
+      const userName = readUserName(item, text);
+      const userId = readUserId(item);
       const timestamp = readText(item, ['.date', '.time', '.timestamp', '[class*="time"]']);
       const likeControl = findLikeControl(item);
       rows.push({

package/src/cli.mjs

@@ -13,6 +13,7 @@ import { handleSystemCommand } from './commands/system.mjs';
 import { handleContainerCommand } from './commands/container.mjs';
 import { handleAutoscriptCommand } from './commands/autoscript.mjs';
 import { handleEventsCommand } from './commands/events.mjs';
+import { handleDevtoolsCommand } from './commands/devtools.mjs';
 import {
   handleStartCommand, handleStopCommand, handleStatusCommand,
   handleGotoCommand, handleBackCommand, handleScreenshotCommand,
@@ -64,6 +65,13 @@ function inferProfileId(cmd, args) {
     return positionals[0] || null;
   }
 
+  if (cmd === 'devtools') {
+    const sub = positionals[0] || null;
+    if (sub === 'eval' || sub === 'logs' || sub === 'clear') {
+      return positionals[1] || null;
+    }
+  }
+
   if (cmd === 'autoscript' && positionals[0] === 'run') {
     return explicitProfile || null;
   }
@@ -192,6 +200,11 @@ async function main() {
     return;
   }
 
+  if (cmd === 'devtools') {
+    await runTrackedCommand(cmd, args, () => handleDevtoolsCommand(args));
+    return;
+  }
+
   // Lifecycle commands
   if (cmd === 'cleanup') {
     await runTrackedCommand(cmd, args, () => handleCleanupCommand(args));
@@ -237,7 +250,7 @@ async function main() {
     'start', 'stop', 'close', 'status', 'list', 'goto', 'navigate', 'back', 'screenshot',
     'new-page', 'close-page', 'switch-page', 'list-pages', 'shutdown',
     'scroll', 'click', 'type', 'highlight', 'clear-highlight', 'viewport',
-    'cookies', 'window', 'mouse', 'system', 'container', 'autoscript', 'events',
+    'cookies', 'window', 'mouse', 'system', 'container', 'autoscript', 'events', 'devtools',
   ]);
 
   if (!serviceCommands.has(cmd)) {

package/src/commands/browser.mjs

@@ -8,6 +8,10 @@ import {
 import { callAPI, ensureCamoufox, ensureBrowserService, getSessionByProfile, checkBrowserService } from '../utils/browser-service.mjs';
 import { resolveProfileId, ensureUrlScheme, looksLikeUrlToken, getPositionals } from '../utils/args.mjs';
 import { acquireLock, releaseLock, cleanupStaleLocks } from '../lifecycle/lock.mjs';
+import {
+  buildSelectorClickScript,
+  buildSelectorTypeScript,
+} from '../container/runtime-core/operations/selector-scripts.mjs';
 import {
   registerSession,
   updateSession,
@@ -26,6 +30,9 @@ const START_WINDOW_MIN_HEIGHT = 700;
 const START_WINDOW_MAX_RESERVE = 240;
 const START_WINDOW_DEFAULT_RESERVE = 72;
 const DEFAULT_HEADLESS_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+const DEVTOOLS_SHORTCUTS = process.platform === 'darwin'
+  ? ['Meta+Alt+I', 'F12']
+  : ['F12', 'Control+Shift+I'];
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -122,6 +129,67 @@ async function stopAndCleanupProfile(profileId, options = {}) {
   };
 }
 
+async function probeViewportSize(profileId) {
+  try {
+    const payload = await callAPI('evaluate', {
+      profileId,
+      script: '(() => ({ width: Number(window.innerWidth || 0), height: Number(window.innerHeight || 0) }))()',
+    });
+    const size = payload?.result || payload?.data || payload || {};
+    const width = Number(size?.width || 0);
+    const height = Number(size?.height || 0);
+    if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+    return { width, height };
+  } catch {
+    return null;
+  }
+}
+
+export async function requestDevtoolsOpen(profileId, options = {}) {
+  const id = String(profileId || '').trim();
+  if (!id) {
+    return { ok: false, requested: false, reason: 'profile_required', shortcuts: [] };
+  }
+
+  const shortcuts = Array.isArray(options.shortcuts) && options.shortcuts.length
+    ? options.shortcuts.map((item) => String(item || '').trim()).filter(Boolean)
+    : DEVTOOLS_SHORTCUTS;
+  const settleMs = Math.max(0, parseNumber(options.settleMs, 180));
+  const before = await probeViewportSize(id);
+  const attempts = [];
+
+  for (const key of shortcuts) {
+    try {
+      await callAPI('keyboard:press', { profileId: id, key });
+      attempts.push({ key, ok: true });
+      if (settleMs > 0) {
+        // Allow browser UI animation to settle after shortcut.
+        // eslint-disable-next-line no-await-in-loop
+        await sleep(settleMs);
+      }
+    } catch (err) {
+      attempts.push({ key, ok: false, error: err?.message || String(err) });
+    }
+  }
+
+  const after = await probeViewportSize(id);
+  const beforeHeight = Number(before?.height || 0);
+  const afterHeight = Number(after?.height || 0);
+  const viewportReduced = beforeHeight > 0 && afterHeight > 0 && afterHeight < (beforeHeight - 100);
+  const successCount = attempts.filter((item) => item.ok).length;
+
+  return {
+    ok: successCount > 0,
+    requested: true,
+    shortcuts,
+    attempts,
+    before,
+    after,
+    verified: viewportReduced,
+    verification: viewportReduced ? 'viewport_height_reduced' : 'shortcut_dispatched',
+  };
+}
+
 export function computeTargetViewportFromWindowMetrics(measured) {
   const innerWidth = Math.max(320, parseNumber(measured?.innerWidth, 0));
   const innerHeight = Math.max(240, parseNumber(measured?.innerHeight, 0));
@@ -250,8 +318,9 @@ export async function handleStartCommand(args) {
   const alias = validateAlias(readFlagValue(args, ['--alias']));
   const idleTimeoutRaw = readFlagValue(args, ['--idle-timeout']);
   const parsedIdleTimeoutMs = parseDurationMs(idleTimeoutRaw, DEFAULT_HEADLESS_IDLE_TIMEOUT_MS);
+  const wantsDevtools = args.includes('--devtools');
   if (hasExplicitWidth !== hasExplicitHeight) {
-    throw new Error('Usage: camo start [profileId] [--url <url>] [--headless] [--alias <name>] [--idle-timeout <duration>] [--width <w> --height <h>]');
+    throw new Error('Usage: camo start [profileId] [--url <url>] [--headless] [--devtools] [--alias <name>] [--idle-timeout <duration>] [--width <w> --height <h>]');
   }
   if ((hasExplicitWidth && explicitWidth < START_WINDOW_MIN_WIDTH) || (hasExplicitHeight && explicitHeight < START_WINDOW_MIN_HEIGHT)) {
     throw new Error(`Window size too small. Minimum is ${START_WINDOW_MIN_WIDTH}x${START_WINDOW_MIN_HEIGHT}`);
@@ -308,7 +377,7 @@ export async function handleStartCommand(args) {
         alias: alias || null,
       });
     const idleState = computeIdleState(record);
-    console.log(JSON.stringify({
+    const payload = {
       ok: true,
       sessionId: existing.session_id || existing.profileId,
       instanceId: record.instanceId,
@@ -323,7 +392,13 @@ export async function handleStartCommand(args) {
         byId: `camo stop --id ${record.instanceId}`,
         byAlias: record.alias ? `camo stop --alias ${record.alias}` : null,
       },
-    }, null, 2));
+    };
+    const existingMode = String(existing?.mode || record?.mode || '').toLowerCase();
+    const existingHeadless = existing?.headless === true || existingMode.includes('headless');
+    if (!existingHeadless && wantsDevtools) {
+      payload.devtools = await requestDevtoolsOpen(profileId);
+    }
+    console.log(JSON.stringify(payload, null, 2));
     startSessionWatchdog(profileId);
     return;
   }
@@ -338,12 +413,16 @@ export async function handleStartCommand(args) {
   }
 
   const headless = args.includes('--headless');
+  if (wantsDevtools && headless) {
+    throw new Error('--devtools is not supported with --headless');
+  }
   const idleTimeoutMs = headless ? parsedIdleTimeoutMs : 0;
   const targetUrl = explicitUrl || implicitUrl;
   const result = await callAPI('start', {
     profileId,
     url: targetUrl ? ensureUrlScheme(targetUrl) : undefined,
     headless,
+    devtools: wantsDevtools,
   });
   
   if (result?.ok) {
@@ -416,6 +495,9 @@ export async function handleStartCommand(args) {
         Number.isFinite(measuredOuterHeight) ? measuredOuterHeight : windowTarget.height,
       );
       result.profileWindow = savedWindow?.window || null;
+      if (wantsDevtools) {
+        result.devtools = await requestDevtoolsOpen(profileId);
+      }
     }
   }
   console.log(JSON.stringify(result, null, 2));
@@ -426,6 +508,12 @@ export async function handleStopCommand(args) {
   const target = rawTarget.toLowerCase();
   const idTarget = readFlagValue(args, ['--id']);
   const aliasTarget = readFlagValue(args, ['--alias']);
+  if (args.includes('--id') && !idTarget) {
+    throw new Error('Usage: camo stop --id <instanceId>');
+  }
+  if (args.includes('--alias') && !aliasTarget) {
+    throw new Error('Usage: camo stop --alias <alias>');
+  }
   const stopIdle = target === 'idle' || args.includes('--idle');
   const stopAll = target === 'all';
   const serviceUp = await checkBrowserService();
@@ -465,11 +553,41 @@ export async function handleStopCommand(args) {
 
   if (stopIdle) {
     const now = Date.now();
-    const idleTargets = listRegisteredSessions()
+    const registeredSessions = listRegisteredSessions();
+    let liveSessions = [];
+    if (serviceUp) {
+      try {
+        const status = await callAPI('getStatus', {});
+        liveSessions = Array.isArray(status?.sessions) ? status.sessions : [];
+      } catch {
+        // Ignore and fallback to local registry.
+      }
+    }
+    const regMap = new Map(
+      registeredSessions
+        .filter((item) => item && String(item?.status || '').trim() === 'active')
+        .map((item) => [String(item.profileId || '').trim(), item]),
+    );
+    const idleTargets = new Set(
+      registeredSessions
       .filter((item) => String(item?.status || '').trim() === 'active')
       .map((item) => ({ session: item, idle: computeIdleState(item, now) }))
       .filter((item) => item.idle.idle)
-      .map((item) => item.session.profileId);
+      .map((item) => item.session.profileId),
+    );
+    let orphanLiveHeadlessCount = 0;
+    for (const live of liveSessions) {
+      const liveProfileId = String(live?.profileId || '').trim();
+      if (!liveProfileId) continue;
+      if (regMap.has(liveProfileId) || idleTargets.has(liveProfileId)) continue;
+      const mode = String(live?.mode || '').toLowerCase();
+      const liveHeadless = live?.headless === true || mode.includes('headless');
+      // Live but unregistered headless sessions are treated as idle-orphan targets.
+      if (liveHeadless) {
+        idleTargets.add(liveProfileId);
+        orphanLiveHeadlessCount += 1;
+      }
+    }
     const results = [];
     for (const profileId of idleTargets) {
       // eslint-disable-next-line no-await-in-loop
@@ -479,7 +597,8 @@ export async function handleStopCommand(args) {
       ok: true,
       mode: 'idle',
       serviceUp,
-      targetCount: idleTargets.length,
+      targetCount: idleTargets.size,
+      orphanLiveHeadlessCount,
       closed: results.filter((item) => item.ok).length,
       failed: results.filter((item) => !item.ok).length,
       results,
@@ -652,14 +771,7 @@ export async function handleClickCommand(args) {
 
   const result = await callAPI('evaluate', {
     profileId,
-    script: `(async () => {
-      const el = document.querySelector(${JSON.stringify(selector)});
-      if (!el) throw new Error('Element not found: ' + ${JSON.stringify(selector)});
-      el.scrollIntoView({ behavior: 'smooth', block: 'center' });
-      await new Promise(r => setTimeout(r, 200));
-      el.click();
-      return { clicked: true, selector: ${JSON.stringify(selector)} };
-    })()`
+    script: buildSelectorClickScript({ selector, highlight: false }),
   });
   console.log(JSON.stringify(result, null, 2));
 }
@@ -686,18 +798,7 @@ export async function handleTypeCommand(args) {
 
   const result = await callAPI('evaluate', {
     profileId,
-    script: `(async () => {
-      const el = document.querySelector(${JSON.stringify(selector)});
-      if (!el) throw new Error('Element not found: ' + ${JSON.stringify(selector)});
-      el.scrollIntoView({ behavior: 'smooth', block: 'center' });
-      await new Promise(r => setTimeout(r, 200));
-      el.focus();
-      el.value = '';
-      el.value = ${JSON.stringify(text)};
-      el.dispatchEvent(new Event('input', { bubbles: true }));
-      el.dispatchEvent(new Event('change', { bubbles: true }));
-      return { typed: true, selector: ${JSON.stringify(selector)}, length: ${text.length} };
-    })()`
+    script: buildSelectorTypeScript({ selector, highlight: false, text }),
   });
   console.log(JSON.stringify(result, null, 2));
 }

package/src/commands/devtools.mjs

@@ -0,0 +1,349 @@
+import { getDefaultProfile, listProfiles } from '../utils/config.mjs';
+import { callAPI } from '../utils/browser-service.mjs';
+
+const DEFAULT_LIMIT = 120;
+const MAX_LIMIT = 1000;
+
+function parseNumber(value, fallback) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : fallback;
+}
+
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+function readFlagValue(args, names) {
+  for (let i = 0; i < args.length; i += 1) {
+    if (!names.includes(args[i])) continue;
+    const value = args[i + 1];
+    if (!value || String(value).startsWith('-')) return null;
+    return value;
+  }
+  return null;
+}
+
+function collectPositionals(args, startIndex = 2) {
+  const values = [];
+  for (let i = startIndex; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token || String(token).startsWith('--')) {
+      continue;
+    }
+    const prev = args[i - 1];
+    if (prev && ['--profile', '-p', '--limit', '-n', '--levels', '--since'].includes(prev)) {
+      continue;
+    }
+    values.push(String(token));
+  }
+  return values;
+}
+
+function pickProfileAndExpression(args, subcommand) {
+  const explicitProfile = readFlagValue(args, ['--profile', '-p']);
+  const profileSet = new Set(listProfiles());
+  const positionals = collectPositionals(args, 2);
+
+  let profileId = explicitProfile || null;
+  let expression = null;
+
+  if (subcommand === 'eval') {
+    if (positionals.length === 0) {
+      return { profileId: profileId || getDefaultProfile(), expression: null };
+    }
+    if (!profileId && positionals.length >= 2) {
+      profileId = positionals[0];
+      expression = positionals.slice(1).join(' ').trim();
+    } else if (!profileId && profileSet.has(positionals[0])) {
+      profileId = positionals[0];
+      expression = positionals.slice(1).join(' ').trim();
+    } else {
+      expression = positionals.join(' ').trim();
+    }
+    return { profileId: profileId || getDefaultProfile(), expression };
+  }
+
+  if (positionals.length > 0) {
+    if (!profileId && (profileSet.has(positionals[0]) || subcommand === 'logs' || subcommand === 'clear')) {
+      profileId = positionals[0];
+    }
+  }
+  return { profileId: profileId || getDefaultProfile(), expression: null };
+}
+
+function buildConsoleInstallScript(maxEntries) {
+  return `(function installCamoDevtoolsConsoleCollector() {
+    const KEY = '__camo_console_collector_v1__';
+    const BUFFER_KEY = '__camo_console_buffer_v1__';
+    const MAX = ${Math.max(100, Math.floor(maxEntries || MAX_LIMIT))};
+    const now = () => Date.now();
+
+    const stringify = (value) => {
+      if (typeof value === 'string') return value;
+      if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);
+      if (value === null) return 'null';
+      if (typeof value === 'undefined') return 'undefined';
+      if (typeof value === 'function') return '[function]';
+      if (typeof value === 'symbol') return String(value);
+      if (value instanceof Error) return value.stack || value.message || String(value);
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return Object.prototype.toString.call(value);
+      }
+    };
+
+    const pushEntry = (level, args) => {
+      const target = window[BUFFER_KEY];
+      if (!Array.isArray(target)) return;
+      const text = Array.from(args || []).map(stringify).join(' ');
+      target.push({
+        ts: now(),
+        level,
+        text,
+        href: String(window.location?.href || ''),
+      });
+      if (target.length > MAX) {
+        target.splice(0, target.length - MAX);
+      }
+    };
+
+    if (!Array.isArray(window[BUFFER_KEY])) {
+      window[BUFFER_KEY] = [];
+    }
+
+    if (!window[KEY]) {
+      const levels = ['log', 'info', 'warn', 'error', 'debug'];
+      const originals = {};
+      for (const level of levels) {
+        const raw = typeof console[level] === 'function' ? console[level] : console.log;
+        originals[level] = raw.bind(console);
+        console[level] = (...args) => {
+          try {
+            pushEntry(level, args);
+          } catch {}
+          return originals[level](...args);
+        };
+      }
+
+      window.addEventListener('error', (event) => {
+        try {
+          const message = event?.message || 'window.error';
+          pushEntry('error', [message]);
+        } catch {}
+      });
+      window.addEventListener('unhandledrejection', (event) => {
+        try {
+          const reason = event?.reason instanceof Error
+            ? (event.reason.stack || event.reason.message)
+            : stringify(event?.reason);
+          pushEntry('error', ['unhandledrejection', reason]);
+        } catch {}
+      });
+
+      window[KEY] = { installedAt: now(), max: MAX };
+    }
+
+    return {
+      ok: true,
+      installed: true,
+      entries: Array.isArray(window[BUFFER_KEY]) ? window[BUFFER_KEY].length : 0,
+      max: MAX,
+    };
+  })();`;
+}
+
+function buildConsoleReadScript(options = {}) {
+  const limit = clamp(parseNumber(options.limit, DEFAULT_LIMIT), 1, MAX_LIMIT);
+  const sinceTs = Math.max(0, parseNumber(options.sinceTs, 0) || 0);
+  const clear = options.clear === true;
+  const levels = Array.isArray(options.levels)
+    ? options.levels.map((item) => String(item || '').trim().toLowerCase()).filter(Boolean)
+    : [];
+  const levelsLiteral = JSON.stringify(levels);
+
+  return `(function readCamoDevtoolsConsole() {
+    const BUFFER_KEY = '__camo_console_buffer_v1__';
+    const raw = Array.isArray(window[BUFFER_KEY]) ? window[BUFFER_KEY] : [];
+    const levelSet = new Set(${levelsLiteral});
+    const list = raw.filter((entry) => {
+      if (!entry || typeof entry !== 'object') return false;
+      const ts = Number(entry.ts || 0);
+      if (ts < ${sinceTs}) return false;
+      if (levelSet.size === 0) return true;
+      return levelSet.has(String(entry.level || '').toLowerCase());
+    });
+    const entries = list.slice(Math.max(0, list.length - ${limit}));
+    if (${clear ? 'true' : 'false'}) {
+      window[BUFFER_KEY] = [];
+    }
+    return {
+      ok: true,
+      total: raw.length,
+      returned: entries.length,
+      sinceTs: ${sinceTs},
+      levels: Array.from(levelSet),
+      cleared: ${clear ? 'true' : 'false'},
+      entries,
+    };
+  })();`;
+}
+
+function buildEvalScript(expression) {
+  return `(async function runCamoDevtoolsEval() {
+    const expr = ${JSON.stringify(expression || '')};
+    const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+    const resultPayload = { ok: true, mode: 'expression', value: null, valueType: null };
+
+    const toSerializable = (value, depth = 0, seen = new WeakSet()) => {
+      if (value === null) return null;
+      if (typeof value === 'undefined') return '[undefined]';
+      if (typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean') return value;
+      if (typeof value === 'bigint') return value.toString();
+      if (typeof value === 'function') return '[function]';
+      if (typeof value === 'symbol') return value.toString();
+      if (value instanceof Error) return { name: value.name, message: value.message, stack: value.stack || null };
+      if (depth >= 3) return '[max-depth]';
+      if (Array.isArray(value)) return value.slice(0, 30).map((item) => toSerializable(item, depth + 1, seen));
+      if (typeof value === 'object') {
+        if (seen.has(value)) return '[circular]';
+        seen.add(value);
+        const out = {};
+        const keys = Object.keys(value).slice(0, 30);
+        for (const key of keys) {
+          out[key] = toSerializable(value[key], depth + 1, seen);
+        }
+        return out;
+      }
+      try {
+        return JSON.parse(JSON.stringify(value));
+      } catch {
+        return String(value);
+      }
+    };
+
+    try {
+      const fn = new AsyncFunction('return (' + expr + ')');
+      const value = await fn();
+      resultPayload.value = toSerializable(value);
+      resultPayload.valueType = typeof value;
+      return resultPayload;
+    } catch (exprError) {
+      try {
+        const fn = new AsyncFunction(expr);
+        const value = await fn();
+        resultPayload.mode = 'statement';
+        resultPayload.value = toSerializable(value);
+        resultPayload.valueType = typeof value;
+        return resultPayload;
+      } catch (statementError) {
+        return {
+          ok: false,
+          mode: 'statement',
+          error: {
+            message: statementError?.message || String(statementError),
+            stack: statementError?.stack || null,
+            expressionError: exprError?.message || String(exprError),
+          },
+        };
+      }
+    }
+  })();`;
+}
+
+async function ensureConsoleCollector(profileId, maxEntries = MAX_LIMIT) {
+  return callAPI('evaluate', {
+    profileId,
+    script: buildConsoleInstallScript(maxEntries),
+  });
+}
+
+async function handleLogs(args) {
+  const { profileId } = pickProfileAndExpression(args, 'logs');
+  if (!profileId) {
+    throw new Error('No default profile set. Run: camo profile default <profileId>');
+  }
+  const limit = clamp(parseNumber(readFlagValue(args, ['--limit', '-n']), DEFAULT_LIMIT), 1, MAX_LIMIT);
+  const sinceTs = Math.max(0, parseNumber(readFlagValue(args, ['--since']), 0) || 0);
+  const levelsRaw = readFlagValue(args, ['--levels', '--level']) || '';
+  const levels = levelsRaw
+    .split(',')
+    .map((item) => String(item || '').trim().toLowerCase())
+    .filter(Boolean);
+  const clear = args.includes('--clear');
+
+  const install = await ensureConsoleCollector(profileId, MAX_LIMIT);
+  const result = await callAPI('evaluate', {
+    profileId,
+    script: buildConsoleReadScript({ limit, sinceTs, levels, clear }),
+  });
+
+  console.log(JSON.stringify({
+    ok: true,
+    command: 'devtools.logs',
+    profileId,
+    collector: install?.result || install?.data || install || null,
+    result: result?.result || result?.data || result || null,
+  }, null, 2));
+}
+
+async function handleClear(args) {
+  const { profileId } = pickProfileAndExpression(args, 'clear');
+  if (!profileId) {
+    throw new Error('No default profile set. Run: camo profile default <profileId>');
+  }
+  await ensureConsoleCollector(profileId, MAX_LIMIT);
+  const result = await callAPI('evaluate', {
+    profileId,
+    script: buildConsoleReadScript({ limit: MAX_LIMIT, sinceTs: 0, clear: true }),
+  });
+  console.log(JSON.stringify({
+    ok: true,
+    command: 'devtools.clear',
+    profileId,
+    result: result?.result || result?.data || result || null,
+  }, null, 2));
+}
+
+async function handleEval(args) {
+  const { profileId, expression } = pickProfileAndExpression(args, 'eval');
+  if (!profileId) {
+    throw new Error('No default profile set. Run: camo profile default <profileId>');
+  }
+  if (!expression) {
+    throw new Error('Usage: camo devtools eval [profileId] <expression> [--profile <id>]');
+  }
+
+  await ensureConsoleCollector(profileId, MAX_LIMIT);
+  const result = await callAPI('evaluate', {
+    profileId,
+    script: buildEvalScript(expression),
+  });
+  console.log(JSON.stringify({
+    ok: true,
+    command: 'devtools.eval',
+    profileId,
+    expression,
+    result: result?.result || result?.data || result || null,
+  }, null, 2));
+}
+
+export async function handleDevtoolsCommand(args) {
+  const sub = String(args[1] || '').trim().toLowerCase();
+  switch (sub) {
+    case 'logs':
+      return handleLogs(args);
+    case 'clear':
+      return handleClear(args);
+    case 'eval':
+      return handleEval(args);
+    default:
+      console.log(`Usage: camo devtools <logs|eval|clear> [options]
+
+Commands:
+  logs [profileId] [--limit 120] [--since <unix_ms>] [--levels error,warn] [--clear]
+  eval [profileId] <expression> [--profile <id>]
+  clear [profileId]
+`);
+  }
+}

package/src/container/runtime-core/operations/selector-scripts.mjs

@@ -33,7 +33,20 @@ export function buildSelectorClickScript({ selector, highlight }) {
     }
     el.scrollIntoView({ behavior: 'smooth', block: 'center' });
     await new Promise((r) => setTimeout(r, 150));
-    el.click();
+    if (el instanceof HTMLElement) {
+      try { el.focus({ preventScroll: true }); } catch {}
+      const common = { bubbles: true, cancelable: true, view: window };
+      try {
+        if (typeof PointerEvent === 'function') {
+          el.dispatchEvent(new PointerEvent('pointerdown', { ...common, pointerType: 'mouse', button: 0 }));
+          el.dispatchEvent(new PointerEvent('pointerup', { ...common, pointerType: 'mouse', button: 0 }));
+        }
+      } catch {}
+      try { el.dispatchEvent(new MouseEvent('mousedown', { ...common, button: 0 })); } catch {}
+      try { el.dispatchEvent(new MouseEvent('mouseup', { ...common, button: 0 })); } catch {}
+    }
+    if (typeof el.click === 'function') el.click();
+    else el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window, button: 0 }));
     if (${highlightLiteral} && el instanceof HTMLElement) {
       setTimeout(() => { el.style.outline = restoreOutline; }, 260);
     }
@@ -56,9 +69,63 @@ export function buildSelectorTypeScript({ selector, highlight, text }) {
     }
     el.scrollIntoView({ behavior: 'smooth', block: 'center' });
     await new Promise((r) => setTimeout(r, 150));
-    el.focus();
-    el.value = ${textLiteral};
-    el.dispatchEvent(new Event('input', { bubbles: true }));
+    if (el instanceof HTMLElement) {
+      try { el.focus({ preventScroll: true }); } catch {}
+      if (typeof el.click === 'function') el.click();
+    }
+    const value = ${textLiteral};
+    const fireInputEvent = (target, name, init) => {
+      try {
+        if (typeof InputEvent === 'function') {
+          target.dispatchEvent(new InputEvent(name, init));
+          return;
+        }
+      } catch {}
+      target.dispatchEvent(new Event(name, { bubbles: true, cancelable: init?.cancelable === true }));
+    };
+    const assignControlValue = (target, next) => {
+      if (target instanceof HTMLInputElement) {
+        const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
+        if (setter) setter.call(target, next);
+        else target.value = next;
+        if (typeof target.setSelectionRange === 'function') {
+          const cursor = String(next).length;
+          try { target.setSelectionRange(cursor, cursor); } catch {}
+        }
+        return true;
+      }
+      if (target instanceof HTMLTextAreaElement) {
+        const setter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value')?.set;
+        if (setter) setter.call(target, next);
+        else target.value = next;
+        if (typeof target.setSelectionRange === 'function') {
+          const cursor = String(next).length;
+          try { target.setSelectionRange(cursor, cursor); } catch {}
+        }
+        return true;
+      }
+      return false;
+    };
+    const editableAssigned = assignControlValue(el, value);
+    if (!editableAssigned) {
+      if (el instanceof HTMLElement && el.isContentEditable) {
+        el.textContent = value;
+      } else {
+        throw new Error('Element not editable: ' + ${selectorLiteral});
+      }
+    }
+    fireInputEvent(el, 'beforeinput', {
+      bubbles: true,
+      cancelable: true,
+      data: value,
+      inputType: 'insertText',
+    });
+    fireInputEvent(el, 'input', {
+      bubbles: true,
+      cancelable: false,
+      data: value,
+      inputType: 'insertText',
+    });
     el.dispatchEvent(new Event('change', { bubbles: true }));
     if (${highlightLiteral} && el instanceof HTMLElement) {
       setTimeout(() => { el.style.outline = restoreOutline; }, 260);

package/src/utils/help.mjs

@@ -24,7 +24,7 @@ CONFIG:
 
 BROWSER CONTROL:
   init                                      Ensure camoufox + ensure browser-service daemon
-  start [profileId] [--url <url>] [--headless] [--alias <name>] [--idle-timeout <duration>] [--width <w> --height <h>]
+  start [profileId] [--url <url>] [--headless] [--devtools] [--alias <name>] [--idle-timeout <duration>] [--width <w> --height <h>]
   stop [profileId]
   stop --id <instanceId>                    Stop by instance id
   stop --alias <alias>                      Stop by alias
@@ -63,6 +63,11 @@ PAGES:
   switch-page [profileId] <index>
   list-pages [profileId]
 
+DEVTOOLS:
+  devtools logs [profileId] [--limit 120] [--since <unix_ms>] [--levels error,warn] [--clear]
+  devtools eval [profileId] <expression> [--profile <id>]
+  devtools clear [profileId]
+
 COOKIES:
   cookies get [profileId]                          Get all cookies for profile
   cookies save [profileId] --path <file>           Save cookies to file
@@ -97,7 +102,10 @@ EXAMPLES:
   camo profile default myprofile
   camo start --url https://example.com --alias main
   camo start worker-1 --headless --alias shard1 --idle-timeout 45m
+  camo start worker-1 --devtools
   camo start myprofile --width 1920 --height 1020
+  camo devtools eval myprofile "document.title"
+  camo devtools logs myprofile --levels error,warn --limit 50
   camo stop --id inst_xxxxxxxx
   camo stop --alias shard1
   camo stop idle