mirror of
https://github.com/openswarm-ai/openswarm.git
synced 2026-09-26 11:34:50 +02:00
3008f083ca
* [eric] ci: gitleaks-ignore the known historical secrets so our branch stops failing on leaks it didnt add * [eric] workflows: restore scheduled-tasks on the workflow line (revert removal, keep windows fixes + 1.1.69) * [eric] workflows: re-apply uncommitted scheduling wip (schedule pill, calendar view, slice) * [eric] ops: gitignore dev-team local state files * [eric] ops: backlog item for download-tracking visibility * [eric] ci: allowlist the cdp-routes redaction-test token in gitleaks * [aidan] feat/scheduled-tasks: keep step labels in sync on edit and show chevron on every step * [aidan] fix: schedule time in chat * [aidan] ux/workflows: add workflow step removal (#91) * [aidan] feat/scheduled-tasks: remember workflow tool permissions across runs * [aidan] feat/task-scheduling: add hourly and minute (15-min minimum) schedule intervals (#93) * [aidan] feat/scheduled-tasks: calendar, rename, and edit workflows (#94) * [aidan] bug: fix schedule button * [aidan] fix/agent-errors: surface provider rate limits * [aidan] ux/cards: click-to-rename for chat and workflow titles Single-click a card's title to enter edit mode inline. Commit on Enter/blur, cancel on Escape. Rename persists via PATCH for workflows and sessions. * [aidan] feat/workflows: seed build prompt for zero-step workflows When a new workflow has no steps, seed the agent with a prompt asking the user to describe what the workflow should do, rather than starting blank. * [aidan] feat/workflows: add-to-schedule popover for unscheduled workflows Clicking the "+" on an unscheduled workflow row opens a popover with two options: - Keep this schedule: enables the workflow's existing cadence and moves it to Scheduled - Change schedule: opens the scheduling editor to pick a different time * [aidan] ux/workflows: wire add-to-schedule popover and simplify New button - Made the "+" icon on unscheduled workflow rows clickable, opening a popover to keep or change the schedule - Removed AddIcon from toolbar "New" button (now reads "New" instead of "+ New") * [aidan] fix/scheduled-tasks: open schedule calendar when Schedule pill clicked Fixed the Schedule pill click being swallowed by the toolbar's dismiss handler. Exempted the toolbar pills via data-toolbar-pills so their click handlers fire. * [aidan] ux/workflows: open New workflow in agent build chat instead of empty card When creating a new workflow from the hub, open it in edit_agent view (with the agent builder chat) instead of a preview card. The workflow is created on the backend first so the embedded session has a real ID. * [aidan] feat/workflow-edit: add draft testing save flow * [aidan] ux/chat: remove continue chat button * [aidan] ux/workflows: polish workflow card interactions * [aidan] fix/workflow-scheduling: save unscheduled workflows as drafts * aidan ui: schedule naming changes * [aidan] ui: tool calling desc/naming * [aidan] ui: calendar sidebar naming * [aidan] ui: fix stop viewing closing chat * [aidan] feat/workflows: auto-name workflows and polish the build flow (#95) * [aidan] feat/workflow-auto-naming: auto-generate workflow titles from steps Generate a title + description from a workflow's steps (one aux call, reused for step labels) whenever it is still auto_named, so a workflow built in the Edit Agent names itself on commit instead of staying "New workflow". A manual rename sets auto_named=False and is never overwritten. Stream the aux call (non-streaming drops content on some 9router lanes) and fall back to a step-derived title when the model is unavailable. * [aidan] feat/workflows: hide unsaved new workflows until first save A brand-new "+ New" workflow is created with unsaved=true and kept out of the hub's scheduled/unscheduled lists while the user is still building it in the Edit Agent. The first commit (Save) clears the flag and the workflow appears. Every other create path stays visible immediately. * [aidan] ux/workflows: remove redundant save workflow button The Edit Agent already has Discard/Save controls in its strip, so the header "Save Workflow" button was a duplicate save path. Remove it and its pulse/edit-session-id wiring; the model/time subtitle stays. * [aidan] ux/workflows: animate title on auto-rename Wrap the workflow card title in the same Typewriter the chat card uses, so when the auto-generated name replaces the placeholder after Save it retypes letter-by-letter. Gated on a real (non-placeholder) title so it never animates on mount or for already-named workflows. * [aidan] ux/workflows: animate sidebar title on auto-rename Wrap the calendar hub's sidebar row title in the same Typewriter the workflow card uses, so a title that auto-renames retypes letter-by-letter in the sidebar too. Extract the placeholder/isRealTitle guard into the shared workflowVisuals so the card and sidebar stay in sync. * [aidan] fix/workflows: connect watch tether, keep watched chat open, wire draft run/history * [aidan] ui: grey out chat pill when not selected * [aidan] ui: fix running agent display * [aidan] feat/history-popover: add chat history and scheduled tasks run log tabs (#96) * [aidan] ux/schedule: toast when calendar view already open on expand * [aidan] ui: fix popover descs * [aidan] feat/workflow-runs: add pause, resume, and stop controls for live runs * [aidan] feat/schedule-calendar: add calendar occurrences endpoint and concrete timezones * [aidan] feat/workflows: require at least one step to save a workflow * [aidan] ux/edit-agent: hide Discard for an unsaved new workflow * [aidan] ux/edit-agent: move fix-prefix card below the step list * [aidan] feat/workflows: toast when an unattended scheduled run starts * [aidan] fix/dashboard-tethers: anchor workflow-sidecar tethers to measured card rects * [aidan] feat/workflows: validate steps before scheduling and keep chat tool memory * [aidan] feat/mcp-suggestions: dismissable integration banner with per-session cooldown * [aidan] feat/workflows: add scheduled-run "running now" toast with click-to-view (#97) * [aidan] ux/workflows: surface paused state on card, sidebar, and calendar; tidy run history * [aidan] feat/mcp-suggestions: suggest both Google and Microsoft when provider is ambiguous * [aidan] fix/agent-tokens: friendly out-of-tokens card across all agent surfaces * [aidan] feat/workflow-model: persist edit-agent model on save with switch notice and fresh drafts * [aidan] fix/workflow-chat: force stop on watched run mirrors workflow card stop * [aidan] fix/workflow-cards: keep watched run tethered on finish to avoid duplicate chat * [aidan] feat/schedule-calendar: mark current time with a now line in week view * [aidan] refactor/private-names: rename error and schedule classifiers from _ to p_ * [aidan] feat/scheduled-tasks: agent workflow scheduling and in-chat convert (#98) * [aidan] feat/workflow-suggest: nudge user to convert repeatable chat to workflow Add SuggestConvertToWorkflow MCP tool that agents call at the end of a task when they've completed something worth repeating (daily report, weekly check, recurring data pull). Frontend detects the tool call and glows the "Convert to workflow" button 3 times to draw the eye. When user clicks it, the suggested cadence (e.g. "every weekday at 9am") is stored in the draft and seeded into the scheduling agent's first prompt, so the agent can act on the suggestion rather than asking the user again. Tool is never auto-called — agents decide when a task is genuinely repeatable (not debugging, creative work, one-off lookup). Tool description emphasizes sparse, high-confidence use only (once per session max). Files changed: - backend/apps/agents/schedule_mcp_server.py: add SuggestConvertToWorkflow tool - frontend/src/shared/mcpToolMeta.ts: add label for new tool - frontend/src/app/pages/Dashboard/cards/AgentCard.tsx: detect suggestion in session messages, show+glow "Convert to workflow" button, pass cadence to draft - frontend/src/shared/state/workflowsSlice.ts: add suggested_cadence field to Workflow interface - frontend/src/app/pages/Workflows/SchedulingView.tsx: seed scheduling agent prompt with suggested cadence hint * [aidan] feat/agent-scheduling: route recurring asks through native workflows, deny claude cron skill * [aidan] feat/workflow-convert: in-chat convert popup and auto-open scheduled workflow card * [aidan] ux/calendar-page: schedule calendar restyle + popover fixes (#99) * [aidan] fix/dashboard-delete: remove workflows calendar panel on delete key * [aidan] ux/workflows-calendar: restyle hub, fix today highlight, add toolbar toggle * [aidan] ux/schedule-popover: compact density, fix sticky header bleed, add header spacing * [aidan] ux/schedule-calendar: hollow ring dot for past fires in month view * [aidan] ux/schedule-calendar: clickable +N more opens day's full run list * [aidan] feat/run-log-filters: add success and skipped pills to scheduled task history * [aidan] fix/convert-button: stop drag capture so convert-to-workflow click fires * [aidan] ux/calendar-card: match border color and radius to chat and workflow cards * [aidan] fix/minimap: render missed-runs card on the minimap * [aidan] ux/run-sparkline: simplify tooltip to plain run tally * [aidan] ux/run-history: collapse expanded run view to one clickable line * [aidan] ux/calendar-card: match corner radius to browser cards * [aidan] feat/workflows: launch-time scheduling UX and workflow-card polish (#101) * [aidan] feat/schedule-list: lazy-load list view via scroll sentinel * [aidan] feat/missed-runs: launch toast with per-workflow counts and pan-to-card * [aidan] fix/dashboard-tethers: keep watching line anchored on canvas zoom * [aidan] feat/scheduled-tasks: review missed runs at launch instead of auto-firing on_missed * [aidan] refactor/workflow-cards: use radius and status design tokens, polish card chrome * [aidan] ux/agent-card: keep convert-to-workflow visible during runs with mid-turn toast * [aidan] ux/mcp-bubble: drop redundant verb label when a workflow label is shown * [aidan] chore/backend: remove stale explanatory comments * [aidan] fix/workflows-hub: load workflows on hub mount so calendar fills at launch * [aidan] feat/workflows: generate title, description, step labels at convert time * [aidan] fix/tidy-layout: include workflows hub in tidy and fit-to-view * [aidan] feat/schedule-list: window long list via measured-height virtualizer * [aidan] ux/workflows-hub: remove time-saved badge from calendar header * [aidan] fix/types: add missing semantic-type labels and drop stray fade arg * [aidan] feat/schedule: pin monthly day-of-month and honor repeat-every intervals * [aidan] feat/schedule: inherit source-session tool surface for scheduled runs * [aidan] ux/calendar: restack hour-cell events as bars with overflow affordance * [aidan] feat/calendar: open the run card when clicking a scheduled occurrence * [aidan] ux/missed-runs: add per-group select-all toggle and rename skip action * [aidan] feat: new scheduled task design ported * [aidan] ui: sidebar reorder, repeat controls on schedule card * [aidan] ui: sidebar, scheduling time * [aidan] feat/schedule: pin monthly last-day-of-month * [aidan] feat/steps: per-step enable toggle * [aidan] feat/workflows: per-workflow color swatch * [aidan] feat/trash: soft-delete workflows with restore and purge * [aidan] feat/run-monitor: live run monitor card on the canvas * [aidan] feat/run-context: attach a run as removable chat context * [aidan] feat/compose: new-workflow landing page and auto-commit build flow * [aidan] ui/workflows: dark mode and design-system cohesion * [aidan] ui/calendar: overflow popover, condensed week view, scroll fix * [aidan] feat/home: ongoing runs, missed review, and accurate Coming-up counts * [aidan] fix/run-status: sync ongoing runs and heal stuck/interrupted runs * [aidan] ux/schedule: last-day-of-month UI, Run-at time typing, interval input * [aidan] ux/workflows: default window size and toolbar icon * [aidan] fix/schedule: measure ran_late from start and anchor recurrences to created_at * [aidan] feat/calendar: render fire times from backend, drop JS recurrence reimpl * [aidan] chore/dashboard: drop dead configure/missed-run cards, refetch on reconnect * [aidan] chore/agent-card: remove unreachable convert-to-workflow action * [aidan] fix/workflows: don't bump updated_at on a no-op draft commit so viewing a workflow doesn't reorder the sidebar * [aidan] feat/schedule: warn when scheduling a workflow that has no steps * [aidan] fix/selection-tool: never select the workflows app, and exit the tool on Escape without dropping selections * [aidan] ux/compose: diversify new-workflow starter prompts across personas * [aidan] ux/run-monitor: spawn the run card a bit farther right of the workflows app * [aidan] fix/schedule: harden run recovery and storage writes against crashes * [aidan] ux/compose: restyle new-workflow starters as a clean pill cluster with rich prompts * [aidan] fix/workflows: optimistically apply edits so the schedule banner updates instantly * [aidan] ui/workflows: three-tone surface depth so the window lifts off the canvas in both themes * [aidan] ui/workflows: close buttons turn red on hover, matching the chat card * [aidan] test/schedule: cover executor pipeline, storage durability, and recurrence gaps * [aidan] fix: remove package-lock json * [aidan] fix/workflows-compose: keep compose view until edit agent replies * [aidan] feat/workflows: auto-generate workflow + step titles with typewriter animation * [eric] deps: restore frontend/package-lock.json (PR #105 deletion broke npm ci) --------- Co-authored-by: Eric <ciregenz@berkeley.edu> Co-authored-by: cire <134991075+ciregenz@users.noreply.github.com>
882 lines
31 KiB
Python
882 lines
31 KiB
Python
# cython: language_level=3str
|
|
|
|
"""A cleanup tool for HTML.
|
|
|
|
Removes unwanted tags and content. See the `Cleaner` class for
|
|
details.
|
|
"""
|
|
|
|
import copy
|
|
import re
|
|
from collections import deque
|
|
from urllib.parse import urlsplit, unquote_plus
|
|
import warnings
|
|
|
|
from lxml import etree
|
|
from lxml.html import defs
|
|
from lxml.html import fromstring as lxml_fromstring, XHTML_NAMESPACE
|
|
from lxml.html import xhtml_to_html, _transform_result
|
|
|
|
|
|
__all__ = ['clean_html', 'clean', 'Cleaner', 'autolink', 'autolink_html',
|
|
'word_break', 'word_break_html', 'LXMLHTMLCleanWarning', 'AmbiguousURLWarning']
|
|
|
|
# Look at http://code.sixapart.com/trac/livejournal/browser/trunk/cgi-bin/cleanhtml.pl
|
|
# Particularly the CSS cleaning; most of the tag cleaning is integrated now
|
|
# I have multiple kinds of schemes searched; but should schemes be
|
|
# whitelisted instead?
|
|
# max height?
|
|
# remove images? Also in CSS? background attribute?
|
|
# Some way to whitelist object, iframe, etc (e.g., if you want to
|
|
# allow *just* embedded YouTube movies)
|
|
# Log what was deleted and why?
|
|
# style="behavior: ..." might be bad in IE?
|
|
# Should we have something for just <meta http-equiv>? That's the worst of the
|
|
# metas.
|
|
# UTF-7 detections? Example:
|
|
# <HEAD><META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=UTF-7"> </HEAD>+ADw-SCRIPT+AD4-alert('XSS');+ADw-/SCRIPT+AD4-
|
|
# you don't always have to have the charset set, if the page has no charset
|
|
# and there's UTF7-like code in it.
|
|
# Look at these tests: http://htmlpurifier.org/live/smoketests/xssAttacks.php
|
|
|
|
|
|
# This is an IE-specific construct you can have in a stylesheet to
|
|
# run some Javascript:
|
|
_replace_css_javascript = re.compile(
|
|
r'expression\s*\(.*?\)', re.S|re.I).sub
|
|
|
|
# Do I have to worry about @\nimport?
|
|
_replace_css_import = re.compile(
|
|
r'@\s*import', re.I).sub
|
|
|
|
_looks_like_tag_content = re.compile(
|
|
r'</?[a-zA-Z]+|\son[a-zA-Z]+\s*=',
|
|
(re.ASCII)).search
|
|
|
|
# All kinds of schemes besides just javascript: that can cause
|
|
# execution:
|
|
_find_image_dataurls = re.compile(
|
|
r'data:image/(.+?);base64,', re.I).findall
|
|
_possibly_malicious_schemes = re.compile(
|
|
r'(javascript|jscript|livescript|vbscript|data|about|mocha):',
|
|
re.I).findall
|
|
# SVG images can contain script content
|
|
_is_unsafe_image_type = re.compile(r"(xml|svg)", re.I).search
|
|
|
|
def _has_javascript_scheme(s):
|
|
safe_image_urls = 0
|
|
for image_type in _find_image_dataurls(s):
|
|
if _is_unsafe_image_type(image_type):
|
|
return True
|
|
safe_image_urls += 1
|
|
return len(_possibly_malicious_schemes(s)) > safe_image_urls
|
|
|
|
_substitute_whitespace = re.compile(r'[\s\x00-\x08\x0B\x0C\x0E-\x19]+').sub
|
|
|
|
# FIXME: check against: http://msdn2.microsoft.com/en-us/library/ms537512.aspx
|
|
_conditional_comment_re = re.compile(
|
|
r'\[if[\s\n\r]+.*?][\s\n\r]*>', re.I|re.S)
|
|
|
|
_find_styled_elements = etree.XPath(
|
|
"descendant-or-self::*[@style]")
|
|
|
|
_find_external_links = etree.XPath(
|
|
("descendant-or-self::a [normalize-space(@href) and substring(normalize-space(@href),1,1) != '#'] |"
|
|
"descendant-or-self::x:a[normalize-space(@href) and substring(normalize-space(@href),1,1) != '#']"),
|
|
namespaces={'x':XHTML_NAMESPACE})
|
|
|
|
# Regex to remove all ASCII control characters (00-1F,7F) except:
|
|
# - 09 - Horizontal tab
|
|
# - 0A - Line Feed
|
|
# - 0B - Vertical tab
|
|
# - 0D - Carriage Return
|
|
_ascii_control_characters_str = re.compile("[\x00-\x08\x0C\x0E-\x1F\x7F]")
|
|
_ascii_control_characters_bytes = re.compile(b"[\x00-\x08\x0C\x0E-\x1F\x7F]")
|
|
|
|
|
|
def fromstring(data):
|
|
"""
|
|
Enhanced fromstring function that removes ASCII control chars
|
|
before passing the input to the original lxml.html.fromstring.
|
|
"""
|
|
if isinstance(data, bytes):
|
|
return lxml_fromstring(_ascii_control_characters_bytes.sub(b"", data))
|
|
else:
|
|
return lxml_fromstring(_ascii_control_characters_str.sub("", data))
|
|
|
|
|
|
# This regular expression is inspired by the one in urllib3.
|
|
_URI_RE = re.compile(
|
|
r"^(?:(?P<scheme>[a-zA-Z][a-zA-Z0-9+.-]*[a-zA-Z0-9]):)?"
|
|
r"(?://(?P<authority>[^\\/?#]*))?"
|
|
r"(?P<path>[^?#]*)"
|
|
r"(?:\?(?P<query_string>[^#]*))?"
|
|
r"(?:#(?P<fragment>.*))?$",
|
|
re.UNICODE,
|
|
)
|
|
|
|
|
|
def _get_authority_from_url(url):
|
|
match = _URI_RE.match(url)
|
|
if match:
|
|
return match.group("authority")
|
|
else:
|
|
return None
|
|
|
|
|
|
class LXMLHTMLCleanWarning(Warning):
|
|
pass
|
|
|
|
|
|
class AmbiguousURLWarning(LXMLHTMLCleanWarning):
|
|
pass
|
|
|
|
|
|
class Cleaner:
|
|
"""
|
|
Instances cleans the document of each of the possible offending
|
|
elements. The cleaning is controlled by attributes; you can
|
|
override attributes in a subclass, or set them in the constructor.
|
|
|
|
``scripts``:
|
|
Removes any ``<script>`` tags.
|
|
|
|
``javascript``:
|
|
Removes any Javascript, like an ``onclick`` attribute. Also removes stylesheets
|
|
as they could contain Javascript.
|
|
|
|
``comments``:
|
|
Removes any comments.
|
|
|
|
``style``:
|
|
Removes any style tags.
|
|
|
|
``inline_style``
|
|
Removes any style attributes. Defaults to the value of the ``style`` option.
|
|
|
|
``links``:
|
|
Removes any ``<link>`` tags
|
|
|
|
``meta``:
|
|
Removes any ``<meta>`` tags
|
|
|
|
``page_structure``:
|
|
Structural parts of a page: ``<head>``, ``<html>``, ``<title>``.
|
|
|
|
``processing_instructions``:
|
|
Removes any processing instructions.
|
|
|
|
``embedded``:
|
|
Removes any embedded objects (flash, iframes)
|
|
|
|
``frames``:
|
|
Removes any frame-related tags
|
|
|
|
``forms``:
|
|
Removes any form tags
|
|
|
|
``annoying_tags``:
|
|
Tags that aren't *wrong*, but are annoying. ``<blink>`` and ``<marquee>``
|
|
|
|
``remove_tags``:
|
|
A list of tags to remove. Only the tags will be removed,
|
|
their content will get pulled up into the parent tag.
|
|
|
|
``kill_tags``:
|
|
A list of tags to kill. Killing also removes the tag's content,
|
|
i.e. the whole subtree, not just the tag itself.
|
|
|
|
``allow_tags``:
|
|
A list of tags to include (default include all).
|
|
|
|
``remove_unknown_tags``:
|
|
Remove any tags that aren't standard parts of HTML.
|
|
|
|
``safe_attrs_only``:
|
|
If true, only include 'safe' attributes (specifically the list
|
|
from the feedparser HTML sanitisation web site).
|
|
|
|
``safe_attrs``:
|
|
A set of attribute names to override the default list of attributes
|
|
considered 'safe' (when safe_attrs_only=True).
|
|
|
|
``add_nofollow``:
|
|
If true, then any <a> tags will have ``rel="nofollow"`` added to them.
|
|
|
|
``host_whitelist``:
|
|
A list or set of hosts that you can use for embedded content
|
|
(for content like ``<object>``, ``<link rel="stylesheet">``, etc).
|
|
You can also implement/override the method
|
|
``allow_embedded_url(el, url)`` or ``allow_element(el)`` to
|
|
implement more complex rules for what can be embedded.
|
|
Anything that passes this test will be shown, regardless of
|
|
the value of (for instance) ``embedded``.
|
|
|
|
Note that this parameter might not work as intended if you do not
|
|
make the links absolute before doing the cleaning.
|
|
|
|
Note that you may also need to set ``whitelist_tags``.
|
|
|
|
Note that URLs are parsed via functions from ``urllib.parse`` and
|
|
no input validation is performed.
|
|
|
|
``whitelist_tags``:
|
|
A set of tags that can be included with ``host_whitelist``.
|
|
The default is ``iframe`` and ``embed``; you may wish to
|
|
include other tags like ``script``, or you may want to
|
|
implement ``allow_embedded_url`` for more control. Set to None to
|
|
include all tags.
|
|
|
|
This modifies the document *in place*.
|
|
"""
|
|
|
|
scripts = True
|
|
javascript = True
|
|
comments = True
|
|
style = False
|
|
inline_style = None
|
|
links = True
|
|
meta = True
|
|
page_structure = True
|
|
processing_instructions = True
|
|
embedded = True
|
|
frames = True
|
|
forms = True
|
|
annoying_tags = True
|
|
remove_tags = ()
|
|
allow_tags = ()
|
|
kill_tags = ()
|
|
remove_unknown_tags = True
|
|
safe_attrs_only = True
|
|
safe_attrs = defs.safe_attrs
|
|
add_nofollow = False
|
|
host_whitelist = ()
|
|
whitelist_tags = {'iframe', 'embed'}
|
|
|
|
def __init__(self, **kw):
|
|
not_an_attribute = object()
|
|
for name, value in kw.items():
|
|
default = getattr(self, name, not_an_attribute)
|
|
if default is None or default is True or default is False:
|
|
pass
|
|
elif isinstance(default, (frozenset, set, tuple, list)):
|
|
# Catch common error of passing ('host') instead of a tuple.
|
|
if isinstance(value, str):
|
|
raise TypeError(
|
|
f"Expected a collection, got str: {name}={value!r}")
|
|
else:
|
|
raise TypeError(
|
|
f"Unknown parameter: {name}={value!r}")
|
|
setattr(self, name, value)
|
|
|
|
if self.inline_style is None and 'inline_style' not in kw:
|
|
self.inline_style = self.style
|
|
|
|
if kw.get("allow_tags"):
|
|
if kw.get("remove_unknown_tags"):
|
|
raise ValueError("It does not make sense to pass in both "
|
|
"allow_tags and remove_unknown_tags")
|
|
self.remove_unknown_tags = False
|
|
|
|
self.host_whitelist = frozenset(self.host_whitelist) if self.host_whitelist else ()
|
|
|
|
# Used to lookup the primary URL for a given tag that is up for
|
|
# removal:
|
|
_tag_link_attrs = dict(
|
|
script='src',
|
|
link='href',
|
|
# From: http://java.sun.com/j2se/1.4.2/docs/guide/misc/applet.html
|
|
# From what I can tell, both attributes can contain a link:
|
|
applet=['code', 'object'],
|
|
iframe='src',
|
|
embed='src',
|
|
layer='src',
|
|
# FIXME: there doesn't really seem like a general way to figure out what
|
|
# links an <object> tag uses; links often go in <param> tags with values
|
|
# that we don't really know. You'd have to have knowledge about specific
|
|
# kinds of plugins (probably keyed off classid), and match against those.
|
|
##object=?,
|
|
# FIXME: not looking at the action currently, because it is more complex
|
|
# than than -- if you keep the form, you should keep the form controls.
|
|
##form='action',
|
|
a='href',
|
|
)
|
|
|
|
def __call__(self, doc):
|
|
"""
|
|
Cleans the document.
|
|
"""
|
|
try:
|
|
getroot = doc.getroot
|
|
except AttributeError:
|
|
pass # Element instance
|
|
else:
|
|
doc = getroot() # ElementTree instance, instead of an element
|
|
# convert XHTML to HTML
|
|
xhtml_to_html(doc)
|
|
# Normalize a case that IE treats <image> like <img>, and that
|
|
# can confuse either this step or later steps.
|
|
for el in doc.iter('image'):
|
|
el.tag = 'img'
|
|
if not self.comments:
|
|
# Of course, if we were going to kill comments anyway, we don't
|
|
# need to worry about this
|
|
self.kill_conditional_comments(doc)
|
|
|
|
kill_tags = set(self.kill_tags or ())
|
|
remove_tags = set(self.remove_tags or ())
|
|
allow_tags = set(self.allow_tags or ())
|
|
|
|
if self.scripts:
|
|
kill_tags.add('script')
|
|
if self.safe_attrs_only:
|
|
safe_attrs = set(self.safe_attrs)
|
|
for el in doc.iter(etree.Element):
|
|
attrib = el.attrib
|
|
for aname in attrib.keys():
|
|
if aname not in safe_attrs:
|
|
del attrib[aname]
|
|
if self.javascript:
|
|
if not (self.safe_attrs_only and
|
|
self.safe_attrs == defs.safe_attrs):
|
|
# safe_attrs handles events attributes itself
|
|
for el in doc.iter(etree.Element):
|
|
attrib = el.attrib
|
|
for aname in attrib.keys():
|
|
if aname.startswith('on'):
|
|
del attrib[aname]
|
|
doc.rewrite_links(self._remove_javascript_link,
|
|
resolve_base_href=False)
|
|
# If we're deleting style then we don't have to remove JS links
|
|
# from styles, otherwise...
|
|
if not self.inline_style:
|
|
for el in _find_styled_elements(doc):
|
|
old = el.get('style')
|
|
new = _replace_css_javascript('', old)
|
|
new = _replace_css_import('', new)
|
|
if self._has_sneaky_javascript(new):
|
|
# Something tricky is going on...
|
|
del el.attrib['style']
|
|
elif new != old:
|
|
el.set('style', new)
|
|
if not self.style:
|
|
for el in list(doc.iter('style')):
|
|
if el.get('type', '').lower().strip() == 'text/javascript':
|
|
el.drop_tree()
|
|
continue
|
|
old = el.text or ''
|
|
new = _replace_css_javascript('', old)
|
|
# The imported CSS can do anything; we just can't allow:
|
|
new = _replace_css_import('', new)
|
|
if self._has_sneaky_javascript(new):
|
|
# Something tricky is going on...
|
|
new = '/* deleted */'
|
|
else:
|
|
new = self._remove_sneaky_css_comments(new)
|
|
|
|
if new != old:
|
|
el.text = new
|
|
if self.comments:
|
|
kill_tags.add(etree.Comment)
|
|
if self.processing_instructions:
|
|
kill_tags.add(etree.ProcessingInstruction)
|
|
if self.style:
|
|
kill_tags.add('style')
|
|
if self.inline_style:
|
|
etree.strip_attributes(doc, 'style')
|
|
if self.links:
|
|
kill_tags.add('link')
|
|
elif self.style or self.javascript:
|
|
# We must get rid of included stylesheets if Javascript is not
|
|
# allowed, as you can put Javascript in them
|
|
for el in list(doc.iter('link')):
|
|
if 'stylesheet' in el.get('rel', '').lower():
|
|
# Note this kills alternate stylesheets as well
|
|
if not self.allow_element(el):
|
|
el.drop_tree()
|
|
if self.meta:
|
|
kill_tags.add('meta')
|
|
if self.page_structure:
|
|
remove_tags.update(('head', 'html', 'title'))
|
|
if self.embedded:
|
|
# FIXME: is <layer> really embedded?
|
|
# We should get rid of any <param> tags not inside <applet>;
|
|
# These are not really valid anyway.
|
|
for el in list(doc.iter('param')):
|
|
parent = el.getparent()
|
|
while parent is not None and parent.tag not in ('applet', 'object'):
|
|
parent = parent.getparent()
|
|
if parent is None:
|
|
el.drop_tree()
|
|
kill_tags.update(('applet',))
|
|
# The alternate contents that are in an iframe are a good fallback:
|
|
remove_tags.update(('iframe', 'embed', 'layer', 'object', 'param'))
|
|
if self.frames:
|
|
# FIXME: ideally we should look at the frame links, but
|
|
# generally frames don't mix properly with an HTML
|
|
# fragment anyway.
|
|
kill_tags.update(defs.frame_tags)
|
|
if self.forms:
|
|
remove_tags.add('form')
|
|
kill_tags.update(('button', 'input', 'select', 'textarea'))
|
|
if self.annoying_tags:
|
|
remove_tags.update(('blink', 'marquee'))
|
|
|
|
# Remove <base> tags whenever <head> is being removed.
|
|
# According to HTML spec, <base> must be in <head>, but browsers
|
|
# may interpret it even when misplaced, allowing URL hijacking attacks.
|
|
if 'head' in kill_tags or 'head' in remove_tags:
|
|
kill_tags.add('base')
|
|
|
|
_remove = deque()
|
|
_kill = deque()
|
|
for el in doc.iter():
|
|
if el.tag in kill_tags:
|
|
if self.allow_element(el):
|
|
continue
|
|
_kill.append(el)
|
|
elif el.tag in remove_tags:
|
|
if self.allow_element(el):
|
|
continue
|
|
_remove.append(el)
|
|
|
|
if _remove and _remove[0] == doc:
|
|
# We have to drop the parent-most tag, which we can't
|
|
# do. Instead we'll rewrite it:
|
|
el = _remove.popleft()
|
|
el.tag = 'div'
|
|
el.attrib.clear()
|
|
elif _kill and _kill[0] == doc:
|
|
# We have to drop the parent-most element, which we can't
|
|
# do. Instead we'll clear it:
|
|
el = _kill.popleft()
|
|
if el.tag != 'html':
|
|
el.tag = 'div'
|
|
el.clear()
|
|
|
|
while _kill:
|
|
_kill.popleft().drop_tree() # popleft to start with innermost elements
|
|
|
|
while _remove:
|
|
_remove.pop().drop_tag()
|
|
|
|
if self.remove_unknown_tags:
|
|
if allow_tags:
|
|
raise ValueError(
|
|
"It does not make sense to pass in both allow_tags and remove_unknown_tags")
|
|
allow_tags = set(defs.tags)
|
|
if allow_tags:
|
|
# make sure we do not remove comments/PIs if users want them (which is rare enough)
|
|
if not self.comments:
|
|
allow_tags.add(etree.Comment)
|
|
if not self.processing_instructions:
|
|
allow_tags.add(etree.ProcessingInstruction)
|
|
|
|
bad = []
|
|
for el in doc.iter():
|
|
if el.tag not in allow_tags:
|
|
bad.append(el)
|
|
if bad:
|
|
if bad[0] is doc:
|
|
el = bad.pop(0)
|
|
el.tag = 'div'
|
|
el.attrib.clear()
|
|
for el in bad:
|
|
el.drop_tag()
|
|
if self.add_nofollow:
|
|
for el in _find_external_links(doc):
|
|
if not self.allow_follow(el):
|
|
rel = el.get('rel')
|
|
if rel:
|
|
if ('nofollow' in rel
|
|
and ' nofollow ' in (' %s ' % rel)):
|
|
continue
|
|
rel = '%s nofollow' % rel
|
|
else:
|
|
rel = 'nofollow'
|
|
el.set('rel', rel)
|
|
|
|
def allow_follow(self, anchor):
|
|
"""
|
|
Override to suppress rel="nofollow" on some anchors.
|
|
"""
|
|
return False
|
|
|
|
def allow_element(self, el):
|
|
"""
|
|
Decide whether an element is configured to be accepted or rejected.
|
|
|
|
:param el: an element.
|
|
:return: true to accept the element or false to reject/discard it.
|
|
"""
|
|
if el.tag not in self._tag_link_attrs:
|
|
return False
|
|
attr = self._tag_link_attrs[el.tag]
|
|
if isinstance(attr, (list, tuple)):
|
|
for one_attr in attr:
|
|
url = el.get(one_attr)
|
|
if not url:
|
|
return False
|
|
if not self.allow_embedded_url(el, url):
|
|
return False
|
|
return True
|
|
else:
|
|
url = el.get(attr)
|
|
if not url:
|
|
return False
|
|
return self.allow_embedded_url(el, url)
|
|
|
|
def allow_embedded_url(self, el, url):
|
|
"""
|
|
Decide whether a URL that was found in an element's attributes or text
|
|
if configured to be accepted or rejected.
|
|
|
|
:param el: an element.
|
|
:param url: a URL found on the element.
|
|
:return: true to accept the URL and false to reject it.
|
|
"""
|
|
if self.whitelist_tags is not None and el.tag not in self.whitelist_tags:
|
|
return False
|
|
if not self.host_whitelist:
|
|
return False
|
|
parts = urlsplit(url)
|
|
if parts.scheme not in ('http', 'https'):
|
|
return False
|
|
|
|
authority = _get_authority_from_url(url)
|
|
if (parts.netloc or authority) and parts.netloc != authority:
|
|
warnings.warn(f"It's impossible to parse the hostname from URL: '{url}'! "
|
|
"URL is not allowed because parsers returned ambiguous results.",
|
|
AmbiguousURLWarning)
|
|
return False
|
|
|
|
if parts.hostname in self.host_whitelist:
|
|
return True
|
|
return False
|
|
|
|
def kill_conditional_comments(self, doc):
|
|
"""
|
|
IE conditional comments basically embed HTML that the parser
|
|
doesn't normally see. We can't allow anything like that, so
|
|
we'll kill any comments that could be conditional.
|
|
"""
|
|
has_conditional_comment = _conditional_comment_re.search
|
|
self._kill_elements(
|
|
doc, lambda el: has_conditional_comment(el.text),
|
|
etree.Comment)
|
|
|
|
def _kill_elements(self, doc, condition, iterate=None):
|
|
bad = []
|
|
for el in doc.iter(iterate):
|
|
if condition(el):
|
|
bad.append(el)
|
|
for el in bad:
|
|
el.drop_tree()
|
|
|
|
def _remove_javascript_link(self, link):
|
|
# links like "j a v a s c r i p t:" might be interpreted in IE
|
|
new = _substitute_whitespace('', unquote_plus(link))
|
|
if _has_javascript_scheme(new):
|
|
# FIXME: should this be None to delete?
|
|
return ''
|
|
return link
|
|
|
|
_comments_re = re.compile(r'/\*.*?\*/', re.S)
|
|
_find_comments = _comments_re.finditer
|
|
_substitute_comments = _comments_re.sub
|
|
_css_unicode_escape_re = re.compile(r'\\([0-9a-fA-F]{1,6})\s?')
|
|
|
|
def _decode_css_unicode_escapes(self, style):
|
|
"""
|
|
Decode CSS Unicode escape sequences like \\69 or \\000069 to their
|
|
actual character values. This prevents bypassing security checks
|
|
using CSS escape sequences.
|
|
|
|
CSS escape syntax: backslash followed by 1-6 hex digits,
|
|
optionally followed by a whitespace character.
|
|
"""
|
|
def replace_escape(match):
|
|
hex_value = match.group(1)
|
|
try:
|
|
return chr(int(hex_value, 16))
|
|
except (ValueError, OverflowError):
|
|
# Invalid unicode codepoint, keep original
|
|
return match.group(0)
|
|
|
|
return self._css_unicode_escape_re.sub(replace_escape, style)
|
|
|
|
def _has_sneaky_javascript(self, style):
|
|
"""
|
|
Depending on the browser, stuff like ``e x p r e s s i o n(...)``
|
|
can get interpreted, or ``expre/* stuff */ssion(...)``. This
|
|
checks for attempt to do stuff like this.
|
|
|
|
Typically the response will be to kill the entire style; if you
|
|
have just a bit of Javascript in the style another rule will catch
|
|
that and remove only the Javascript from the style; this catches
|
|
more sneaky attempts.
|
|
"""
|
|
style = self._substitute_comments('', style)
|
|
style = self._decode_css_unicode_escapes(style)
|
|
style = style.replace('\\', '')
|
|
style = _substitute_whitespace('', style)
|
|
style = style.lower()
|
|
if _has_javascript_scheme(style):
|
|
return True
|
|
if 'expression(' in style:
|
|
return True
|
|
if '@import' in style:
|
|
return True
|
|
if '</noscript' in style:
|
|
# e.g. '<noscript><style><a title="</noscript><img src=x onerror=alert(1)>">'
|
|
return True
|
|
if _looks_like_tag_content(style):
|
|
# e.g. '<math><style><img src=x onerror=alert(1)></style></math>'
|
|
return True
|
|
return False
|
|
|
|
def _remove_sneaky_css_comments(self, style):
|
|
"""
|
|
Look for suspicious code in CSS comment and if found,
|
|
remove the entire comment from the given style.
|
|
|
|
Browsers might parse <style> as an ordinary HTML tag
|
|
in some specific context and that might cause code in CSS
|
|
comments to run.
|
|
"""
|
|
for match in self._find_comments(style):
|
|
comment = match.group(0)
|
|
if _has_javascript_scheme(comment) or _looks_like_tag_content(comment):
|
|
style = style.replace(comment, "/* deleted */")
|
|
|
|
return style
|
|
|
|
def clean_html(self, html):
|
|
result_type = type(html)
|
|
if isinstance(html, (str, bytes)):
|
|
doc = fromstring(html)
|
|
else:
|
|
doc = copy.deepcopy(html)
|
|
self(doc)
|
|
return _transform_result(result_type, doc)
|
|
|
|
clean = Cleaner()
|
|
clean_html = clean.clean_html
|
|
|
|
############################################################
|
|
## Autolinking
|
|
############################################################
|
|
|
|
_link_regexes = [
|
|
re.compile(r'(?P<body>https?://(?P<host>[a-z0-9._-]+)(?:/[/\-_.,a-z0-9%&?;=~]*)?(?:\([/\-_.,a-z0-9%&?;=~]*\))?)', re.I),
|
|
# This is conservative, but autolinking can be a bit conservative:
|
|
re.compile(r'mailto:(?P<body>[a-z0-9._-]+@(?P<host>[a-z0-9_.-]+[a-z]))', re.I),
|
|
]
|
|
|
|
_avoid_elements = ['textarea', 'pre', 'code', 'head', 'select', 'a']
|
|
|
|
_avoid_hosts = [
|
|
re.compile(r'^localhost', re.I),
|
|
re.compile(r'\bexample\.(?:com|org|net)$', re.I),
|
|
re.compile(r'^127\.0\.0\.1$'),
|
|
]
|
|
|
|
_avoid_classes = ['nolink']
|
|
|
|
def autolink(el, link_regexes=_link_regexes,
|
|
avoid_elements=_avoid_elements,
|
|
avoid_hosts=_avoid_hosts,
|
|
avoid_classes=_avoid_classes):
|
|
"""
|
|
Turn any URLs into links.
|
|
|
|
It will search for links identified by the given regular
|
|
expressions (by default mailto and http(s) links).
|
|
|
|
It won't link text in an element in avoid_elements, or an element
|
|
with a class in avoid_classes. It won't link to anything with a
|
|
host that matches one of the regular expressions in avoid_hosts
|
|
(default localhost and 127.0.0.1).
|
|
|
|
If you pass in an element, the element's tail will not be
|
|
substituted, only the contents of the element.
|
|
"""
|
|
if el.tag in avoid_elements:
|
|
return
|
|
class_name = el.get('class')
|
|
if class_name:
|
|
class_name = class_name.split()
|
|
for match_class in avoid_classes:
|
|
if match_class in class_name:
|
|
return
|
|
for child in list(el):
|
|
autolink(child, link_regexes=link_regexes,
|
|
avoid_elements=avoid_elements,
|
|
avoid_hosts=avoid_hosts,
|
|
avoid_classes=avoid_classes)
|
|
if child.tail:
|
|
text, tail_children = _link_text(
|
|
child.tail, link_regexes, avoid_hosts, factory=el.makeelement)
|
|
if tail_children:
|
|
child.tail = text
|
|
index = el.index(child)
|
|
el[index+1:index+1] = tail_children
|
|
if el.text:
|
|
text, pre_children = _link_text(
|
|
el.text, link_regexes, avoid_hosts, factory=el.makeelement)
|
|
if pre_children:
|
|
el.text = text
|
|
el[:0] = pre_children
|
|
|
|
def _link_text(text, link_regexes, avoid_hosts, factory):
|
|
leading_text = ''
|
|
links = []
|
|
last_pos = 0
|
|
while 1:
|
|
best_match, best_pos = None, None
|
|
for regex in link_regexes:
|
|
regex_pos = last_pos
|
|
while 1:
|
|
match = regex.search(text, pos=regex_pos)
|
|
if match is None:
|
|
break
|
|
host = match.group('host')
|
|
for host_regex in avoid_hosts:
|
|
if host_regex.search(host):
|
|
regex_pos = match.end()
|
|
break
|
|
else:
|
|
break
|
|
if match is None:
|
|
continue
|
|
if best_pos is None or match.start() < best_pos:
|
|
best_match = match
|
|
best_pos = match.start()
|
|
if best_match is None:
|
|
# No more matches
|
|
if links:
|
|
assert not links[-1].tail
|
|
links[-1].tail = text
|
|
else:
|
|
assert not leading_text
|
|
leading_text = text
|
|
break
|
|
link = best_match.group(0)
|
|
end = best_match.end()
|
|
if link.endswith('.') or link.endswith(','):
|
|
# These punctuation marks shouldn't end a link
|
|
end -= 1
|
|
link = link[:-1]
|
|
prev_text = text[:best_match.start()]
|
|
if links:
|
|
assert not links[-1].tail
|
|
links[-1].tail = prev_text
|
|
else:
|
|
assert not leading_text
|
|
leading_text = prev_text
|
|
anchor = factory('a')
|
|
anchor.set('href', link)
|
|
body = best_match.group('body')
|
|
if not body:
|
|
body = link
|
|
if body.endswith('.') or body.endswith(','):
|
|
body = body[:-1]
|
|
anchor.text = body
|
|
links.append(anchor)
|
|
text = text[end:]
|
|
return leading_text, links
|
|
|
|
def autolink_html(html, *args, **kw):
|
|
result_type = type(html)
|
|
if isinstance(html, (str, bytes)):
|
|
doc = fromstring(html)
|
|
else:
|
|
doc = copy.deepcopy(html)
|
|
autolink(doc, *args, **kw)
|
|
return _transform_result(result_type, doc)
|
|
|
|
autolink_html.__doc__ = autolink.__doc__
|
|
|
|
############################################################
|
|
## Word wrapping
|
|
############################################################
|
|
|
|
_avoid_word_break_elements = ['pre', 'textarea', 'code']
|
|
_avoid_word_break_classes = ['nobreak']
|
|
|
|
def word_break(el, max_width=40,
|
|
avoid_elements=_avoid_word_break_elements,
|
|
avoid_classes=_avoid_word_break_classes,
|
|
break_character=chr(0x200b)):
|
|
"""
|
|
Breaks any long words found in the body of the text (not attributes).
|
|
|
|
Doesn't effect any of the tags in avoid_elements, by default
|
|
``<textarea>`` and ``<pre>``
|
|
|
|
Breaks words by inserting ​, which is a unicode character
|
|
for Zero Width Space character. This generally takes up no space
|
|
in rendering, but does copy as a space, and in monospace contexts
|
|
usually takes up space.
|
|
|
|
See http://www.cs.tut.fi/~jkorpela/html/nobr.html for a discussion
|
|
"""
|
|
# Character suggestion of ​ comes from:
|
|
# http://www.cs.tut.fi/~jkorpela/html/nobr.html
|
|
if el.tag in _avoid_word_break_elements:
|
|
return
|
|
class_name = el.get('class')
|
|
if class_name:
|
|
dont_break = False
|
|
class_name = class_name.split()
|
|
for avoid in avoid_classes:
|
|
if avoid in class_name:
|
|
dont_break = True
|
|
break
|
|
if dont_break:
|
|
return
|
|
if el.text:
|
|
el.text = _break_text(el.text, max_width, break_character)
|
|
for child in el:
|
|
word_break(child, max_width=max_width,
|
|
avoid_elements=avoid_elements,
|
|
avoid_classes=avoid_classes,
|
|
break_character=break_character)
|
|
if child.tail:
|
|
child.tail = _break_text(child.tail, max_width, break_character)
|
|
|
|
def word_break_html(html, *args, **kw):
|
|
result_type = type(html)
|
|
doc = fromstring(html)
|
|
word_break(doc, *args, **kw)
|
|
return _transform_result(result_type, doc)
|
|
|
|
def _break_text(text, max_width, break_character):
|
|
words = text.split()
|
|
for word in words:
|
|
if len(word) > max_width:
|
|
replacement = _insert_break(word, max_width, break_character)
|
|
text = text.replace(word, replacement)
|
|
return text
|
|
|
|
_break_prefer_re = re.compile(r'[^a-z]', re.I)
|
|
|
|
def _insert_break(word, width, break_character):
|
|
orig_word = word
|
|
result = ''
|
|
while len(word) > width:
|
|
start = word[:width]
|
|
breaks = list(_break_prefer_re.finditer(start))
|
|
if breaks:
|
|
last_break = breaks[-1]
|
|
# Only walk back up to 10 characters to find a nice break:
|
|
if last_break.end() > width-10:
|
|
# FIXME: should the break character be at the end of the
|
|
# chunk, or the beginning of the next chunk?
|
|
start = word[:last_break.end()]
|
|
result += start + break_character
|
|
word = word[len(start):]
|
|
result += word
|
|
return result
|
|
|