| """Scribus as an agentenv computer app, exported by REA from a desktop application capture. |
| |
| Package: scribus (captured at 1.6.1-0ubuntu7). Capture Evidence: ev_d819eeeffe6b96576a6e675911321db97fd7c68c3aa2179bda8e17c4cc347ecb. |
| The seed was made for the task, as saved at checkpoint seed. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import contextlib |
| import copy |
| import hashlib |
| import io |
| import json |
| import math |
| import os |
| import re |
| import sqlite3 |
| import struct |
| import subprocess |
| import sys |
| import tempfile |
| import zipfile |
| import zlib |
| from pathlib import Path |
| from xml.parsers import expat |
|
|
| from agentenv_protocol import add_data, get_data, reset_data |
| from agentenv_protocol.computer import AptSource, ComputerAppEnvironment, Download, Launch, Packages, Ready, RunScript, computer_app, linux, ready_check |
| from agentenv_protocol.computer.app_data import INITIAL, add, get, in_thread, keep_initial, reset |
| from agentenv_protocol.types import DataPart |
|
|
| HERE = Path(__file__).resolve().parent |
| SEED_HOME = "/home/user" |
| PATHS = [".config/scribus", "Documents"] |
| DCONF = "" |
| TEXT_SEEDS = frozenset([".config/scribus/checkfonts150.xml", "Documents/jazz-night-flyer.sla"]) |
| WINDOW_CLASS = "scribus" |
|
|
| XML_SUFFIXES = (".xml", ".xbel", ".plist", ".svg", ".ui") |
| GROUP_HEADER = re.compile(r"^\[([^\]]+)\]$") |
| LINE_BREAK = re.compile(r"\r?\n") |
| SQLITE_HEADER = b"SQLite format 3\x00" |
| GVDB_HEADER = b"GVariant" |
| ZIP_HEADER = b"PK\x03\x04" |
| XML_SPACE = "xml:space" |
| MAX_VIEW_BYTES = 64 * 1024 * 1024 |
| MAX_SAFE_INTEGER = 2**53 - 1 |
| MAX_TABLES = 64 |
| MAX_ROWS = 500 |
| MAX_LINES = 5000 |
| MAX_XML_NODES = 5000 |
| MAX_XML_DEPTH = 64 |
| SQLITE_BUSY_S = 0.25 |
| MAX_PARSED_BYTES = 4 * 1024 * 1024 |
| MAX_JSON_VIEW_DEPTH = 500 |
| JSON_TOO_DEEP = f"nested deeper than the {MAX_JSON_VIEW_DEPTH} levels a JSON view keeps" |
|
|
|
|
| def _respelled(text: str, home: Path) -> str: |
| """The seed's home path respelled to this computer's home, only where a whole path segment ends after it.""" |
| return re.sub(re.escape(SEED_HOME) + r"(?![\w.@+~-])", lambda _: str(home), text) |
|
|
|
|
| def _respelled_utf16(data: bytes, home: Path) -> bytes: |
| """A UTF-16 text file with a byte-order mark respelled like a text seed, its mark kept; any other bytes as given.""" |
| for mark, codec in ((b"\xff\xfe", "utf-16-le"), (b"\xfe\xff", "utf-16-be")): |
| if data.startswith(mark): |
| try: |
| text = data[len(mark):].decode(codec) |
| except UnicodeDecodeError: |
| return data |
| return mark + _respelled(text, home).encode(codec) if SEED_HOME in text else data |
| return data |
|
|
|
|
| |
| SPLASH_MARKS = ("_NET_WM_STATE_SKIP_TASKBAR", "_NET_WM_WINDOW_TYPE_SPLASH") |
|
|
|
|
| def _taskbar_window(window_class: str) -> bool: |
| """Whether a top-level window of the given class that the taskbar lists is shown; a splash screen or a dialog |
| skips the taskbar.""" |
| def xprop(*args: str) -> str: |
| done = subprocess.run(["xprop", *args], capture_output=True, text=True) |
| return done.stdout if done.returncode == 0 else "" |
|
|
| for window in re.findall(r"0x[0-9a-f]+", xprop("-root", "_NET_CLIENT_LIST").partition("#")[2]): |
| props = xprop("-id", window, "WM_CLASS", "_NET_WM_STATE", "_NET_WM_WINDOW_TYPE") |
| classes = re.findall(r'"((?:[^"\\]|\\.)*)"', props.partition("WM_CLASS")[2].split("\n", 1)[0]) |
| if window_class in classes and not any(mark in props for mark in SPLASH_MARKS): |
| return True |
| return False |
|
|
|
|
| def _seed_home(home: Path) -> None: |
| """Copy the captured files into this computer's home; text files, UTF-16 ones too, have the seed's home path |
| respelled.""" |
| seed = HERE / "seed" |
| for source in sorted(seed.rglob("*")) if seed.is_dir() else []: |
| if not source.is_file(): |
| continue |
| relative = source.relative_to(seed).as_posix() |
| target = home / relative |
| target.parent.mkdir(parents=True, exist_ok=True) |
| data = source.read_bytes() |
| if relative in TEXT_SEEDS: |
| data = _respelled(data.decode("utf-8"), home).encode("utf-8") |
| else: |
| data = _respelled_utf16(data, home) |
| target.write_bytes(data) |
|
|
|
|
| def _dconf(arguments: list, environment: dict) -> str: |
| return subprocess.run(["dconf", *arguments], env={**os.environ, **environment}, capture_output=True, text=True, |
| check=True).stdout |
|
|
|
|
| def _load_dconf(home: Path) -> None: |
| """Compile the captured dconf keys into the user database without D-Bus, which is not up yet. Keys already there |
| stay unless captured: dconf compile reads the key files in name order and a later file wins. A failure is |
| reported and the app starts without them.""" |
| if not DCONF: |
| return |
| database = home / ".config" / "dconf" / "user" |
| try: |
| database.parent.mkdir(parents=True, exist_ok=True) |
| with tempfile.TemporaryDirectory(dir=database.parent) as scratch: |
| keyfiles = Path(scratch, "keyfiles") |
| keyfiles.mkdir() |
| if database.is_file(): |
| profile = Path(scratch, "profile") |
| profile.write_text(f"file-db:{database}\n") |
| existing = _dconf(["dump", "/"], {"DCONF_PROFILE": str(profile)}) |
| (keyfiles / "00-existing").write_text(existing) |
| (keyfiles / "01-captured").write_text(_respelled(DCONF, home)) |
| _dconf(["compile", str(Path(scratch, "user")), str(keyfiles)], {}) |
| os.replace(Path(scratch, "user"), database) |
| except (OSError, subprocess.CalledProcessError) as error: |
| detail = (getattr(error, "stderr", None) or "").strip().splitlines() |
| print(f"warning: the captured dconf settings were not loaded: {detail[-1] if detail else error}", |
| file=sys.stderr) |
|
|
|
|
| def _sqlite_text(data: bytes): |
| text = data.decode("utf-8", "replace") |
| return {"text": text, "bytes_hex": data.hex()} if "�" in text else text |
|
|
|
|
| def _cell(value): |
| if isinstance(value, bytes): |
| return {"blob_hex": value.hex()} |
| if isinstance(value, int) and abs(value) > MAX_SAFE_INTEGER: |
| return {"integer": str(value)} |
| |
| if isinstance(value, float) and (math.isinf(value) or (value == 0 and math.copysign(1, value) < 0)): |
| return "Infinity" if value == math.inf else "-Infinity" if value == -math.inf else "-0" |
| return value |
|
|
|
|
| def _table(db, name: str, primary_key: list) -> dict: |
| quoted = '"' + name.replace('"', '""') + '"' |
| cursor = db.execute(f"select * from main.{quoted} not indexed limit {MAX_ROWS + 1}") |
| rows = [[_cell(value) for value in row] for row in cursor] |
| return {"columns": [column[0] for column in cursor.description], "primary_key": primary_key, |
| "rows": rows[:MAX_ROWS], "truncated": len(rows) > MAX_ROWS} |
|
|
|
|
| def _sqlite(path: Path) -> dict: |
| """The database's ordinary tables, in schema order, up to REA's table and row limits.""" |
| with contextlib.closing(sqlite3.connect(path.resolve().as_uri() + "?mode=ro", uri=True, timeout=SQLITE_BUSY_S)) as db: |
| kinds = dict(db.execute("select name, type from pragma_table_list where schema = 'main'")) |
| names = [name for (name,) in db.execute("select name from sqlite_schema where type = 'table'") |
| if kinds.get(name) == "table"] |
| keys = {name: [key for (key,) in db.execute( |
| "select name from pragma_table_info(?, 'main') where pk > 0 order by pk", (name,))] |
| for name in names[:MAX_TABLES]} |
| db.text_factory = _sqlite_text |
| tables = {name: _table(db, name, keys[name]) for name in names[:MAX_TABLES]} |
| cut = len(names) > MAX_TABLES |
| return {"format": "sqlite", "view": {"tables": tables, "tables_truncated": cut}, |
| "truncated": cut or any(table["truncated"] for table in tables.values())} |
|
|
|
|
| def _text(text: str) -> dict: |
| lines = LINE_BREAK.split(text) |
| if lines[-1] == "": |
| lines.pop() |
| view = {"lines": lines[:MAX_LINES], "line_count": len(lines), "truncated": len(lines) > MAX_LINES} |
| return {"format": "text", "view": view, "truncated": view["truncated"]} |
|
|
|
|
| def _keyfile_line(raw: str) -> tuple: |
| """A key file line as REA reads it: skip (blank or comment), group, entry or other.""" |
| line = raw.strip() |
| if not line or line[0] in "#;": |
| return ("skip",) |
| header = GROUP_HEADER.match(line) |
| if header: |
| return ("group", header.group(1)) |
| key, equals, value = line.partition("=") |
| return ("entry", key.strip(), value.strip()) if equals and key else ("other",) |
|
|
|
|
| def _is_keyfile(text: str) -> bool: |
| """REA's rule: at least one group, and nothing a key file view would drop.""" |
| kinds = {_keyfile_line(line)[0] for line in LINE_BREAK.split(text)} |
| return "group" in kinds and "other" not in kinds |
|
|
|
|
| def _keyfile(text: str) -> dict: |
| groups, group = {}, "" |
| for line in map(_keyfile_line, LINE_BREAK.split(text)): |
| if line[0] == "group": |
| group = line[1] |
| groups.setdefault(group, {}) |
| elif line[0] == "entry": |
| groups.setdefault(group, {})[line[1]] = line[2] |
| return groups |
|
|
|
|
| |
| XML_WHITESPACE = " \t\r\n" |
| PREDEFINED_ENTITIES = ("amp", "lt", "gt", "apos", "quot") |
| ENTITY_REFERENCE = re.compile(r"&([^#;][^;]*);") |
|
|
|
|
| def _expat(namespaces: bool, doctype=None): |
| """An expat parser that reads a DOCTYPE as REA does: one with an internal subset, which could declare entities, |
| is refused, the DTD it names is never read, and a reference to an entity other than XML's five is refused where |
| expat would skip it. With namespaces it also enforces their rules, as REA's parser does, and without them it |
| reports names as the document spells them. doctype, when given, receives the declared name and identifiers.""" |
| parser = expat.ParserCreate(namespace_separator=" " if namespaces else None) |
| parser.SetParamEntityParsing(expat.XML_PARAM_ENTITY_PARSING_NEVER) |
|
|
| def declared(name: str, system_id, public_id, internal_subset: bool) -> None: |
| if internal_subset: |
| raise ValueError("the document's DOCTYPE has an internal subset") |
| if doctype is not None: |
| doctype({"name": name, "public_id": public_id, "system_id": system_id}) |
|
|
| def undeclared(name: str, _parameter: bool) -> None: |
| raise ValueError(f"the document refers to the undeclared entity {name}") |
|
|
| def external(*_) -> None: |
| raise ValueError("the document refers to an external entity") |
|
|
| parser.StartDoctypeDeclHandler = declared |
| parser.SkippedEntityHandler = undeclared |
| parser.ExternalEntityRefHandler = external |
| return parser |
|
|
|
|
| def _check_tag(markup: str) -> None: |
| """expat leaves an undeclared entity out of an attribute value without a word when a DOCTYPE names a DTD; REA's |
| parser refuses it. With text taken by its own handler, a start tag is the only markup expat passes here that |
| starts with < and a name, and it passes it whole.""" |
| if markup[:1] == "<" and markup[1:2] not in ("!", "?", "/"): |
| for name in ENTITY_REFERENCE.findall(markup): |
| if name not in PREDEFINED_ENTITIES: |
| raise ValueError(f"the document refers to the undeclared entity {name}") |
|
|
|
|
| def _ignore_text(_text: str) -> None: |
| pass |
|
|
|
|
| class _XmlReader: |
| """REA's XML view built as expat reads: names as spelled, declarations as attributes, text split where REA's DOM |
| splits it (an empty CDATA section joins the text around it), and each node counted against REA's limits.""" |
|
|
| def __init__(self) -> None: |
| self.remaining, self.truncated, self.root, self.doctype = MAX_XML_NODES, False, None, None |
| |
| |
| |
| self.open = [] |
| self.text, self.cdata = [], None |
|
|
| def read(self, text: str) -> None: |
| parser = _expat(False, self._doctype) |
| parser.buffer_text = True |
| parser.StartElementHandler, parser.EndElementHandler = self._start, self._end |
| parser.CharacterDataHandler = self._data |
| parser.StartCdataSectionHandler, parser.EndCdataSectionHandler = self._cdata_start, self._cdata_end |
| parser.CommentHandler = parser.ProcessingInstructionHandler = self._other |
| parser.Parse(text, True) |
|
|
| def _doctype(self, declared: dict) -> None: |
| self.doctype = declared |
|
|
| def _admit(self) -> bool: |
| """Whether the next node inside a kept element is kept, within the node and depth limits; one past them |
| marks the view truncated.""" |
| if self.open and self.open[-1][0] is None: |
| return False |
| if self.remaining <= 0 or len(self.open) > MAX_XML_DEPTH: |
| self.truncated = True |
| return False |
| self.remaining -= 1 |
| return True |
|
|
| def _text_node(self, text: str) -> None: |
| if self.open and text.strip(XML_WHITESPACE): |
| self.open[-1][3] = True |
| if self._admit(): |
| self.open[-1][0]["children"].append(text) |
|
|
| def _flush(self) -> None: |
| if self.text: |
| text, self.text = "".join(self.text), [] |
| self._text_node(text) |
|
|
| def _data(self, text: str) -> None: |
| (self.text if self.cdata is None else self.cdata).append(text) |
|
|
| def _cdata_start(self) -> None: |
| self.cdata = [] |
|
|
| def _cdata_end(self) -> None: |
| text, self.cdata = "".join(self.cdata), None |
| if text: |
| self._flush() |
| self._text_node(text) |
|
|
| def _other(self, *_) -> None: |
| """A comment or processing instruction, counted like any node and never kept.""" |
| self._flush() |
| if self.open: |
| self._admit() |
|
|
| def _start(self, name: str, attributes: dict) -> None: |
| self._flush() |
| parent = self.open[-1] if self.open else [None, False, False, False] |
| parent[2] = True |
| view = {"name": name, "attributes": attributes, "children": []} if self._admit() else None |
| if view is not None and parent[0] is not None: |
| parent[0]["children"].append(view) |
| space = attributes.get(XML_SPACE) |
| self.open.append([view, space == "preserve" if space else parent[1], False, False]) |
|
|
| def _end(self, _name: str) -> None: |
| self._flush() |
| view, preserve, holds_element, holds_text = self.open.pop() |
| if view is not None and holds_element and not holds_text and not preserve: |
| view["children"] = [child for child in view["children"] |
| if not isinstance(child, str) or child.strip(XML_WHITESPACE)] |
| if not self.open: |
| self.root = view |
|
|
|
|
| def _xml_view(text: str): |
| """REA's XML view, or None for a document REA's parser refuses: a pass with namespaces checks the document as REA's |
| parser does, then a pass without them reads names as spelled, as REA's view keeps them, and the DOCTYPE.""" |
| reader = _XmlReader() |
| try: |
| check = _expat(True) |
| check.CharacterDataHandler, check.DefaultHandler = _ignore_text, _check_tag |
| check.Parse(text, True) |
| reader.read(text) |
| except (expat.ExpatError, ValueError): |
| return None |
| view = {"root": reader.root, "truncated": reader.truncated} |
| return view if reader.doctype is None else {"doctype": reader.doctype, **view} |
|
|
|
|
| def _not_json(constant: str): |
| raise ValueError(f"{constant} is not JSON") |
|
|
|
|
| class _Inexact(Exception): |
| """A JSON number that REA's state view refuses, since reading it would change it.""" |
|
|
|
|
| def _digits(text: str) -> str: |
| return re.split(r"[eE]", text.lstrip("-"))[0].replace(".", "").strip("0") or "0" |
|
|
|
|
| def _js_string(value: float) -> str: |
| """How JavaScript's String() writes a finite double: an integer below 1e21 in full, any other in shortest form.""" |
| return str(int(value)) if value.is_integer() and abs(value) < 1e21 else repr(value) |
|
|
|
|
| def _safe_number(text: str) -> bool: |
| """lossless-json's isSafeNumber: an integer spelling within 2^53, or a float spelling that keeps its digits.""" |
| if re.fullmatch(r"-?[0-9]+", text): |
| return len(text.lstrip("-")) <= 16 and abs(int(text)) <= MAX_SAFE_INTEGER |
| value = float(text) |
| if not math.isfinite(value): |
| return False |
| written = _js_string(value) |
| return written == text or _digits(written) == _digits(text) |
|
|
|
|
| def _exact_number(text: str): |
| """A JSON number read only when reading it changes nothing, as REA's state view rules: its spelling and its |
| written-back form both safe, and not -0.""" |
| value = float(text) |
| if (not _safe_number(text) or not math.isfinite(value) or not _safe_number(_js_string(value)) |
| or (value == 0 and math.copysign(1, value) < 0)): |
| raise _Inexact(text) |
| return int(text) if re.fullmatch(r"-?[0-9]+", text) else value |
|
|
|
|
| _INEXACT = object() |
| _LEVEL_END = object() |
|
|
|
|
| def _number_or_mark(spelling: str): |
| """A JSON number read exactly, or a mark for one REA's state view refuses.""" |
| try: |
| return _exact_number(spelling) |
| except _Inexact: |
| return _INEXACT |
|
|
|
|
| def _holds_inexact(value) -> bool: |
| """Whether a parsed JSON value still holds a marked number once duplicate keys kept their last value; one |
| iterator per nesting level, so no child list is copied.""" |
| levels = [iter((value,))] |
| while levels: |
| item = next(levels[-1], _LEVEL_END) |
| if item is _LEVEL_END: |
| levels.pop() |
| elif item is _INEXACT: |
| return True |
| elif isinstance(item, dict): |
| levels.append(iter(item.values())) |
| elif isinstance(item, list): |
| levels.append(iter(item)) |
| return False |
|
|
|
|
| def _deeper_than(root, limit: int) -> bool: |
| """Whether a parsed JSON value nests deeper than a limit, as REA checks it: a value's depth is the number of |
| iterators open above it, one per nesting level, so no child list is copied.""" |
| levels = [iter((root,))] |
| while levels: |
| item = next(levels[-1], _LEVEL_END) |
| if item is _LEVEL_END: |
| levels.pop() |
| elif len(levels) - 1 > limit: |
| return True |
| elif isinstance(item, dict): |
| levels.append(iter(item.values())) |
| elif isinstance(item, list): |
| levels.append(iter(item)) |
| return False |
|
|
|
|
| def _text_view(name: str, text: str) -> dict: |
| """The format REA's state view detects for decoded text, and its view.""" |
| trimmed = re.sub(r"^[\s]+", "", text) |
| if name.endswith(".json") or trimmed[:1] in ("[", "{"): |
| |
| try: |
| view = json.loads(text, parse_constant=_not_json, parse_float=_number_or_mark, parse_int=_number_or_mark) |
| except RecursionError: |
| |
| return {"format": "json", "view": None, "error": JSON_TOO_DEEP} |
| except ValueError: |
| pass |
| else: |
| if _holds_inexact(view): |
| return {"format": "json", "view": None, |
| "error": "a number in it cannot be read exactly, such as an integer above 2^53"} |
| if _deeper_than(view, MAX_JSON_VIEW_DEPTH): |
| return {"format": "json", "view": None, "error": JSON_TOO_DEEP} |
| return {"format": "json", "view": view, "truncated": False} |
| lowered = name.lower() |
| if lowered.endswith(XML_SUFFIXES) or trimmed.startswith("<?xml"): |
| view = _xml_view(text) |
| return _text(text) if view is None else {"format": "xml", "view": view, "truncated": view["truncated"]} |
| if _is_keyfile(text): |
| return {"format": "keyfile", "view": {"groups": _keyfile(text)}, "truncated": False} |
| return _text(text) |
|
|
|
|
| def _view(path: Path) -> dict: |
| """A typed JSON view of one file in the shapes of REA's state view; truncated says the view is partial.""" |
| too_large = {"format": None, "view": None, "error": "larger than 64 MiB, the most the view reads"} |
| if path.stat().st_size > MAX_VIEW_BYTES: |
| return too_large |
| with path.open("rb") as file: |
| data = file.read(8192) |
| whole = not data.startswith(SQLITE_HEADER) and b"\x00" not in data |
| data += file.read(MAX_VIEW_BYTES + 1 - len(data)) if whole else b"" |
| if data.startswith(SQLITE_HEADER): |
| return _sqlite(path) |
| if data.startswith(ZIP_HEADER): |
| return _zip(path) |
| if len(data) > MAX_VIEW_BYTES: |
| return too_large |
| try: |
| text = data.decode("utf-8-sig") if whole else None |
| except UnicodeDecodeError: |
| text = None |
| return {"format": "binary", "view": None, "truncated": False} if text is None else _text_view(path.name, text) |
|
|
|
|
| def _views(home: Path, paths: list) -> dict: |
| """A view of every file under the app's paths, keyed by its home-relative path.""" |
| files = {} |
| for owned in paths: |
| root = home / owned |
| candidates = [root] if root.is_file() else sorted(root.rglob("*")) if root.is_dir() else [] |
| for path in candidates: |
| if path.is_file() and not path.is_symlink(): |
| key = path.relative_to(home).as_posix() |
| try: |
| files[key] = _view(path) |
| except (OSError, ValueError, sqlite3.Error, RecursionError) as error: |
| files[key] = {"format": None, "view": None, "error": str(error)} |
| return files |
|
|
| MAX_ZIP_ENTRIES = 1000 |
| MAX_ZIP_ENTRY_BYTES = 16 * 1024 * 1024 |
| MAX_ZIP_BYTES = 64 * 1024 * 1024 |
| MAX_ZIP_RATIO = 100 |
| ZIP_READ_CHUNK = 64 * 1024 |
| ZIP_END = b"PK\x05\x06" |
| ZIP_CENTRAL = b"PK\x01\x02" |
| ZIP64_LOCATOR = b"PK\x06\x07" |
| ZIP64_END = b"PK\x06\x06" |
| |
| NOT_READ_INSIDE = ((SQLITE_HEADER, "sqlite", "a SQLite database"), (GVDB_HEADER, "dconf", "a dconf database"), |
| (ZIP_HEADER, "zip", "an archive")) |
|
|
|
|
| def _entry_view(name: str, data: bytes) -> dict: |
| """An archive entry's format and view by the rules a file's follow; a database or an archive inside is not |
| read.""" |
| for header, form, inside in NOT_READ_INSIDE: |
| if data.startswith(header): |
| return {"format": form, "view": None, "error": f"{inside} inside an archive is not read"} |
| try: |
| text = data.decode("utf-8-sig") if b"\x00" not in data[:8192] else None |
| except UnicodeDecodeError: |
| text = None |
| if text is None: |
| return {"format": "binary", "view": None} |
| view = _text_view(name, text) |
| if view["format"] in ("json", "keyfile") and len(data) > MAX_PARSED_BYTES: |
| return {"format": view["format"], "view": None, |
| "error": "larger than the 4 MiB limit for JSON and key file views"} |
| return view |
|
|
|
|
| def _zip_refusal(info, spent: int): |
| """Why an entry is not read, checked in REA's order, or None; spent is the archive's bytes read so far.""" |
| if info.flag_bits & 0x1: |
| return "encrypted, so it is not read" |
| if info.compress_type not in (zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED): |
| return f"compressed with method {info.compress_type}, which the view does not read" |
| if info.file_size > MAX_ZIP_ENTRY_BYTES: |
| return "larger than the 16 MiB an entry's view reads" |
| if info.file_size > MAX_ZIP_RATIO * info.compress_size: |
| return f"expands more than {MAX_ZIP_RATIO} times, so it is not read" |
| if spent + info.file_size > MAX_ZIP_BYTES: |
| return "past the 64 MiB read from one archive" |
| return None |
|
|
|
|
| def _entry_bytes(archive, info): |
| """An entry's uncompressed bytes, or None when they fail its CRC-32 or are not exactly its declared size. Reading |
| stops one byte past that size, which data past a short declared size fills, and asks for a bounded chunk at a |
| time, which bounds what the decompressor expands per call, so a forged small size holds no more than that.""" |
| probe = copy.copy(info) |
| probe.file_size = info.file_size + 1 |
| data = bytearray() |
| try: |
| with archive.open(probe) as member: |
| while len(data) <= info.file_size: |
| chunk = member.read(min(probe.file_size - len(data), ZIP_READ_CHUNK)) |
| if not chunk: |
| break |
| data += chunk |
| except (zipfile.BadZipFile, zlib.error, EOFError, OSError, ValueError): |
| return None |
| return data if len(data) == info.file_size else None |
|
|
|
|
| def _zip_entry(archive, info, refusal): |
| """One entry of a zip view: its name, size and digest, and its own format and view, or why it was not read.""" |
| entry = {"name": info.filename, "size": info.file_size, "sha256": None, "format": None, "view": None, |
| "view_error": refusal} |
| if refusal is not None: |
| return entry |
| data = _entry_bytes(archive, info) |
| if data is None: |
| return {**entry, "view_error": "its compressed data is damaged"} |
| view = _entry_view(info.filename, data) |
| return {**entry, "sha256": hashlib.sha256(data).hexdigest(), "format": view["format"], |
| "view": view.get("view"), "view_error": view.get("error")} |
|
|
|
|
| def _zip_end(file, size: int): |
| """Where an archive's central directory ends, how long it is and the offset it declares, from the last end |
| record whose comment reaches the end of the file and, when a Zip64 locator precedes it whatever that record |
| holds, the Zip64 one just before the locator; None without an end record, or when sentinels defer to a |
| Zip64 record that is missing.""" |
| window = min(size, 22 + 0xFFFF) |
| file.seek(size - window) |
| tail = file.read(window) |
| at = tail.rfind(ZIP_END, 0, len(tail) - 18) |
| while at >= 0 and at + 22 + int.from_bytes(tail[at + 20:at + 22], "little") != len(tail): |
| at = tail.rfind(ZIP_END, 0, at + 3) |
| if at < 0: |
| return None |
| total, length, offset = struct.unpack_from("<HII", tail, at + 10) |
| end = size - window + at |
| record = end - 20 - 56 |
| if record < 0: |
| return end, length, offset |
| file.seek(end - 20) |
| if file.read(4) != ZIP64_LOCATOR: |
| return end, length, offset |
| file.seek(record) |
| zip64 = file.read(56) |
| if len(zip64) == 56 and zip64[:4] == ZIP64_END: |
| length, offset = struct.unpack_from("<QQ", zip64, 40) |
| return record, length, offset |
| if total == 0xFFFF or 0xFFFFFFFF in (length, offset): |
| return None |
| return end, length, offset |
|
|
|
|
| def _zip_unicode_path(raw: bytes, flags: int, extra: bytes): |
| """An Info-ZIP Unicode Path when zip.js uses it: version 1, no UTF-8 flag, and the CRC-32 of the stored name.""" |
| at = 0 |
| while at + 4 <= len(extra): |
| kind, length = struct.unpack_from("<HH", extra, at) |
| if kind == 0x7075: |
| data = extra[at + 4:at + 4 + length] |
| usable = (length >= 5 and len(data) == length and data[0] == 1 and not flags & 0x800 |
| and int.from_bytes(data[1:5], "little") == zlib.crc32(raw)) |
| return data[5:] if usable else None |
| at += 4 + length |
| return None |
|
|
|
|
| def _zip_ends_in_slash(raw: bytes, flags: int, extra: bytes): |
| """Whether an entry's name, as REA decodes it, ends in a slash; None when it must be UTF-8 and is not.""" |
| utf8 = _zip_unicode_path(raw, flags, extra) |
| if utf8 is None and flags & 0x800: |
| utf8 = raw |
| if utf8 is None: |
| return raw.endswith(b"/") |
| try: |
| return utf8.decode("utf-8").endswith("/") |
| except UnicodeDecodeError: |
| return None |
|
|
|
|
| def _zip_directory(file, size: int, keep: int): |
| """An archive's central directory read a record at a time, keeping the first file entries' records, as many as keep allows, and |
| counting the rest, as REA reads it: (start, declared offset, records, count), or None when it cannot be read. |
| Directories are told apart as zip.js tells them: a final slash, a Unix directory mode, or the MS-DOS attribute.""" |
| located = _zip_end(file, size) |
| if located is None: |
| return None |
| end, length, declared = located |
| start = end - length |
| if start < 0: |
| return None |
| file.seek(start) |
| records, count, at = [], 0, start |
| while at < end: |
| fixed = file.read(46) |
| if at + 46 > end or len(fixed) < 46 or fixed[:4] != ZIP_CENTRAL: |
| return None |
| made_by, flags = struct.unpack_from("<H2xH", fixed, 4) |
| name_length, extra_length, comment_length = struct.unpack_from("<HHH", fixed, 28) |
| external = struct.unpack_from("<I", fixed, 38)[0] |
| rest = file.read(name_length + extra_length + comment_length) |
| at += 46 + name_length + extra_length + comment_length |
| if len(rest) < name_length + extra_length + comment_length or at > end: |
| return None |
| slash = _zip_ends_in_slash(rest[:name_length], flags, rest[name_length:name_length + extra_length]) |
| if slash is None: |
| return None |
| if not (slash or (external >> 16) & 0o170000 == 0o040000 or (made_by >> 8 == 0 and external & 0x10)): |
| count += 1 |
| if len(records) < keep: |
| records.append(fixed + rest) |
| return start, declared, records, count |
|
|
|
|
| class _BoundedArchive(io.RawIOBase): |
| """An archive as zipfile reads it: its entries in place, then a directory of the kept records alone and end |
| records for them, so zipfile parses no more records than the view lists.""" |
|
|
| def __init__(self, file, start: int, tail: bytes) -> None: |
| super().__init__() |
| self._file, self._start, self._tail, self._at = file, start, tail, 0 |
|
|
| def readable(self) -> bool: |
| return True |
|
|
| def seekable(self) -> bool: |
| return True |
|
|
| def tell(self) -> int: |
| return self._at |
|
|
| def seek(self, offset: int, whence: int = 0) -> int: |
| self._at = offset + (0, self._at, self._start + len(self._tail))[whence] |
| return self._at |
|
|
| def readinto(self, buffer) -> int: |
| view = memoryview(buffer) |
| if self._at < self._start: |
| self._file.seek(self._at) |
| count = self._file.readinto(view[:self._start - self._at]) |
| else: |
| chunk = self._tail[self._at - self._start:self._at - self._start + len(view)] |
| count = len(chunk) |
| view[:count] = chunk |
| self._at += count |
| return count |
|
|
|
|
| def _zip(path: Path) -> dict: |
| """A zip archive's file entries in archive order, up to REA's entry, size, ratio and archive limits; nothing is |
| extracted to disk, no archive inside is opened, and zipfile is shown only the directory records listed.""" |
| entries, spent = [], 0 |
| try: |
| with path.open("rb") as file: |
| directory = _zip_directory(file, os.fstat(file.fileno()).st_size, MAX_ZIP_ENTRIES) |
| if directory is None: |
| raise zipfile.BadZipFile("no readable central directory") |
| start, declared, records, count = directory |
| kept = b"".join(records) |
| offset = declared if declared <= 0xFFFFFFFF else start |
| |
| |
| tail = (kept |
| + struct.pack("<4sQ2H2I4Q", ZIP64_END, 44, 45, 45, 0, 0, len(records), len(records), len(kept), offset) |
| + struct.pack("<4sIQI", ZIP64_LOCATOR, 0, offset + len(kept), 1) |
| + struct.pack("<4s4H2IH", ZIP_END, 0, 0, len(records), len(records), len(kept), offset, 0)) |
| with zipfile.ZipFile(_BoundedArchive(file, start, tail)) as archive: |
| for info in archive.infolist(): |
| refusal = _zip_refusal(info, spent) |
| spent += info.file_size if refusal is None else 0 |
| entries.append(_zip_entry(archive, info, refusal)) |
| except (zipfile.BadZipFile, zlib.error, EOFError, NotImplementedError, OSError, ValueError, struct.error): |
| return {"format": "zip", "view": None, "error": "not a readable zip archive"} |
| view = {"entries": entries, "entry_count": count, "truncated": count > len(entries)} |
| return {"format": "zip", "view": view, "truncated": view["truncated"]} |
|
|
|
|
| @computer_app(supports=[{"os": {"type": "linux", "display": ["x11"]}, "arch": ["amd64", "arm64"]}]) |
| @linux( |
| packages=Packages(apt=["scribus"]), |
| launch=Launch(at="boot", command=["sh", "-c", "cd \"$HOME\" 2>/dev/null; exec 'scribus' \"$HOME\"/'Documents/jazz-night-flyer.sla'"], window={"class": "scribus"}, ready=Ready(window=True)), |
| paths=PATHS, |
| skill="SKILL.md", |
| ) |
| class Scribus(ComputerAppEnvironment): |
| """Scribus, launched at boot with the captured state in its home. |
| |
| Declaring data hooks switches off agentenv's default data plane, so these call its helpers: the seed is kept as |
| the initial state, reset restores it, add writes files under PATHS, and get returns those files plus a typed JSON |
| view of each. |
| """ |
|
|
| def __init__(self) -> None: |
| super().__init__() |
| if not INITIAL.exists(): |
| _seed_home(Path.home()) |
| _load_dconf(Path.home()) |
| keep_initial(self.paths) |
|
|
| @add_data |
| async def add_files(self, parts: list) -> None: |
| await add(parts, self.paths) |
|
|
| @get_data |
| async def get_files(self, write_namespace=None) -> list: |
| files = await get(self.paths, write_namespace) |
| views = await in_thread(_views, Path.home(), self.paths) |
| return [*files, DataPart(data={"state": views})] |
|
|
| @reset_data |
| async def reset_files(self) -> None: |
| await reset(self.paths) |
|
|
| @ready_check |
| def main_window_shown(self) -> bool: |
| """A window of the app's class that the taskbar lists is shown, not only a splash screen or a dialog.""" |
| return _taskbar_window(WINDOW_CLASS) |
|
|
