Files
2026-11-02 22:54:14 +08:00

247 lines
12 KiB
Python

"""Shared file transports and conservative upload transaction coordination.
An action acknowledgement is not upload readiness. Once an action might have
happened, no other transport is tried without reconciliation (fail closed).
"""
from __future__ import annotations
import base64
import json
import mimetypes
import time
from dataclasses import dataclass
from enum import Enum
from pathlib import Path
from app.core.config import WorkflowError
from app.core.tab_pool import get_clipboard_lock
from app.utils.attachments import attachment_config, type_allowed, MIB
from app.utils.platform import get_primary_modifier_key
from app.core.driver import as_element, driver_for_tab
class DispatchState(str, Enum):
NOT_DISPATCHED = "not_dispatched"
DISPATCHED = "dispatched"
UNKNOWN = "unknown"
@dataclass(frozen=True)
class DispatchResult:
state: DispatchState
transport: str
reason: str = ""
class AttachmentUploadCoordinator:
def __init__(self, tab, *, selectors=None, monitor=None, config=None,
cancelled=lambda: False, focus=None):
self.tab, self.monitor = tab, monitor
self.selectors = selectors or {}
self.config = attachment_config(config)
self.cancelled, self.focus = cancelled, focus
self.last_result = None
self.completed_paths = []
self.total_bytes = 0
self.tainted = False
self.resource_batch = None
self.planned_items = []
def _check(self):
if self.cancelled():
raise WorkflowError("attachment_cancelled")
if self.tainted:
raise WorkflowError("attachment_upload_unconfirmed")
def _element(self, selector):
if not selector:
return None
try:
return driver_for_tab(self.tab).find(selector, timeout=0.6)
except Exception:
return None
def _inputs(self):
configured = self.selectors.get("file_input")
try:
if configured:
return list(driver_for_tab(self.tab).find_all(configured, timeout=0.6) or [])
# Prefer composer-scoped lookup; retain legacy page lookup if no root was configured.
root_selector = self.selectors.get("composer_root")
root = self._element(root_selector) if root_selector else self.tab
return list(as_element(root).find_all('css:input[type="file"]', timeout=0.6) or []) if root else []
except Exception:
return []
def _file_input(self, path, mime):
for ele in self._inputs():
self._check()
try:
if ele.attr("disabled") is not None:
continue
accept = [v.strip().lower() for v in str(ele.attr("accept") or "").split(",") if v.strip()]
if not type_allowed(path.name, mime, accept):
continue
except Exception:
continue # not a usable target; no side effect yet
try:
# DrissionPage's file input uses CDP and dispatches its own change event.
# Never dispatch a second change here: frameworks may upload twice.
ele.input(str(path))
return DispatchResult(DispatchState.DISPATCHED, "file_input")
except Exception:
return DispatchResult(DispatchState.UNKNOWN, "file_input", "input_acknowledgement_missing")
return DispatchResult(DispatchState.NOT_DISPATCHED, "file_input", "no_compatible_input")
def _cdp_drop(self, path, mime):
zone = self._element(self.selectors.get("drop_zone"))
if zone is None:
return DispatchResult(DispatchState.NOT_DISPATCHED, "cdp_drop")
dropped = False
try:
point = as_element(zone).run_js("this.scrollIntoView({block:'center'}); const r=this.getBoundingClientRect(); return {x:r.x+r.width/2,y:r.y+r.height/2};")
if not isinstance(point, dict) or not all(isinstance(point.get(k), (int, float)) and point[k] > 0 for k in ("x", "y")):
return DispatchResult(DispatchState.NOT_DISPATCHED, "cdp_drop", "invalid_target")
data = {"items": [], "files": [str(path)], "dragOperationsMask": 1}
for event in ("dragEnter", "dragOver", "drop"):
self._check()
dropped = event == "drop"
driver_for_tab(self.tab).run_cdp("Input.dispatchDragEvent", type=event, x=point["x"], y=point["y"], data=data, modifiers=0)
return DispatchResult(DispatchState.DISPATCHED, "cdp_drop")
except WorkflowError:
raise
except Exception:
return DispatchResult(DispatchState.UNKNOWN if dropped else DispatchState.NOT_DISPATCHED, "cdp_drop", "cdp_unavailable")
def _js_drop(self, path, mime):
zone = self._element(self.selectors.get("drop_zone"))
if zone is None or path.stat().st_size > 4 * MIB:
return DispatchResult(DispatchState.NOT_DISPATCHED, "js_drop", "no_target_or_over_4mb")
# Bound the fallback's memory amplification. Large files use CDP/file input.
payload = json.dumps({"name": path.name, "mime": mime, "data": base64.b64encode(path.read_bytes()).decode("ascii")})
script = """
const p=PAYLOAD;
const bytes=Uint8Array.from(atob(p.data), c=>c.charCodeAt(0));
const dt=new DataTransfer(); dt.items.add(new File([bytes],p.name,{type:p.mime}));
for(const type of ['dragenter','dragover','drop']) this.dispatchEvent(new DragEvent(type,{bubbles:true,cancelable:true,dataTransfer:dt}));
return true;
""".replace("PAYLOAD", payload)
try:
as_element(zone).run_js(script)
return DispatchResult(DispatchState.DISPATCHED, "js_drop")
except Exception:
return DispatchResult(DispatchState.UNKNOWN, "js_drop", "drop_acknowledgement_missing")
def _clipboard(self, path, mime, image=False):
from app.utils.system_clipboard import (copy_file_to_native_clipboard, copy_image_to_native_clipboard,
ClipboardUnsupportedError, ClipboardDependencyError)
name = "image_clipboard" if image else "file_clipboard"
if image and not mime.startswith("image/"):
return DispatchResult(DispatchState.NOT_DISPATCHED, name)
pasted = False
try:
with get_clipboard_lock():
self._check()
if not self.focus or not self.focus():
return DispatchResult(DispatchState.NOT_DISPATCHED, name, "focus_not_confirmed")
copier = copy_image_to_native_clipboard if image else copy_file_to_native_clipboard
copier(str(path))
modifier = get_primary_modifier_key()
pasted = True
driver_for_tab(self.tab).actions.key_down(modifier).key_down("V").key_up("V").key_up(modifier)
return DispatchResult(DispatchState.DISPATCHED, name)
except (ClipboardUnsupportedError, ClipboardDependencyError):
return DispatchResult(DispatchState.NOT_DISPATCHED, name, "clipboard_unavailable")
except WorkflowError:
raise
except Exception:
return DispatchResult(DispatchState.UNKNOWN if pasted else DispatchState.NOT_DISPATCHED, name)
def _dispatch(self, name, path, mime):
if name == "file_input":
result = self._file_input(path, mime)
if result.state == DispatchState.NOT_DISPATCHED:
button = self._element(self.selectors.get("upload_btn"))
if button is not None:
try:
button.click()
except Exception:
pass # opening a chooser does not attach a file
self._check()
result = self._file_input(path, mime)
return result
if name == "cdp_drop":
return self._cdp_drop(path, mime)
if name == "js_drop":
return self._js_drop(path, mime)
return self._clipboard(path, mime, image=name == "image_clipboard")
def upload(self, filepath, mime=None):
self._check()
if not self.config["enabled"]:
raise WorkflowError("attachments_disabled")
if self.monitor is None:
raise WorkflowError("attachment_monitor_unavailable")
path = Path(filepath).resolve()
mime = mime or mimetypes.guess_type(path.name)[0] or "application/octet-stream"
try:
size = path.stat().st_size
except OSError:
raise WorkflowError("attachment_file_unavailable") from None
if not size:
raise WorkflowError("attachment_empty")
# Include not-yet-uploaded API attachments when uploading a generated prompt file.
# This catches combined quotas BEFORE the first upload side effect.
pending = [item for item in self.planned_items if str(item.path.resolve()) != str(path)
and str(item.path.resolve()) not in self.completed_paths]
if len(self.completed_paths) + 1 + len(pending) > self.config["max_count"]:
raise WorkflowError("attachment_count_exceeded")
if self.total_bytes + size + sum(item.byte_size for item in pending) > self.config["max_total_mb"] * MIB:
raise WorkflowError("attachment_size_exceeded")
if not type_allowed(path.name, mime, self.config["allowed_types"]):
raise WorkflowError("attachment_type_unsupported")
if len(self.completed_paths) >= self.config["max_count"]:
raise WorkflowError("attachment_count_exceeded")
if size > self.config["max_file_mb"] * MIB or self.total_bytes + size > self.config["max_total_mb"] * MIB:
raise WorkflowError("attachment_size_exceeded")
deadline = time.monotonic() + self.config["ready_timeout"]
names = [path.name] # no stem-only match against unrelated composer text
for name in self.config["transport_order"]:
self._check()
if time.monotonic() >= deadline:
break
baseline = self.monitor.begin_tracking(expected_names=names)
if not baseline:
raise WorkflowError("attachment_monitor_unavailable")
if self.resource_batch is not None:
self.resource_batch.may_be_reading = True
try:
result = self._dispatch(name, path, mime)
except WorkflowError:
raise
except Exception:
result = DispatchResult(DispatchState.UNKNOWN, name, "transport_failed")
self.last_result = result
if result.state == DispatchState.NOT_DISPATCHED:
continue
# Once a side effect is possible, no blind retry or transport fallback.
self.tainted = True
remaining = deadline - time.monotonic()
if remaining <= 0:
raise WorkflowError("attachment_upload_unconfirmed")
ready = self.monitor.wait_until_ready(
expected_names=names, require_observed=True, require_send_enabled=False,
accept_existing=False, start_new_tracking=False, require_fresh_preview=True,
max_wait=remaining, hard_max_wait=remaining, idle_timeout=remaining,
label=f"attachment:{name}",
)
if self.cancelled():
raise WorkflowError("attachment_cancelled")
if not ready.get("success"):
raise WorkflowError("attachment_upload_rejected" if ready.get("reason") == "upload_rejected" else "attachment_upload_unconfirmed")
self.tainted = False
self.completed_paths.append(str(path))
self.total_bytes += size
return True
raise WorkflowError("attachment_transport_unavailable")