@uipath/maestro-builder-sdk 5.2.0

package/dist/generators/extract_library.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""Extract the connector library out of a downloaded zip, safely.
+
+Python owns this step because `zipfile` is in the standard library and the SDK
+would otherwise need its first archive dependency. The caller (Node) has already
+fetched the archive and checked its sha256; this script only unpacks it.
+
+Everything here is about not trusting the archive. A zip carries whatever paths
+its author put in it, so entry names are validated rather than joined:
+
+  * only entries under `--root` are considered, and the prefix is stripped, so
+    the tree flattens to the destination;
+  * a segment that is empty, `.` or `..` aborts the whole extraction. Not skips
+    it — aborts. An archive containing `../../etc/foo` is not an archive with one
+    bad file, it is an archive we should not be unpacking;
+  * absolute names and Windows drive letters are rejected for the same reason;
+  * symlink entries are refused. Nothing in the library needs one, and a symlink
+    written during extraction turns a later write into a write somewhere else;
+  * `index.json` has to land, or the archive was not the library and the caller
+    should hear about it rather than get an empty directory.
+
+Usage:
+    extract_library.py --archive <zip> --into <dir> [--root <prefix>]
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import stat
+import sys
+import zipfile
+
+DEFAULT_ROOT = "integrations/library-json/"
+
+
+class UnsafeArchive(Exception):
+    """The archive asked for something outside the destination."""
+
+
+def safe_relative_path(entry_name: str, root: str) -> str | None:
+    """The destination-relative path for `entry_name`, or None to skip it.
+
+    Raises UnsafeArchive when the name is one we refuse outright. Mirrors
+    `safeLibraryRelativePath` in the product CLI so both extractors agree on
+    what a hostile entry looks like.
+    """
+    normalized = entry_name.replace("\\", "/")
+    if not normalized.startswith(root):
+        return None
+    relative = normalized[len(root):]
+    if not relative or relative.endswith("/"):
+        return None  # the directory entry itself
+    if relative.startswith("/") or ":" in relative.split("/")[0]:
+        raise UnsafeArchive(f"absolute or drive-qualified entry: {entry_name}")
+    parts = relative.split("/")
+    if any(part in ("", ".", "..") for part in parts):
+        raise UnsafeArchive(f"unsafe entry: {entry_name}")
+    return relative
+
+
+def is_symlink(info: zipfile.ZipInfo) -> bool:
+    # The unix mode lives in the top 16 bits of external_attr. Zips written on
+    # Windows leave it zero, which reads as "not a symlink" — correct, since
+    # those cannot carry one.
+    return stat.S_ISLNK(info.external_attr >> 16)
+
+
+def extract(archive_path: str, destination: str, root: str) -> int:
+    written = 0
+    with zipfile.ZipFile(archive_path) as archive:
+        for info in archive.infolist():
+            relative = safe_relative_path(info.filename, root)
+            if relative is None:
+                continue
+            if is_symlink(info):
+                raise UnsafeArchive(f"symlink entry: {info.filename}")
+            target = os.path.join(destination, *relative.split("/"))
+            os.makedirs(os.path.dirname(target), exist_ok=True)
+            with archive.open(info) as source, open(target, "wb") as sink:
+                sink.write(source.read())
+            written += 1
+    return written
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--archive", required=True, help="downloaded .zip")
+    parser.add_argument("--into", required=True, help="destination directory")
+    parser.add_argument(
+        "--root",
+        default=DEFAULT_ROOT,
+        help=f"only extract entries under this prefix (default: {DEFAULT_ROOT})",
+    )
+    args = parser.parse_args()
+
+    if not os.path.isfile(args.archive):
+        print(f"extract-library: no such archive: {args.archive}",
+              file=sys.stderr)
+        return 1
+
+    os.makedirs(args.into, exist_ok=True)
+    try:
+        written = extract(args.archive, args.into, args.root)
+    except UnsafeArchive as unsafe:
+        print(f"extract-library: {unsafe}", file=sys.stderr)
+        return 1
+    except zipfile.BadZipFile as bad:
+        print(f"extract-library: {args.archive} is not a zip: {bad}",
+              file=sys.stderr)
+        return 1
+
+    if written == 0 or not os.path.isfile(os.path.join(args.into, "index.json")):
+        print(
+            f"extract-library: {args.archive} carries no {args.root}index.json",
+            file=sys.stderr,
+        )
+        return 1
+
+    print(f"extract-library: wrote {written} file(s) to {args.into}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())