hbkit 0.1.0__py3-none-any.whl

hbkit/__init__.py

@@ -0,0 +1,7 @@
+"""hbkit - recover files from Synology Hyper Backup (.hbk) archives without Synology software."""
+
+__version__ = "0.1.0"
+
+from .archive import Archive, UnsupportedArchive, find_archive_root, is_archive  # noqa: F401
+
+__all__ = ["Archive", "UnsupportedArchive", "find_archive_root", "is_archive", "__version__"]

hbkit/archive.py

@@ -0,0 +1,387 @@
+"""Read a Synology Hyper Backup (.hbk) archive directly. No Synology software required.
+
+Format (reverse engineered; all integers BIG-ENDIAN):
+  version_list.off_virtual_file -> virtual_file.index record (56B)
+    i64 @0 = (file_chunk_index_id << 48) | byte_offset
+  -> Config/file_chunk<id>.index @byte_offset : flat array of BE i64 keys, 8B each
+  -> each key = byte offset into Pool/chunk_index (29B records)
+       u8 mode @0 ; if mode&1 -> i64 cite_offset @1 (indirect, recurse)
+                    else      -> i32 bucket_id @1, i32 bucket_index_offset @5
+  -> Pool/<pool>/<bucket_id>>11>/<bucket_id & 0x7FF>.index @bucket_index_offset  (32B record)
+       u32 comp_len, u32 offset, u32 uncomp_len, md5[16] of DECOMPRESSED chunk,
+       u32 crc32 of record[0:28]
+  -> same-named .bucket @offset, comp_len bytes: raw LZ4 BLOCK (zlib is the fallback codec;
+     SYNO::Backup::decompress dispatches type 1/2/4 = lz4 / lz4-hc / zlib)
+
+Index families are <N>.idx shards concatenated in numeric order; records start at stream
+offset 64; only shard 0 carries the 64-byte header (magic 0x7053A86E).
+
+Synology writes a generation suffix on most files (`0.idx.2`, `1.db.2`, `index_ver.json.1`).
+Everything here resolves `name`, `name.1`, `name.2`... transparently, preferring the highest
+generation, and ignores macOS AppleDouble junk (`._*`).
+"""
+from __future__ import annotations
+
+import ctypes
+import hashlib
+import os
+import re
+import struct
+import zlib
+from collections import OrderedDict
+
+class UnsupportedArchive(Exception):
+    """The archive uses a layout this reader does not implement. Never guess - a wrong
+    guess here means silently wrong bytes, which is the one outcome a recovery tool
+    must never produce."""
+
+
+MAX_OPEN_BUCKETS = int(os.environ.get("HBK_MAX_OPEN", "64"))
+BUCKET_BUF = int(os.environ.get("HBK_BUCKET_BUF", 1 << 22))   # read-ahead; platter drives care
+INDEX_BUF = int(os.environ.get("HBK_INDEX_BUF", 1 << 16))     # chunk keys are mostly sequential;
+                                                             # unbuffered = one syscall per 29 B
+MAGIC = 0x7053A86E
+
+_LZ4_CANDIDATES = [
+    os.environ.get("HBK_LZ4"),
+    "/opt/homebrew/lib/liblz4.dylib",
+    "/usr/local/lib/liblz4.dylib",
+    "/usr/lib/x86_64-linux-gnu/liblz4.so.1",
+    "liblz4.so.1", "liblz4.dylib",
+]
+_lz4 = None
+
+
+def lz4():
+    """Lazily bind liblz4. Note the x86_64 dylib inside HyperBackupExplorer.app will
+    not load on Apple Silicon - use a native one (brew install lz4)."""
+    global _lz4
+    if _lz4 is None:
+        for c in _LZ4_CANDIDATES:
+            if not c:
+                continue
+            try:
+                lib = ctypes.CDLL(c)
+            except OSError:
+                continue
+            lib.LZ4_decompress_safe.argtypes = [ctypes.c_char_p, ctypes.c_char_p,
+                                                ctypes.c_int, ctypes.c_int]
+            lib.LZ4_decompress_safe.restype = ctypes.c_int
+            _lz4 = lib
+            break
+        else:
+            raise RuntimeError("liblz4 not found - set HBK_LZ4 to its path (brew install lz4)")
+    return _lz4
+
+
+# ------------------------------------------------------------ path resolution
+
+_SHARD = re.compile(r"^(\d+)\.idx(?:\.(\d+))?$")
+
+
+def resolve(d: str, base: str) -> str:
+    """Find `base` / `base.<gen>` inside directory `d`, preferring the highest generation."""
+    best = None
+    try:
+        names = os.listdir(d)
+    except OSError as e:
+        raise FileNotFoundError(f"{d}: {e}") from e
+    for f in names:
+        if f.startswith("._"):
+            continue
+        if f == base:
+            gen = 0
+        elif f.startswith(base + "."):
+            suf = f[len(base) + 1:]
+            if not suf.isdigit():
+                continue
+            gen = int(suf)
+        else:
+            continue
+        if best is None or gen > best[0]:
+            best = (gen, f)
+    if best is None:
+        raise FileNotFoundError(f"no {base}[.gen] in {d}")
+    return os.path.join(d, best[1])
+
+
+class Cat:
+    """Numbered <N>.idx[.gen] shards presented as a single logical byte stream."""
+
+    def __init__(self, d: str):
+        self.d = d
+        found: dict[int, tuple[int, str]] = {}
+        for f in os.listdir(d):
+            if f.startswith("._"):
+                continue
+            m = _SHARD.match(f)
+            if not m:
+                continue
+            n, gen = int(m.group(1)), int(m.group(2) or 0)
+            if n not in found or gen > found[n][0]:
+                found[n] = (gen, f)
+        if not found:
+            raise FileNotFoundError(f"no .idx shards in {d}")
+        self.files = [found[k][1] for k in sorted(found)]
+        self.sizes = [os.path.getsize(os.path.join(d, f)) for f in self.files]
+        self.starts, t = [], 0
+        for s in self.sizes:
+            self.starts.append(t)
+            t += s
+        self.total = t
+        self._fh: dict[int, object] = {}
+        # Shard 0 carries a 64-byte header that declares the record size, so readers do
+        # not have to hardcode per-DSM-version layouts.
+        with open(os.path.join(d, self.files[0]), "rb") as fh:
+            head = fh.read(64)
+        if len(head) < 64:
+            raise UnsupportedArchive(f"{d}: shard 0 is shorter than its header")
+        w = struct.unpack(">16I", head)
+        if w[0] != MAGIC:
+            raise UnsupportedArchive(f"{d}: bad magic {w[0]:#010x}, expected {MAGIC:#010x}")
+        self.kind, self.variant = w[1], w[2]
+        self.record_size = w[4]
+        self.declared_total = (w[5] << 32) | w[6]
+
+    def read(self, off: int, n: int) -> bytes:
+        out = b""
+        for i, (f, st, sz) in enumerate(zip(self.files, self.starts, self.sizes)):
+            if off + n <= st or off >= st + sz:
+                continue
+            a, b = max(off, st), min(off + n, st + sz)
+            fh = self._fh.get(i)
+            if fh is None:
+                fh = self._fh[i] = open(os.path.join(self.d, f), "rb", buffering=INDEX_BUF)
+            fh.seek(a - st)
+            out += fh.read(b - a)
+        return out
+
+    def close(self):
+        for fh in self._fh.values():
+            fh.close()
+        self._fh.clear()
+
+
+def is_archive(d: str) -> bool:
+    return os.path.isdir(os.path.join(d, "Pool")) and os.path.isdir(os.path.join(d, "Config"))
+
+
+def find_archive_root(path: str) -> str:
+    """Accept the .hbk directory itself, a parent containing one, or the .bkpi file."""
+    path = os.path.abspath(os.path.expanduser(path))
+    if os.path.isfile(path):
+        path = os.path.dirname(path)
+    if is_archive(path):
+        return path
+    if os.path.isdir(path):
+        for e in sorted(os.listdir(path)):
+            c = os.path.join(path, e)
+            if not e.startswith("._") and os.path.isdir(c) and is_archive(c):
+                return c
+    raise FileNotFoundError(f"no Hyper Backup archive at {path}")
+
+
+# --------------------------------------------------------------------- archive
+
+class Archive:
+    """One .hbk archive. Cheap to construct; caches open handles and bucket indexes."""
+
+    def __init__(self, root: str):
+        self.root = find_archive_root(root)
+        c, p = f"{self.root}/Config", f"{self.root}/Pool"
+        self.vf = Cat(f"{c}/virtual_file.index")
+        self.ci = Cat(f"{p}/chunk_index")
+        self.fc: dict[int, Cat] = {}
+        for e in os.listdir(c):
+            m = re.match(r"^file_chunk(\d+)\.index$", e)
+            if m and os.path.isdir(os.path.join(c, e)):
+                self.fc[int(m.group(1))] = Cat(os.path.join(c, e))
+        if not self.fc:
+            raise FileNotFoundError(f"no file_chunk<N>.index directories in {c}")
+        pools = [e for e in os.listdir(p) if e.isdigit() and os.path.isdir(os.path.join(p, e))]
+        if not pools:
+            raise FileNotFoundError(f"no numbered pool directory under {p}")
+        self.pools = sorted(pools, key=int)
+        self.pool = os.path.join(p, self.pools[0])
+        self._bidx: OrderedDict[int, bytes] = OrderedDict()
+        self._bdat: OrderedDict[int, object] = OrderedDict()
+        self._brec: dict[int, int] = {}
+
+        if self.vf.record_size != 56:
+            raise UnsupportedArchive(
+                f"virtual_file record size {self.vf.record_size}, only 56 is implemented")
+        if self.ci.record_size not in (16, 29):
+            raise UnsupportedArchive(
+                f"chunk_index record size {self.ci.record_size}, "
+                "only 16 (v1/v2) and 29 (v3) are implemented")
+
+    # -- metadata ---------------------------------------------------------
+
+    def task_config(self) -> dict:
+        out: dict[str, str] = {}
+        try:
+            p = resolve(self.root, "_Syno_TaskConfig")
+        except FileNotFoundError:
+            return out
+        with open(p, encoding="utf-8", errors="replace") as fh:
+            for line in fh:
+                if "=" in line and not line.startswith("["):
+                    k, v = line.split("=", 1)
+                    out[k.strip()] = v.strip().strip('"')
+        return out
+
+    def is_encrypted(self) -> bool:
+        return self.task_config().get("enable_data_encrypt", "false").lower() == "true"
+
+    def shares(self) -> list[str]:
+        d = f"{self.root}/Config/@Share"
+        if not os.path.isdir(d):
+            return []
+        return sorted(e for e in os.listdir(d)
+                      if not e.startswith("._") and os.path.isdir(os.path.join(d, e)))
+
+    def share_versions(self, share: str) -> list[int]:
+        d = f"{self.root}/Config/@Share/{share}"
+        vs = set()
+        for f in os.listdir(d):
+            if f.startswith("._") or f.startswith("complete_list"):
+                continue
+            m = re.match(r"^(\d+)\.db(?:\.\d+)?$", f)
+            if m:
+                vs.add(int(m.group(1)))
+        return sorted(vs)
+
+    def share_db(self, share: str, version: int | None = None) -> str:
+        d = f"{self.root}/Config/@Share/{share}"
+        if version is None:
+            vs = self.share_versions(share)
+            if not vs:
+                raise FileNotFoundError(f"no version db in {d}")
+            version = max(vs)
+        return resolve(d, f"{version}.db")
+
+    # -- chunk plumbing ---------------------------------------------------
+
+    def _bucket(self, bid: int):
+        idx = self._bidx.get(bid)
+        if idx is None:
+            sub = os.path.join(self.pool, str(bid >> 11))
+            f = bid & 0x7FF
+            with open(resolve(sub, f"{f}.index"), "rb") as fh:
+                idx = fh.read()
+            w = struct.unpack(">16I", idx[:64])
+            if w[0] != MAGIC:
+                raise UnsupportedArchive(f"bucket {bid}: bad index magic {w[0]:#010x}")
+            if w[4] not in (28, 32):
+                raise UnsupportedArchive(
+                    f"bucket {bid}: index record size {w[4]}, only 28 and 32 are implemented")
+            self._brec[bid] = w[4]
+            self._bidx[bid] = idx
+            self._bdat[bid] = open(resolve(sub, f"{f}.bucket"), "rb", buffering=BUCKET_BUF)
+            while len(self._bidx) > MAX_OPEN_BUCKETS:
+                k, _ = self._bidx.popitem(last=False)
+                self._bdat.pop(k).close()
+        else:
+            self._bidx.move_to_end(bid)
+            self._bdat.move_to_end(bid)
+        return idx, self._bdat[bid]
+
+    def chunk_ref(self, key: int, depth: int = 0):
+        """Resolve a chunk_index key to (bucket_id, bucket_index_offset)."""
+        if depth > 16:
+            raise ValueError("chunk_index cite loop")
+        n = self.ci.record_size
+        r = self.ci.read(key, n)
+        if len(r) < min(n, 9):
+            raise ValueError(f"short chunk_index record at {key}")
+        if n == 16:                       # v1/v2: bucket_id and offset sit at the front
+            return struct.unpack(">ii", r[0:8])
+        if r[0] & 1:                      # v3 bit0 = intra-cite indirection (dedup)
+            return self.chunk_ref(struct.unpack(">q", r[1:9])[0], depth + 1)
+        return struct.unpack(">ii", r[1:9])
+
+    def read_chunk(self, bid: int, boff: int, verify: bool = True) -> bytes:
+        idx, fh = self._bucket(bid)
+        n = self._brec[bid]
+        rec = idx[boff:boff + n]
+        if len(rec) < n:
+            raise ValueError(f"bucket {bid} index truncated at {boff}")
+        clen, off, ulen = struct.unpack(">III", rec[:12])
+        # 32-byte records carry a trailing CRC32 over the record; 28-byte legacy ones do not
+        if verify and n == 32 and (zlib.crc32(rec[:28]) & 0xFFFFFFFF) != struct.unpack(">I", rec[28:32])[0]:
+            raise ValueError(f"bucket index CRC32 mismatch b{bid}@{boff}")
+        fh.seek(off)
+        raw = fh.read(clen)
+        dst = ctypes.create_string_buffer(ulen)
+        n = lz4().LZ4_decompress_safe(raw, dst, clen, ulen)
+        data = dst.raw[:n] if n > 0 else b""
+        if n != ulen:
+            try:
+                data = zlib.decompress(raw)                 # compress type 4
+            except Exception:
+                raise ValueError(f"decompress failed b{bid}@{boff} lz4={n} want={ulen}") from None
+        if verify and hashlib.md5(data).digest() != rec[12:28]:
+            raise ValueError(f"MD5 mismatch b{bid}@{boff}")
+        return data
+
+    def extract(self, ovf: int, size: int, verify: bool = True, out=None):
+        """Rebuild one file. Writes to `out` if given (returns byte count), else returns bytes."""
+        if not size:
+            return 0 if out is not None else b""
+        if ovf is None or ovf < 0:
+            # sentinel: the whole file is deduped into Pool/file_pool rather than chunked.
+            # Exactly 1 of 501,278 files in the reference archive. Not decoded.
+            raise ValueError("whole-file dedup entry (Pool/file_pool) - not supported")
+        v = struct.unpack(">q", self.vf.read(ovf, 8))[0]
+        fc = self.fc.get(v >> 48)
+        if fc is None:
+            raise ValueError(f"no file_chunk{v >> 48}.index in archive")
+        off = v & 0xFFFFFFFFFFFF
+        parts, got, i, BATCH = [], 0, 0, 4096
+        while got < size:
+            blob = fc.read(off + i * 8, 8 * BATCH)
+            if not blob:
+                raise ValueError(f"chunk list exhausted at {got}/{size} bytes")
+            for j in range(0, len(blob) - 7, 8):
+                if got >= size:
+                    break
+                bid, boff = self.chunk_ref(struct.unpack(">q", blob[j:j + 8])[0])
+                d = self.read_chunk(bid, boff, verify=verify)
+                got += len(d)
+                if out is not None:
+                    out.write(d)
+                else:
+                    parts.append(d)
+                i += 1
+        if got != size:
+            raise ValueError(f"size mismatch: rebuilt {got}, expected {size}")
+        return got if out is not None else b"".join(parts)
+
+    def close(self):
+        self.vf.close()
+        self.ci.close()
+        for c in self.fc.values():
+            c.close()
+        for fh in self._bdat.values():
+            fh.close()
+        self._bdat.clear()
+        self._bidx.clear()
+
+
+# ------------------------------------------------- module-level convenience API
+# One cached Archive per root, so worker processes build it once and reuse it.
+
+_cache: dict[str, Archive] = {}
+
+
+def open_archive(root: str | None = None) -> Archive:
+    root = root or os.environ.get("HBK_ROOT") or ""
+    key = os.path.abspath(os.path.expanduser(root))
+    a = _cache.get(key)
+    if a is None:
+        a = _cache[key] = Archive(root)
+    return a
+
+
+def extract(ovf: int, size: int, verify: bool = True, out=None, root: str | None = None):
+    return open_archive(root).extract(ovf, size, verify=verify, out=out)

hbkit/cli.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Recover files from a Synology Hyper Backup (.hbk) archive. No Synology software needed.
+
+  hbk <archive> doctor                               check whether it can be recovered
+  hbk <archive> info                                 show task, shares, codec
+  hbk <archive> list  [pattern]                      search the file index
+  hbk <archive> get   <glob> <dest> [-j N]           extract (keeps tree + mtimes)
+  hbk <archive> verify <glob>      [-j N]            integrity-check, write nothing
+  hbk <archive> tui                                  browse in the full-screen UI
+
+<archive> is a .hbk directory, or any drive/folder containing one.
+Globs match the full archive path, which starts with the share name.
+Extraction is resumable: correctly-sized files are skipped.
+
+  hbk /Volumes/Backup doctor
+  hbk /Volumes/Backup list holiday
+  hbk /Volumes/Backup get "/Photos/2019/*" ~/restore
+"""
+from __future__ import annotations
+
+import fnmatch
+import os
+import shutil
+import sqlite3
+import sys
+import time
+
+
+from . import archive as hbk
+from . import index as hbk_index
+from . import runner as hbk_run
+
+CODECS = {"0": "none", "1": "lz4", "2": "lz4-hc", "4": "zlib"}
+
+
+def human(n) -> str:
+    n = float(n or 0)
+    for u in ("B", "K", "M", "G", "T"):
+        if abs(n) < 1024 or u == "T":
+            return f"{n:.0f}B" if u == "B" else f"{n:,.1f}{u}"
+        n /= 1024
+    return f"{n:,.1f}T"
+
+
+def hms(s) -> str:
+    s = max(0, int(s or 0))
+    h, m, sec = s // 3600, (s % 3600) // 60, s % 60
+    return f"{h}:{m:02d}:{sec:02d}" if h else f"{m:02d}:{sec:02d}"
+
+
+def all_files(db):
+    """(path, ovf, size, mtime) for every file; path begins with the share name."""
+    return db.execute("""
+        WITH RECURSIVE t(id,path,isdir) AS (
+            SELECT id, '/'||name, isdir FROM node WHERE parent IS NULL
+            UNION ALL
+            SELECT n.id, t.path||'/'||n.name, n.isdir
+              FROM node n JOIN t ON n.parent=t.id
+        )
+        SELECT t.path, n.ovf, n.size, n.mtime
+          FROM t JOIN node n ON n.id=t.id
+         WHERE t.isdir=0 AND n.ovf IS NOT NULL
+    """)
+
+
+def open_index(archive):
+    arc = hbk.Archive(archive)
+    if arc.is_encrypted():
+        sys.exit("archive is encrypted - extraction is not supported")
+    if not hbk_index.is_current(arc):
+        print("indexing archive (first use only)...", file=sys.stderr)
+        hbk_index.build(arc, progress=lambda s, d, n: print(f"  {s} [{d}/{n}]", file=sys.stderr))
+    return arc, sqlite3.connect(f"file:{hbk_index.cache_path(arc)}?mode=ro", uri=True)
+
+
+def run(arc, sel, dest, jobs, check):
+    total = sum(s[2] for s in sel)
+    print(f"{len(sel):,} files, {human(total)}, {jobs} workers"
+          + (" - verify only, nothing written" if check else f" -> {dest}"))
+    if not check:
+        os.makedirs(dest, exist_ok=True)
+    r = hbk_run.Runner(arc.root, dest, sel, jobs, verify=True, check=check)
+    tty = sys.stderr.isatty()
+    t0 = time.time()
+    r.start()
+    try:
+        while not r.finished:
+            r.poll()
+            el = max(time.time() - t0, 1e-6)
+            pct = 100 * r.bytes_done / total if total else 100
+            rate = r.bytes_done / el
+            eta = (total - r.bytes_done) / rate if rate > 0 else 0
+            if tty:      # only paint a live line on a terminal; piped output stays clean
+                sys.stderr.write(f"\r  {pct:5.1f}%  {r.done_files:,}/{r.total_files:,}  "
+                                 f"{human(r.bytes_done)}  {rate/1e6:,.0f} MB/s  eta {hms(eta)}   ")
+                sys.stderr.flush()
+            time.sleep(0.25)
+        r.poll()
+    except KeyboardInterrupt:
+        r.cancel()
+        print("\ncancelled", file=sys.stderr)
+    finally:
+        r.cleanup()
+    el = max(time.time() - t0, 1e-6)
+    if tty:
+        sys.stderr.write("\r" + " " * 78 + "\r")
+    verb = "verified" if check else "extracted"
+    print(f"{r.ok:,} {verb}, {r.skipped:,} already present, {r.failed:,} failed "
+          f"in {hms(el)} ({r.bytes_done/el/1e6:,.0f} MB/s)")
+    for p, m in r.errors[:20]:
+        print(f"  FAIL {p}: {m}")
+    if len(r.errors) > 20:
+        print(f"  ... and {len(r.errors)-20} more")
+    return 1 if r.failed else 0
+
+
+def main() -> int:
+    a = sys.argv[1:]
+    jobs = 8
+    if "-j" in a:
+        i = a.index("-j")
+        jobs = int(a[i + 1])
+        del a[i:i + 2]
+    if len(a) < 2:
+        print(__doc__)
+        return 1
+    archive, cmd = a[0], a[1]
+
+    if cmd == "doctor":
+        from . import doctor
+        r = doctor.diagnose(archive)
+        print(doctor.render(r))
+        return 0 if (r.ok and not r.blockers) else 1
+
+    if cmd == "tui":
+        from .tui import HBKApp
+        HBKApp(jobs, archive).run()
+        return 0
+
+    if cmd == "info":
+        arc = hbk.Archive(archive)
+        cfg = arc.task_config()
+        print(f"archive   : {arc.root}")
+        print(f"task      : {cfg.get('name','?')}   host {cfg.get('host_name','?')}")
+        print(f"codec     : {CODECS.get(cfg.get('data_compress_type',''), '?')}")
+        print(f"encrypted : {arc.is_encrypted()}")
+        print(f"sources   : {cfg.get('backup_folders','?')}")
+        for s in arc.shares():
+            print(f"  share {s}   versions={arc.share_versions(s)}")
+        return 0
+
+    arc, db = open_index(archive)
+
+    if cmd == "list":
+        pat = a[2].lower() if len(a) > 2 else ""
+        n = tot = 0
+        for path, ovf, size, mt in all_files(db):
+            if pat in path.lower():
+                n += 1
+                tot += size or 0
+                if n <= 200:
+                    print(f"{size or 0:>13,}  {path}")
+        print(f"\n{n:,} files, {human(tot)}" + (" (first 200 shown)" if n > 200 else ""))
+        return 0
+
+    if cmd in ("get", "verify"):
+        if len(a) < 3 or (cmd == "get" and len(a) < 4):
+            print(__doc__)
+            return 1
+        glob = a[2]
+        dest = os.path.abspath(os.path.expanduser(a[3])) if cmd == "get" else ""
+        sel = [row for row in all_files(db) if fnmatch.fnmatch(row[0], glob)]
+        if not sel:
+            print("no files matched that glob")
+            return 1
+        if cmd == "get":
+            need = sum(s[2] for s in sel)
+            probe = dest
+            while probe and not os.path.exists(probe):
+                probe = os.path.dirname(probe)
+            free = shutil.disk_usage(probe or "/").free
+            if need > free:
+                print(f"not enough space: need {human(need)}, have {human(free)} free")
+                return 1
+        return run(arc, sel, dest, jobs, cmd == "verify")
+
+    print(__doc__)
+    return 1
+
+
+def main_entry() -> int:
+    """Console-script entry point; keeps `main()` usable as a plain function."""
+    try:
+        return main()
+    except KeyboardInterrupt:
+        return 130
+    except hbk.UnsupportedArchive as e:
+        print(f"unsupported archive: {e}", file=sys.stderr)
+        return 2
+    except FileNotFoundError as e:
+        print(f"{e}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main_entry())