workpeg 0.78.0__tar.gz → 0.79.1__tar.gz

{workpeg-0.78.0/src/workpeg.egg-info → workpeg-0.79.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workpeg
-Version: 0.78.0
+Version: 0.79.1
 Summary: Workpeg function runtime and SDK
 Author-email: Workpeg <support@workpeg.com>
 License: MIT

{workpeg-0.78.0 → workpeg-0.79.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "workpeg"
-version = "0.78.0"
+version = "0.79.1"
 description = "Workpeg function runtime and SDK"
 readme = "README.md"
 requires-python = ">=3.10"

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/cdn.py

@@ -9,6 +9,8 @@ from pathlib import Path
 
 import requests
 
+from workpeg.submit import _looks_secret
+
 
 DEFAULT_API_BASE = "https://repo.workpeg.com"
 
@@ -21,6 +23,10 @@ EXCLUDED_DIRS = {
     "venv",
     "dist",
     "build",
+    # credential stores — never publish these
+    ".ssh",
+    ".aws",
+    ".gnupg",
 }
 
 EXCLUDED_SUFFIXES = (".pyc", ".pyo")
@@ -79,6 +85,10 @@ def build_directory_tar_gz_bytes(path: Path) -> bytes:
             if item.name.endswith(EXCLUDED_SUFFIXES):
                 continue
 
+            # Never publish secrets, and never follow a symlink out of the tree.
+            if item.is_symlink() or _looks_secret(item.name):
+                continue
+
             archive.add(item, arcname=str(rel))
 
     return out.getvalue()

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/cli.py

@@ -388,6 +388,18 @@ def _fake_cloud_setup(app_name: str, explicit_port: int) -> "tuple[int, dict]":
     return port, {"ssl_cert": cert, "ssl_key": key, "url_host": domain}
 
 
+def _run_server(serve_fn, *args, **kwargs) -> None:
+    """Run a blocking dev server, turning a ServeError (e.g. a privileged or
+    in-use port) into a clean CLI error instead of a raw traceback."""
+    from workpeg.ui.serve import ServeError
+
+    try:
+        serve_fn(*args, **kwargs)
+    except ServeError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise SystemExit(1)
+
+
 def main(argv=None) -> None:
     argv = argv if argv is not None else sys.argv[1:]
 
@@ -597,7 +609,8 @@ def main(argv=None) -> None:
 
         # Watch the whole project directory so edits to any page file trigger
         # a recompile — not just changes to main.py.
-        serve_blocking(
+        _run_server(
+            serve_blocking,
             str(project_dir / "dist"),
             port,
             watch_source=str(project_dir),
@@ -653,8 +666,9 @@ def main(argv=None) -> None:
 
                 # Watch the project directory, not just main.py, so edits to
                 # any page file also trigger a recompile.
-                serve_blocking(out_dir, port, watch_source=str(source),
-                               peg_namespace=peg_ns, **extra)
+                _run_server(serve_blocking, out_dir, port,
+                            watch_source=str(source),
+                            peg_namespace=peg_ns, **extra)
             else:
                 # No main.py — treat as a pre-built dist directory and serve
                 # as-is. There's no recompile, so --peg-namespace can't apply
@@ -662,7 +676,7 @@ def main(argv=None) -> None:
                 if peg_ns:
                     print("  Note: --peg-namespace is ignored for a pre-built "
                           "dist (rebuild to change it).", file=sys.stderr)
-                serve_blocking(str(source), port, **extra)
+                _run_server(serve_blocking, str(source), port, **extra)
 
         elif source.suffix == ".py":
             from workpeg.ui.build import build_ui
@@ -676,8 +690,9 @@ def main(argv=None) -> None:
                 print(f"ERROR: {e}", file=sys.stderr)
                 raise SystemExit(2)
 
-            serve_blocking(out_dir, port, watch_source=str(source),
-                           peg_namespace=peg_ns, **extra)
+            _run_server(serve_blocking, out_dir, port,
+                        watch_source=str(source),
+                        peg_namespace=peg_ns, **extra)
 
         else:
             print(

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/context.py

@@ -62,7 +62,16 @@ class _TableContext(BaseContext):
 
     @classmethod
     def _verify_columns(cls, columns):
-        return True  # TODO
+        # A structural check, not a full schema: columns is a list of column
+        # definitions (each an object). Defense-in-depth on data the platform
+        # serialises in — reject a clearly-wrong shape, don't second-guess
+        # each field.
+        if columns is None:
+            return
+        if not isinstance(columns, list):
+            raise ValueError("Columns must be a list of column definitions.")
+        if not all(isinstance(c, dict) for c in columns):
+            raise ValueError("Each column must be a dictionary.")
 
     @classmethod
     def _verify_namespace(cls, namespace):
@@ -71,7 +80,17 @@ class _TableContext(BaseContext):
 
     @classmethod
     def _verify_peg(cls, peg):
-        return True  # TODO
+        # A peg identifier: a positive integer id (the common case) or a
+        # namespace string. bool is an int subclass in Python, so exclude it
+        # explicitly.
+        if peg is None:
+            return
+        if isinstance(peg, bool) or not isinstance(peg, (int, str)):
+            raise ValueError("Peg must be an integer id, a string, or None.")
+        if isinstance(peg, int) and peg <= 0:
+            raise ValueError("Peg id must be a positive integer.")
+        if isinstance(peg, str) and not peg.strip():
+            raise ValueError("Peg string must be non-empty.")
 
 
 class _StaffContext(BaseContext):

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/run.py

@@ -44,7 +44,10 @@ def run_with_docker(
         cmd += ["--name", name]
 
     if expose:
-        cmd += ["-p", f"{port}:{port}"]
+        # Publish to LOOPBACK only — a locally-run function's /invoke shouldn't
+        # be reachable from the LAN. (The deployed runtime binds 0.0.0.0 inside
+        # its own managed container; this is the developer's machine.)
+        cmd += ["-p", f"127.0.0.1:{port}:{port}"]
 
     if network:
         cmd += ["--network", network]

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/submit.py

@@ -16,6 +16,26 @@ JWT_ENV = "WORKPEG_PK"
 API_ENV = "WORKPEG_API_BASE"
 PATH_ENV = "WORKPEG_SUBMIT_PATH"
 
+# Files that must never leave the machine in a bundle/upload — env files, key
+# material, and credential stores. Matched by basename (case-insensitively).
+_SECRET_NAMES = frozenset({
+    ".envrc", ".netrc", ".npmrc", ".pypirc", ".htpasswd", ".dockercfg",
+    "credentials", "id_rsa", "id_dsa", "id_ecdsa", "id_ed25519",
+})
+_SECRET_SUFFIXES = (".pem", ".key", ".pfx", ".p12", ".keystore", ".jks")
+
+
+def _looks_secret(name: str) -> bool:
+    """A basename that looks like a secret (``.env``/``.env.local``, a key file,
+    a credential store) — excluded from bundles and uploads."""
+    lo = name.lower()
+    return (
+        lo == ".env"
+        or lo.startswith(".env.")
+        or lo in _SECRET_NAMES
+        or lo.endswith(_SECRET_SUFFIXES)
+    )
+
 
 def _fail(msg: str, code: int = 2) -> None:
     print(f"ERROR: {msg}", file=sys.stderr)
@@ -91,8 +111,13 @@ def build_tar_gz_bytes(source_dir: Path) -> bytes:
         "dist",
         "build",
         ".DS_Store",
+        # credential stores — never ship these off the machine
+        ".ssh",
+        ".aws",
+        ".gnupg",
     }
 
+    skipped_secrets: list[str] = []
     buf = io.BytesIO()
     with tarfile.open(fileobj=buf, mode="w:gz") as tar:
         for p in source_dir.rglob("*"):
@@ -101,12 +126,27 @@ def build_tar_gz_bytes(source_dir: Path) -> bytes:
             if any(part in exclude_names for part in rel.parts):
                 continue
 
+            # Never bundle secrets, and never follow symlinks out of the project
+            # (a link could point at anything on the machine). Belt-and-braces on
+            # top of validate_function_project.
+            if p.is_symlink():
+                skipped_secrets.append(rel.as_posix() + " (symlink)")
+                continue
+            if _looks_secret(rel.name):
+                skipped_secrets.append(rel.as_posix())
+                continue
+
             if not p.exists():
                 continue
 
             arcname = rel.as_posix()
             tar.add(p.as_posix(), arcname=arcname, recursive=False)
 
+    if skipped_secrets:
+        print(
+            "  Skipped (looks like a secret / symlink, not bundled): "
+            + ", ".join(sorted(skipped_secrets))
+        )
     return buf.getvalue()
 
 

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/ui/compiler/ast_parser.py

@@ -76,10 +76,11 @@ _WORKPEG_TABLE_HELPERS = {
 
 
 def _is_workpeg_host(url: str) -> bool:
-    """True when *url* targets a Workpeg-owned host — ``workpeg`` appearing as a
-    domain label (workpeg.com, *.workpeg.*, …), not as the TLD. Relative URLs
-    have no host and are never Workpeg. Mirrors ``Workpeg._isWorkpegHost`` in
-    the runtime."""
+    """True when *url* targets a Workpeg-owned host — ``workpeg`` as the
+    REGISTRABLE label, the one right before the TLD (workpeg.com, *.workpeg.io,
+    …), not merely somewhere in the name (so ``foo.workpeg.evil.com`` is NOT
+    Workpeg). Relative URLs have no host and are never Workpeg. Mirrors
+    ``Workpeg._isWorkpegHost`` in the runtime."""
     try:
         host = urlparse(url).hostname
     except ValueError:
@@ -87,7 +88,7 @@ def _is_workpeg_host(url: str) -> bool:
     if not host:
         return False
     labels = host.lower().split(".")
-    return "workpeg" in labels[:-1]
+    return len(labels) >= 2 and labels[-2] == "workpeg"
 
 
 _SUPPORTED_WIDGETS = {

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/ui/fake_cloud.py

@@ -47,6 +47,30 @@ def slugify(name: str) -> str:
     return re.sub(r"[^a-z0-9-]", "", slug).strip("-")
 
 
+# A plain hostname: dot-separated LDH labels, ≤253 chars. Anything else — a
+# space, newline, slash, shell metachar — is rejected before it reaches a hosts
+# file (where a newline could inject another mapping), a cert subject, or a path.
+_VALID_DOMAIN = re.compile(
+    r"^(?=.{1,253}$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?"
+    r"(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$",
+    re.IGNORECASE,
+)
+
+
+def _require_valid_domain(domain: str) -> None:
+    if not isinstance(domain, str) or not _VALID_DOMAIN.match(domain):
+        raise FakeCloudError(f"Refusing to use an invalid hostname: {domain!r}")
+
+
+def _lock_down_key(key: "Path") -> None:
+    """Make a generated TLS private key owner read/write only (0600). A no-op
+    where POSIX permissions don't apply."""
+    try:
+        os.chmod(key, 0o600)
+    except OSError:
+        pass
+
+
 def derive_domain(name: str) -> str:
     """Turn a project name into ``dev.<slug>.workpeg.com``.
 
@@ -107,6 +131,7 @@ def ensure_hosts_entry(domain: str, hosts_path: "str | None" = None) -> bool:
     terminal. Entries are tagged with a marker comment so they are easy
     to find and remove later.
     """
+    _require_valid_domain(domain)
     path = hosts_path or hosts_path_for_os()
     content = Path(path).read_text()
     if _has_hosts_entry(content, domain):
@@ -151,6 +176,7 @@ def ensure_certificate(
     ``"self-signed"`` (openssl fallback — browser warning). Certificates
     are cached under ``~/.workpeg/fake-cloud/<domain>/`` and reused.
     """
+    _require_valid_domain(domain)     # it lands in a path, a subject, a SAN
     root = Path(cert_root) if cert_root else _CERT_ROOT
     cert_dir = root / domain
     cert = cert_dir / "cert.pem"
@@ -178,6 +204,7 @@ def ensure_certificate(
                 check=True,
                 capture_output=True,
             )
+            _lock_down_key(key)
             kind_file.write_text("mkcert")
             return str(cert), str(key), "mkcert"
         except subprocess.CalledProcessError:
@@ -198,6 +225,7 @@ def ensure_certificate(
             check=True,
             capture_output=True,
         )
+        _lock_down_key(key)
         kind_file.write_text("self-signed")
         return str(cert), str(key), "self-signed"
 
@@ -209,14 +237,22 @@ def ensure_certificate(
 
 def pick_https_port(preferred: int = 443, fallback: int = 8443) -> int:
     """Best HTTPS port available: 443 (no port in URL) when bindable,
-    else 8443, else the first free port above 8443."""
+    else 8443, else the first free port above 8443.
+
+    Probes the bind on the *same* host the dev server will use
+    (``_bind_host()``, loopback by default) — not ``0.0.0.0`` — so the result
+    matches reality. On macOS a non-root process can bind 443 on all interfaces
+    but not on 127.0.0.1, so probing loopback correctly falls back to 8443
+    instead of handing back a 443 the server then can't bind."""
+    from workpeg.ui.serve import _bind_host, find_free_port
+
+    host = _bind_host()
     for port in (preferred, fallback):
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.bind(("", port))
+                s.bind((host, port))
             return port
         except OSError:
             continue
-    from workpeg.ui.serve import find_free_port
 
     return find_free_port(start=fallback + 1)

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/ui/runtime/ai.js

@@ -212,6 +212,43 @@
     });
   }
 
+  // Momentary "copied" confirmation on an icon copy button: swap its glyph to a
+  // check and its label to "Copied", then restore after a beat. Re-clicking
+  // resets the timer instead of stacking them, and the resting icon/label are
+  // captured only on the first flash so rapid clicks can't lose them.
+  function flashCopied(btn) {
+    if (!btn) return;
+    var ic = btn.querySelector("i");
+    if (btn._copiedTimer) {
+      clearTimeout(btn._copiedTimer);
+    } else if (ic) {
+      btn._restIcon = ic.className;
+      btn._restLabel = btn.getAttribute("aria-label");
+    }
+    if (ic) ic.className = "ti ti-check";
+    btn.classList.add("is-copied");
+    btn.setAttribute("aria-label", "Copied");
+    btn.setAttribute("title", "Copied");
+    btn._copiedTimer = setTimeout(function () {
+      if (ic) ic.className = btn._restIcon || "ti ti-copy";
+      btn.classList.remove("is-copied");
+      if (btn._restLabel) {
+        btn.setAttribute("aria-label", btn._restLabel);
+        btn.setAttribute("title", btn._restLabel);
+      }
+      btn._copiedTimer = null;
+    }, 1200);
+  }
+
+  // An icon copy button that confirms the copy with a momentary check.
+  function copyBtn(getText, extraCls) {
+    var btn = iconBtn("copy", "Copy", function () {
+      copyText(getText());
+      flashCopied(btn);
+    }, extraCls);
+    return btn;
+  }
+
   function escapeHtml(s) {
     return String(s == null ? "" : s)
       .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
@@ -666,7 +703,7 @@
     var bubble = el("div", "chat-message__bubble", { text: m.content });
     var actions = el("div", "chat-message__actions chat-message__actions--user", {
       children: [
-        iconBtn("copy", "Copy", function () { copyText(m.content); })
+        copyBtn(function () { return m.content; })
       ]
     });
     return el("div", "chat-message chat-message--user", { children: [
@@ -732,8 +769,8 @@
 
   function buildAiActions(node) {
     var m = node._msg;
-    var copy = iconBtn("copy", "Copy", function () {
-      copyText(node._bubble.innerText || m.content); }, "chat-message__action");
+    var copy = copyBtn(function () {
+      return node._bubble.innerText || m.content; }, "chat-message__action");
     var regen = iconBtn("refresh", "Regenerate", function () { regenerate(); },
       "chat-message__action");
     var right = el("div", "chat-message__actions-right", { children: [
@@ -1187,6 +1224,9 @@
     R + " .wpai-iconbtn{width:28px;height:28px;display:flex;align-items:center;justify-content:center;background:transparent;border:none;color:var(--color-icon-tertiary);cursor:pointer;border-radius:var(--radius,8px);transition:all .15s ease}",
     R + " .wpai-iconbtn:hover{background:var(--color-surface-sunken2);color:var(--color-icon-primary)}",
     R + " .wpai-iconbtn.is-active{color:var(--color-brand-secondary,var(--color-brand-primary))}",
+    // Momentary confirmation after a copy — the check reads as success, and this
+    // wins over :hover (defined earlier) so it stays green even under the cursor.
+    R + " .wpai-iconbtn.is-copied,.wpai-iconbtn.is-copied:hover{color:var(--color-success-500,#12b76a);background:transparent}",
     // chips + suggestions
     R + " .suggestions-section{display:grid;gap:16px;border-radius:var(--radius-lg,12px);padding:16px;width:100%}",
     R + " .chips-title{font-size:var(--text-body-sm-size,13px);color:var(--color-text-secondary);margin:0}",

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/ui/runtime/workpeg-runtime.js

@@ -49,7 +49,11 @@
   Workpeg._isWorkpegHost = function (url) {
     var host = urlHost(url);
     if (!host) return false;
-    return host.split(".").slice(0, -1).indexOf("workpeg") !== -1;
+    // "workpeg" must be the REGISTRABLE label — the one right before the TLD.
+    // So workpeg.com and dev.x.workpeg.io match, but foo.workpeg.evil.com does
+    // NOT: a bare "workpeg" label buried in an attacker's domain is not us.
+    var labels = host.split(".");
+    return labels.length >= 2 && labels[labels.length - 2] === "workpeg";
   };
 
   // Core request: NO Workpeg-host guard (workpeg.* uses this directly).
@@ -117,8 +121,10 @@
         (window.location && window.location.hostname) || ""
       ).toLowerCase();
       var labels = host.split(".");
-      var i = labels.indexOf("workpeg");
-      return i > 0 ? labels[i - 1] : "";
+      // Only a genuine Workpeg host (workpeg as the registrable label) names a
+      // namespace — the label right before "workpeg".
+      var i = labels.length - 2;
+      return (i > 0 && labels[i] === "workpeg") ? labels[i - 1] : "";
     } catch (e) {
       return "";
     }
@@ -407,7 +413,7 @@
       var ep = (window.location && window.location.pathname) || "/";
       window.location.href =
         Workpeg.accountsBase.replace(/\/+$/, "") +
-        "/login?peg=" + encodeURIComponent(ns) + "&ep=" + ep;
+        "/login?peg=" + encodeURIComponent(ns) + "&ep=" + encodeURIComponent(ep);
     } catch (e) { /* no window — nothing to redirect */ }
   };
 
@@ -4398,6 +4404,10 @@
       }
       if (props.target) {
         el.target = props.target;
+        // A new browsing context must not get a usable window.opener back to us
+        // (reverse tabnabbing) and shouldn't leak our URL as Referer — match
+        // HtmlView/Markdown, which already set this.
+        if (props.target === "_blank") el.rel = "noopener noreferrer";
       }
     } else {
       el = document.createElement("div");

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/ui/serve.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import errno
 import http.server
 import json
 import os
@@ -12,6 +13,11 @@ from pathlib import Path
 from typing import Callable
 
 
+class ServeError(Exception):
+    """A dev server couldn't start. Carries an actionable message for the CLI to
+    print instead of a raw traceback."""
+
+
 class _ReusingTCPServer(socketserver.TCPServer):
     allow_reuse_address = True
 
@@ -370,11 +376,48 @@ def find_free_port(start: int = 8080) -> int:
     )
 
 
+def _bind_host() -> str:
+    """Interface the dev server listens on. Localhost by default, so the app,
+    live-reload endpoint and error overlay aren't exposed to the whole LAN; set
+    ``WORKPEG_BIND_HOST=0.0.0.0`` to reach it from another device on purpose."""
+    return os.environ.get("WORKPEG_BIND_HOST", "127.0.0.1").strip() or "127.0.0.1"
+
+
+def _bind_tcp_server(server_cls, port: int, handler):
+    """Build *server_cls* bound to ``(_bind_host(), port)``, turning a failed
+    bind into a clear :class:`ServeError` (never a raw traceback).
+
+    macOS quirk worth calling out: a non-root process may bind a privileged
+    port (<1024) on *all* interfaces (``0.0.0.0``) but NOT on a single address
+    like ``127.0.0.1`` — so loopback-binding 443 fails with EACCES unless run
+    as root. That's why the message points at sudo / a high port / the
+    ``WORKPEG_BIND_HOST`` opt-out rather than just failing."""
+    host = _bind_host()
+    try:
+        return server_cls((host, port), handler)
+    except PermissionError as exc:
+        if port < 1024:
+            raise ServeError(
+                f"Can't bind {host}:{port} — port {port} is privileged (<1024). "
+                f"Re-run with sudo, use a high port (drop --port to auto-pick, "
+                f"or e.g. --port 8443), or set WORKPEG_BIND_HOST=0.0.0.0 to bind "
+                f"every interface (also reachable from the LAN)."
+            ) from exc
+        raise ServeError(f"Not permitted to bind {host}:{port}.") from exc
+    except OSError as exc:
+        if exc.errno == errno.EADDRINUSE:
+            raise ServeError(
+                f"{host}:{port} is already in use — stop whatever is using it, "
+                f"or pass a different --port."
+            ) from exc
+        raise
+
+
 def _create_server(
     directory: str, port: int
 ) -> tuple[_ReusingTCPServer, str]:
     abs_dir = str(Path(directory).resolve())
-    server = _ReusingTCPServer(("", port), _make_handler(abs_dir))
+    server = _bind_tcp_server(_ReusingTCPServer, port, _make_handler(abs_dir))
     return server, f"http://localhost:{port}"
 
 
@@ -457,7 +500,8 @@ def serve_background(
     if watch_source is not None:
         abs_dir = str(Path(directory).resolve())
         handler_cls, broadcast = _make_reload_handler(abs_dir)
-        server: socketserver.BaseServer = _ReloadTCPServer(("", port), handler_cls)
+        server: socketserver.BaseServer = _bind_tcp_server(
+            _ReloadTCPServer, port, handler_cls)
 
         from workpeg.ui.watcher import FileWatcher
 
@@ -510,7 +554,8 @@ def serve_blocking(
     if watch_source is not None:
         abs_dir = str(Path(directory).resolve())
         handler_cls, broadcast = _make_reload_handler(abs_dir)
-        server: socketserver.BaseServer = _ReloadTCPServer(("", port), handler_cls)
+        server: socketserver.BaseServer = _bind_tcp_server(
+            _ReloadTCPServer, port, handler_cls)
 
         from workpeg.ui.watcher import FileWatcher
 

{workpeg-0.78.0 → workpeg-0.79.1}/src/workpeg/ui/widgets/interactive.py

@@ -118,6 +118,9 @@ class Link(BaseWidget):
             p["label"] = self.label
         if self.target is not None:
             p["target"] = self.target
+        if self.aria_label:
+            # camelCase — the key the generator/runtime read (props.ariaLabel).
+            p["ariaLabel"] = self.aria_label
         if self.icon is not None:
             p["icon"] = self.icon
         return p

{workpeg-0.78.0 → workpeg-0.79.1/src/workpeg.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workpeg
-Version: 0.78.0
+Version: 0.79.1
 Summary: Workpeg function runtime and SDK
 Author-email: Workpeg <support@workpeg.com>
 License: MIT

{workpeg-0.78.0 → workpeg-0.79.1}/tests/test_cdn.py

@@ -85,6 +85,37 @@ def test_build_tar_includes_files_and_excludes_junk(tmp_path):
     assert "mod.pyc" not in names                 # .pyc suffix excluded
 
 
+def test_build_tar_excludes_secrets_and_symlinks(tmp_path):
+    (tmp_path / "index.html").write_text("hi")
+    # Secrets a developer might leave in an asset dir — never publish these.
+    (tmp_path / ".env").write_text("SECRET=1")
+    (tmp_path / "server.key").write_text("key")
+    (tmp_path / "id_rsa").write_text("key")
+    (tmp_path / ".ssh").mkdir()
+    (tmp_path / ".ssh" / "config").write_text("x")
+
+    # A symlink escaping the tree must not be followed.
+    outside = tmp_path.parent / "outside.txt"
+    outside.write_text("secret")
+    symlink_supported = True
+    try:
+        (tmp_path / "escape.txt").symlink_to(outside)
+    except (OSError, NotImplementedError):
+        symlink_supported = False
+
+    data = build_directory_tar_gz_bytes(tmp_path)
+    with tarfile.open(fileobj=io.BytesIO(data), mode="r:gz") as tar:
+        names = set(tar.getnames())
+
+    assert "index.html" in names
+    assert ".env" not in names
+    assert "server.key" not in names
+    assert "id_rsa" not in names
+    assert not any(n.startswith(".ssh") for n in names)
+    if symlink_supported:
+        assert "escape.txt" not in names
+
+
 def test_build_tar_missing_dir_exits(tmp_path):
     with pytest.raises(SystemExit):
         build_directory_tar_gz_bytes(tmp_path / "does-not-exist")

{workpeg-0.78.0 → workpeg-0.79.1}/tests/test_context.py

@@ -199,3 +199,83 @@ class TestMetadataContext:
 
         for case in test_cases:
             assert _MetadataContext.verify(case) is True
+
+
+class TestTableColumnsValidation:
+
+    def test_accepts_empty_list(self, valid_table_data):
+        valid_table_data["columns"] = []
+        assert _TableContext.verify(valid_table_data) is True
+
+    def test_accepts_list_of_dicts(self, valid_table_data):
+        valid_table_data["columns"] = [{"name": "a"}, {"name": "b"}]
+        assert _TableContext.verify(valid_table_data) is True
+
+    def test_accepts_none(self, valid_table_data):
+        valid_table_data["columns"] = None
+        assert _TableContext.verify(valid_table_data) is True
+
+    def test_rejects_non_list(self, valid_table_data):
+        valid_table_data["columns"] = {"not": "a list"}
+        with pytest.raises(
+            ValueError,
+            match="Columns must be a list of column definitions.",
+        ):
+            _TableContext.verify(valid_table_data)
+
+    def test_rejects_non_dict_entries(self, valid_table_data):
+        valid_table_data["columns"] = ["name", "age"]
+        with pytest.raises(
+            ValueError,
+            match="Each column must be a dictionary.",
+        ):
+            _TableContext.verify(valid_table_data)
+
+
+class TestTablePegValidation:
+
+    def test_accepts_positive_int(self, valid_table_data):
+        valid_table_data["peg"] = 10
+        assert _TableContext.verify(valid_table_data) is True
+
+    def test_accepts_namespace_string(self, valid_table_data):
+        valid_table_data["peg"] = "workpeg.hr"
+        assert _TableContext.verify(valid_table_data) is True
+
+    def test_accepts_none(self, valid_table_data):
+        valid_table_data["peg"] = None
+        assert _TableContext.verify(valid_table_data) is True
+
+    def test_rejects_zero_and_negative(self, valid_table_data):
+        for bad in (0, -5):
+            valid_table_data["peg"] = bad
+            with pytest.raises(
+                ValueError,
+                match="Peg id must be a positive integer.",
+            ):
+                _TableContext.verify(valid_table_data)
+
+    def test_rejects_bool(self, valid_table_data):
+        # bool is an int subclass — must not sneak through as a peg id.
+        valid_table_data["peg"] = True
+        with pytest.raises(
+            ValueError,
+            match="Peg must be an integer id, a string, or None.",
+        ):
+            _TableContext.verify(valid_table_data)
+
+    def test_rejects_wrong_type(self, valid_table_data):
+        valid_table_data["peg"] = {"id": 1}
+        with pytest.raises(
+            ValueError,
+            match="Peg must be an integer id, a string, or None.",
+        ):
+            _TableContext.verify(valid_table_data)
+
+    def test_rejects_blank_string(self, valid_table_data):
+        valid_table_data["peg"] = "   "
+        with pytest.raises(
+            ValueError,
+            match="Peg string must be non-empty.",
+        ):
+            _TableContext.verify(valid_table_data)

{workpeg-0.78.0 → workpeg-0.79.1}/tests/test_run.py

@@ -53,7 +53,7 @@ def test_run_with_docker_builds_first(monkeypatch, tmp_path):
     cmd, check = calls[0]
     assert cmd == [
         "docker", "run", "-d",
-        "-p", "9000:9000",
+        "-p", "127.0.0.1:9000:9000",
         "--network", "workpeg_net",
         "--restart", "unless-stopped",
         "built-image",
@@ -132,7 +132,7 @@ def test_run_with_docker_no_build(monkeypatch, tmp_path):
     cmd, check = calls[0]
     assert cmd == [
         "docker", "run", "-d",
-        "-p", "8000:8000",
+        "-p", "127.0.0.1:8000:8000",
         "--network", "bridge",
         "--restart", "unless-stopped",
         "configured-image",
@@ -307,7 +307,7 @@ def test_run_with_docker_expose(monkeypatch, tmp_path):
     cmd, check = calls[0]
     assert cmd == [
         "docker", "run", "-d",
-        "-p", "9000:9000",
+        "-p", "127.0.0.1:9000:9000",
         "--restart", "unless-stopped",
         "demo",
     ]

{workpeg-0.78.0 → workpeg-0.79.1}/tests/test_submit.py

@@ -137,6 +137,68 @@ def test_build_tar_gz_bytes_excludes_common_junk(tmp_path: Path):
     assert ".DS_Store" not in paths
 
 
+def test_build_tar_gz_bytes_excludes_secrets(tmp_path: Path, capsys):
+    # A valid function project...
+    (tmp_path / "Dockerfile").write_text("FROM scratch")
+    (tmp_path / "app").mkdir()
+    (tmp_path / "app" / "main.py").write_text("x=1\n")
+
+    # ...alongside secrets a careless developer might leave in the tree.
+    (tmp_path / ".env").write_text("SECRET=hunter2")
+    (tmp_path / ".env.local").write_text("TOKEN=abc")
+    (tmp_path / "server.key").write_text("-----BEGIN PRIVATE KEY-----")
+    (tmp_path / "tls.pem").write_text("-----BEGIN CERTIFICATE-----")
+    (tmp_path / "id_rsa").write_text("ssh-key")
+    (tmp_path / "credentials").write_text("[default]")
+    (tmp_path / ".ssh").mkdir()
+    (tmp_path / ".ssh" / "known_hosts").write_text("host")
+
+    tgz = submit.build_tar_gz_bytes(tmp_path)
+    paths = list_tar_paths(tgz)
+
+    assert "app/main.py" in paths
+    for leaked in (
+        ".env", ".env.local", "server.key", "tls.pem",
+        "id_rsa", "credentials",
+    ):
+        assert leaked not in paths, f"{leaked} must never be bundled"
+    assert all(not p.startswith(".ssh/") for p in paths)
+    # And the developer is told what was withheld.
+    assert "looks like a secret" in capsys.readouterr().out
+
+
+def test_build_tar_gz_bytes_skips_symlinks(tmp_path: Path):
+    (tmp_path / "Dockerfile").write_text("FROM scratch")
+    (tmp_path / "app").mkdir()
+    (tmp_path / "app" / "main.py").write_text("x=1\n")
+
+    # A symlink pointing at something outside the project must never be followed
+    # into the bundle.
+    outside = tmp_path.parent / "outside_secret.txt"
+    outside.write_text("do not exfiltrate")
+    link = tmp_path / "link_out.txt"
+    try:
+        link.symlink_to(outside)
+    except (OSError, NotImplementedError):
+        pytest.skip("symlinks unsupported on this platform")
+
+    tgz = submit.build_tar_gz_bytes(tmp_path)
+    paths = list_tar_paths(tgz)
+
+    assert "app/main.py" in paths
+    assert "link_out.txt" not in paths
+
+
+def test_looks_secret_matches_expected_names():
+    for name in (
+        ".env", ".ENV", ".env.production", ".netrc", "id_ed25519",
+        "key.pem", "cert.PEM", "store.p12", "app.keystore",
+    ):
+        assert submit._looks_secret(name) is True
+    for name in ("main.py", "requirements.txt", "environment.yml", "readme.md"):
+        assert submit._looks_secret(name) is False
+
+
 def test_build_tar_gz_bytes_bad_path(tmp_path: Path):
     bad = tmp_path / "does-not-exist"
     with pytest.raises(SystemExit) as e: