yunti-browser-runtime 0.1.3 → 0.2.1

package/extension/content.js

@@ -338,7 +338,7 @@ function isExtensionContextInvalidated(error) {
 }
 
 function contextInvalidatedResponse() {
-  return { ok: false, error: "插件已重新加载，请刷新 browser page恢复连接。" }
+  return { ok: false, error: "插件已重新加载，正在等待扩展自动恢复连接；必要时再刷新页面。" }
 }
 
 function markExtensionContextInvalidated() {
@@ -366,6 +366,8 @@ function updateWidgetStatus(text, auth = null) {
 
 async function executeTool(tool, args) {
   switch (tool) {
+    case "yunti_observe_page":
+      return observePage(args)
     case "yunti_get_page_snapshot":
       return getPageSnapshot(args)
     case "yunti_get_selected_context":
@@ -380,6 +382,8 @@ async function executeTool(tool, args) {
       return clickElement(args)
     case "yunti_click_at":
       return clickAt(args)
+    case "yunti_hover":
+      return hoverElement(args)
     case "yunti_fill":
       return fillElement(args)
     case "yunti_type_text":
@@ -397,6 +401,14 @@ async function executeTool(tool, args) {
   }
 }
 
+function observePage(args = {}) {
+  if (!window.YuntiBrowserRuntimeObserver?.observePage) {
+    throw new Error("yunti_observe_page is unavailable because the DOM observer module was not loaded. Refresh the page and try again.")
+  }
+  window.__YUNTI_BROWSER_SESSION_ID__ = browserSessionId
+  return window.YuntiBrowserRuntimeObserver.observePage(args)
+}
+
 async function getPageSnapshot(args = {}) {
   const mode = args.mode === "detailed" ? "detailed" : "light"
   const includeElements = args.includeElements === undefined ? mode === "detailed" : Boolean(args.includeElements)
@@ -538,10 +550,13 @@ function rollbackPreviewPatch(patchId) {
 }
 
 function clickElement(args) {
-  const element = mustFind(args.selector)
-  element.scrollIntoView({ block: "center", inline: "center" })
-  element.click()
-  return { clicked: true, element: describeElement(element) }
+  if (args.selector) {
+    const element = mustFind(args.selector)
+    element.scrollIntoView({ block: "center", inline: "center" })
+    element.click()
+    return { clicked: true, element: describeElement(element) }
+  }
+  return clickAt(args)
 }
 
 function clickAt(args) {
@@ -559,12 +574,36 @@ function clickAt(args) {
   }
 }
 
+function hoverElement(args) {
+  const element = resolveTargetElement(args)
+  if (!element) throw new Error("yunti_hover requires selector or x/y coordinates")
+  element.scrollIntoView({ block: "center", inline: "center" })
+  const rect = element.getBoundingClientRect()
+  const x = Number.isFinite(Number(args.x)) ? Number(args.x) : rect.left + rect.width / 2
+  const y = Number.isFinite(Number(args.y)) ? Number(args.y) : rect.top + rect.height / 2
+  focusElement(element)
+  dispatchHoverSequence(element, x, y)
+  return {
+    hovered: true,
+    x: Math.round(x),
+    y: Math.round(y),
+    element: describeElement(element),
+  }
+}
+
 function fillElement(args) {
-  const element = mustFind(args.selector)
+  const element = resolveTargetElement(args)
+  if (!element) throw new Error("yunti_fill requires selector or x/y coordinates")
   const value = String(args.value ?? "")
   element.scrollIntoView({ block: "center", inline: "center" })
   setEditableText(element, value, { replace: true })
-  return { filled: true, element: describeElement(element), valueLength: value.length }
+  return {
+    filled: true,
+    element: describeElement(element),
+    valueLength: value.length,
+    valueApplied: getEditableText(element) === value,
+    method: element.isContentEditable ? "contenteditable" : element instanceof HTMLSelectElement ? "select" : "dom",
+  }
 }
 
 function typeText(args) {
@@ -602,25 +641,69 @@ function pressKey(args) {
 }
 
 function selectElement(args) {
-  const element = mustFind(args.selector)
+  const element = resolveTargetElement(args)
+  if (!element) throw new Error("yunti_select requires selector or x/y coordinates")
   if (!(element instanceof HTMLSelectElement)) throw new Error("Target is not a select element")
-  element.value = String(args.value ?? "")
+  const value = String(args.value ?? "")
+  const text = String(args.text ?? "")
+  const matchMode = text ? "text" : "value"
+  const targetOption = text || value
+  const options = Array.from(element.options)
+  const option = options.find((item) => matchMode === "text" ? item.text.trim() === targetOption : item.value === targetOption)
+  if (!option) {
+    return {
+      selected: false,
+      element: describeElement(element),
+      value: element.value,
+      code: "OPTION_NOT_FOUND",
+      error: matchMode === "text" ? "Option text not found" : "Option value not found",
+      matchMode,
+      targetOption,
+      availableValues: options.map((item) => item.value).slice(0, 50),
+      availableTexts: options.map((item) => item.text.trim()).slice(0, 50),
+      options: summarizeSelectOptions(options),
+    }
+  }
+  if (option?.disabled) {
+    return {
+      selected: false,
+      element: describeElement(element),
+      value: element.value,
+      code: "OPTION_DISABLED",
+      error: matchMode === "text" ? "Option text is disabled" : "Option value is disabled",
+      matchMode,
+      targetOption,
+      disabledValue: option.value,
+      disabledText: option.text.trim(),
+      availableValues: options.map((item) => item.value).slice(0, 50),
+      availableTexts: options.map((item) => item.text.trim()).slice(0, 50),
+      options: summarizeSelectOptions(options),
+    }
+  }
+  element.value = option.value
   element.dispatchEvent(new Event("input", { bubbles: true }))
   element.dispatchEvent(new Event("change", { bubbles: true }))
-  return { selected: true, element: describeElement(element), value: element.value }
+  return {
+    selected: true,
+    element: describeElement(element),
+    value: element.value,
+    text: option.text.trim(),
+    selectedIndex: element.selectedIndex,
+  }
 }
 
 function scrollPage(args) {
   const deltaX = Number.isFinite(Number(args.deltaX)) ? Number(args.deltaX) : 0
   const deltaY = Number.isFinite(Number(args.deltaY)) ? Number(args.deltaY) : 600
+  const hasCoordinateTarget = Number.isFinite(Number(args.x)) && Number.isFinite(Number(args.y))
+  const coordinateX = hasCoordinateTarget ? clamp(Number(args.x), 0, Math.max(0, window.innerWidth - 1)) : undefined
+  const coordinateY = hasCoordinateTarget ? clamp(Number(args.y), 0, Math.max(0, window.innerHeight - 1)) : undefined
   const coordinateTarget =
-    Number.isFinite(Number(args.x)) && Number.isFinite(Number(args.y))
-      ? document.elementFromPoint(
-          clamp(Number(args.x), 0, Math.max(0, window.innerWidth - 1)),
-          clamp(Number(args.y), 0, Math.max(0, window.innerHeight - 1))
-        )
+    hasCoordinateTarget
+      ? document.elementFromPoint(coordinateX, coordinateY)
       : null
-  const target = findScrollableAncestor(coordinateTarget) || document.scrollingElement || document.documentElement
+  const scrollableAncestor = findScrollableAncestor(coordinateTarget)
+  const target = scrollableAncestor || document.scrollingElement || document.documentElement
   const before = getScrollPosition(target)
   target.scrollBy({ left: deltaX, top: deltaY, behavior: "auto" })
   const after = getScrollPosition(target)
@@ -629,6 +712,18 @@ function scrollPage(args) {
     deltaX,
     deltaY,
     target: target === document.scrollingElement ? "document" : describeElement(target),
+    ...(hasCoordinateTarget
+      ? {
+          coordinateTarget: {
+            x: Math.round(coordinateX),
+            y: Math.round(coordinateY),
+            found: Boolean(coordinateTarget),
+            ...(coordinateTarget ? { element: describeElement(coordinateTarget) } : {}),
+          },
+          scrollContainerFound: Boolean(scrollableAncestor),
+          ...(scrollableAncestor ? {} : { coordinateScrollFallback: "document" }),
+        }
+      : {}),
     before,
     after,
   }
@@ -650,6 +745,15 @@ function resolveTargetElement(args = {}) {
   return null
 }
 
+function summarizeSelectOptions(options) {
+  return options.slice(0, 50).map((item) => ({
+    value: item.value,
+    text: item.text.trim(),
+    disabled: Boolean(item.disabled),
+    selected: Boolean(item.selected),
+  }))
+}
+
 function focusElement(element) {
   if (element && typeof element.focus === "function") {
     element.focus({ preventScroll: true })
@@ -677,7 +781,29 @@ function dispatchPointerMouseSequence(element, x, y) {
   }
 }
 
+function dispatchHoverSequence(element, x, y) {
+  const common = {
+    bubbles: true,
+    cancelable: true,
+    composed: true,
+    clientX: x,
+    clientY: y,
+    view: window,
+  }
+  for (const type of ["pointerover", "pointerenter", "pointermove"]) {
+    try {
+      element.dispatchEvent(new PointerEvent(type, { ...common, pointerType: "mouse", isPrimary: true }))
+    } catch {
+      break
+    }
+  }
+  for (const type of ["mouseover", "mouseenter", "mousemove"]) {
+    element.dispatchEvent(new MouseEvent(type, common))
+  }
+}
+
 function setEditableText(element, text, options = {}) {
+  assertEditableTarget(element)
   if (element.isContentEditable) {
     const next = options.replace ? text : `${element.textContent || ""}${text}`
     element.textContent = next
@@ -692,6 +818,31 @@ function setEditableText(element, text, options = {}) {
   element.dispatchEvent(new Event("change", { bubbles: true }))
 }
 
+function assertEditableTarget(element) {
+  if (!element) throw new Error("No editable target is focused")
+  const style = getComputedStyle(element)
+  const rect = element.getBoundingClientRect()
+  const tag = element.tagName.toLowerCase()
+  const type = String(element.type || "").toLowerCase()
+  if (element.hidden || style.display === "none" || style.visibility === "hidden" || Number(style.opacity) === 0 || rect.width <= 0 || rect.height <= 0) {
+    throw new Error("Target element is hidden or has no size")
+  }
+  if (element.disabled || element.getAttribute("aria-disabled") === "true") {
+    throw new Error("Target element is disabled")
+  }
+  if (element.readOnly || element.getAttribute("aria-readonly") === "true") {
+    throw new Error("Target element is readonly")
+  }
+  if (element.isContentEditable) return
+  if ("value" in element) {
+    if (tag === "input" && ["button", "checkbox", "color", "file", "hidden", "image", "radio", "range", "reset", "submit"].includes(type)) {
+      throw new Error(`Target input type ${type} is not editable`)
+    }
+    return
+  }
+  throw new Error("Target element is not editable")
+}
+
 function setNativeValue(element, value) {
   const prototype = Object.getPrototypeOf(element)
   const descriptor = Object.getOwnPropertyDescriptor(prototype, "value")