workpeg 0.1.0__tar.gz

workpeg-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2011-2025 The Bootstrap Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

workpeg-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: workpeg
+Version: 0.1.0
+Summary: Workpeg function runtime and SDK
+Author-email: Workpeg <support@workpeg.com>
+License: MIT
+Project-URL: Homepage, https://gitlab.com/workpeg/workpeg
+Project-URL: Repository, https://gitlab.com/workpeg/workpeg
+Keywords: workpeg,serverless,functions,runtime
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Workpeg SDK
+
+SDK for building **Workpeg Pegs and Functions**.
+
+Currently focused on:
+
+- `workpeg-runtime` – function execution runtime
+- `workpeg-new-function` – project scaffolding
+
+Frontend features, Peg integrations, push & deployment tooling are coming soon.
+
+---
+
+## Installation
+
+```bash
+pip install workpeg
+```
+
+---
+
+## Getting Started
+
+### 1. Create a New Function
+
+```bash
+workpeg-new-function my-peg
+cd my-peg
+```
+
+This generates:
+
+```
+my-peg/
+  app/
+    __init__.py
+    main.py
+  requirements.txt
+  Dockerfile
+```
+
+---
+
+### 2. Implement Your Function
+
+Edit `app/main.py`:
+
+```python
+def main(context, payload):
+    return payload
+```
+
+Every Workpeg Function must define:
+
+```python
+def main(context: dict, payload: dict) -> dict
+```
+
+- `context` → execution metadata (provided by Workpeg)
+- `payload` → input data
+- return value → must be JSON serializable
+
+---
+
+### 3. Run Locally
+
+```bash
+echo '{"context": {}, "payload": {"hello": "world"}}' | workpeg-runtime
+```
+
+Example output:
+
+```json
+{ "status": "success", "result": { "hello": "world" } }
+```
+
+---
+
+## Runtime
+
+`workpeg-runtime`:
+
+1. Reads JSON from STDIN
+2. Loads `app.main:main`
+3. Executes the function
+4. Writes structured JSON to STDOUT
+
+Override entrypoint:
+
+```bash
+FUNCTION_ENTRYPOINT="module.path:function_name" workpeg-runtime
+```
+
+---
+
+## Roadmap
+
+- Peg-level integrations
+- Frontend features (Streamlit/Reflex style)
+- Push & deployment tooling
+- Hosted execution
+
+---
+
+📘 Documentation coming soon.
+
+MIT License

workpeg-0.1.0/README.md

@@ -0,0 +1,107 @@
+# Workpeg SDK
+
+SDK for building **Workpeg Pegs and Functions**.
+
+Currently focused on:
+
+- `workpeg-runtime` – function execution runtime
+- `workpeg-new-function` – project scaffolding
+
+Frontend features, Peg integrations, push & deployment tooling are coming soon.
+
+---
+
+## Installation
+
+```bash
+pip install workpeg
+```
+
+---
+
+## Getting Started
+
+### 1. Create a New Function
+
+```bash
+workpeg-new-function my-peg
+cd my-peg
+```
+
+This generates:
+
+```
+my-peg/
+  app/
+    __init__.py
+    main.py
+  requirements.txt
+  Dockerfile
+```
+
+---
+
+### 2. Implement Your Function
+
+Edit `app/main.py`:
+
+```python
+def main(context, payload):
+    return payload
+```
+
+Every Workpeg Function must define:
+
+```python
+def main(context: dict, payload: dict) -> dict
+```
+
+- `context` → execution metadata (provided by Workpeg)
+- `payload` → input data
+- return value → must be JSON serializable
+
+---
+
+### 3. Run Locally
+
+```bash
+echo '{"context": {}, "payload": {"hello": "world"}}' | workpeg-runtime
+```
+
+Example output:
+
+```json
+{ "status": "success", "result": { "hello": "world" } }
+```
+
+---
+
+## Runtime
+
+`workpeg-runtime`:
+
+1. Reads JSON from STDIN
+2. Loads `app.main:main`
+3. Executes the function
+4. Writes structured JSON to STDOUT
+
+Override entrypoint:
+
+```bash
+FUNCTION_ENTRYPOINT="module.path:function_name" workpeg-runtime
+```
+
+---
+
+## Roadmap
+
+- Peg-level integrations
+- Frontend features (Streamlit/Reflex style)
+- Push & deployment tooling
+- Hosted execution
+
+---
+
+📘 Documentation coming soon.
+
+MIT License

workpeg-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "workpeg"
+version = "0.1.0"
+description = "Workpeg function runtime and SDK"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+  { name = "Workpeg", email = "support@workpeg.com" },
+]
+keywords = ["workpeg", "serverless", "functions", "runtime"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: POSIX :: Linux",
+]
+
+dependencies = [
+  # add any SDK runtime deps here, keep it minimal
+]
+
+[project.urls]
+Homepage = "https://gitlab.com/workpeg/workpeg"
+Repository = "https://gitlab.com/workpeg/workpeg"
+
+[project.scripts]
+# This creates the console script "workpeg-runtime"
+workpeg-runtime = "workpeg_sdk.runtime:main"
+workpeg-new-function = "workpeg_sdk.create_new:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.package-data]
+workpeg_sdk = ["templates/**"]
+
+
+[tool.setuptools.packages.find]
+where = ["src"]

workpeg-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

workpeg-0.1.0/src/workpeg.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: workpeg
+Version: 0.1.0
+Summary: Workpeg function runtime and SDK
+Author-email: Workpeg <support@workpeg.com>
+License: MIT
+Project-URL: Homepage, https://gitlab.com/workpeg/workpeg
+Project-URL: Repository, https://gitlab.com/workpeg/workpeg
+Keywords: workpeg,serverless,functions,runtime
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Workpeg SDK
+
+SDK for building **Workpeg Pegs and Functions**.
+
+Currently focused on:
+
+- `workpeg-runtime` – function execution runtime
+- `workpeg-new-function` – project scaffolding
+
+Frontend features, Peg integrations, push & deployment tooling are coming soon.
+
+---
+
+## Installation
+
+```bash
+pip install workpeg
+```
+
+---
+
+## Getting Started
+
+### 1. Create a New Function
+
+```bash
+workpeg-new-function my-peg
+cd my-peg
+```
+
+This generates:
+
+```
+my-peg/
+  app/
+    __init__.py
+    main.py
+  requirements.txt
+  Dockerfile
+```
+
+---
+
+### 2. Implement Your Function
+
+Edit `app/main.py`:
+
+```python
+def main(context, payload):
+    return payload
+```
+
+Every Workpeg Function must define:
+
+```python
+def main(context: dict, payload: dict) -> dict
+```
+
+- `context` → execution metadata (provided by Workpeg)
+- `payload` → input data
+- return value → must be JSON serializable
+
+---
+
+### 3. Run Locally
+
+```bash
+echo '{"context": {}, "payload": {"hello": "world"}}' | workpeg-runtime
+```
+
+Example output:
+
+```json
+{ "status": "success", "result": { "hello": "world" } }
+```
+
+---
+
+## Runtime
+
+`workpeg-runtime`:
+
+1. Reads JSON from STDIN
+2. Loads `app.main:main`
+3. Executes the function
+4. Writes structured JSON to STDOUT
+
+Override entrypoint:
+
+```bash
+FUNCTION_ENTRYPOINT="module.path:function_name" workpeg-runtime
+```
+
+---
+
+## Roadmap
+
+- Peg-level integrations
+- Frontend features (Streamlit/Reflex style)
+- Push & deployment tooling
+- Hosted execution
+
+---
+
+📘 Documentation coming soon.
+
+MIT License

workpeg-0.1.0/src/workpeg.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/workpeg.egg-info/PKG-INFO
+src/workpeg.egg-info/SOURCES.txt
+src/workpeg.egg-info/dependency_links.txt
+src/workpeg.egg-info/entry_points.txt
+src/workpeg.egg-info/top_level.txt
+src/workpeg_sdk/__init__.py
+src/workpeg_sdk/create_new.py
+src/workpeg_sdk/runtime.py
+src/workpeg_sdk/templates/__init__.py
+src/workpeg_sdk/templates/functions/Dockerfile
+src/workpeg_sdk/templates/functions/LICENSE
+src/workpeg_sdk/templates/functions/README.md
+src/workpeg_sdk/templates/functions/app/__init__.py
+src/workpeg_sdk/templates/functions/app/main.py
+tests/test_create_new.py
+tests/test_run_time.py

workpeg-0.1.0/src/workpeg.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

workpeg-0.1.0/src/workpeg.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+workpeg-new-function = workpeg_sdk.create_new:main
+workpeg-runtime = workpeg_sdk.runtime:main

workpeg-0.1.0/src/workpeg.egg-info/top_level.txt

@@ -0,0 +1 @@
+workpeg_sdk

workpeg-0.1.0/src/workpeg_sdk/__init__.py

@@ -0,0 +1,5 @@
+# src/workpeg_sdk/__init__.py
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

workpeg-0.1.0/src/workpeg_sdk/create_new.py

@@ -0,0 +1,86 @@
+# src/workpeg_sdk/create_new.py
+import argparse
+import os
+import shutil
+from pathlib import Path
+import importlib.resources as pkg_resources
+
+
+class TemplateError(Exception):
+    pass
+
+
+def _copy_tree(src_root: Path, dst_root: Path, *, force: bool) -> None:
+    """
+    Recursively copy src_root directory contents into dst_root.
+    """
+    if not src_root.exists():
+        raise TemplateError(f"Template root not found: {src_root}")
+
+    dst_root.mkdir(parents=True, exist_ok=True)
+
+    for item in src_root.rglob("*"):
+        rel = item.relative_to(src_root)
+        dst = dst_root / rel
+
+        if item.is_dir():
+            dst.mkdir(parents=True, exist_ok=True)
+            continue
+
+        if dst.exists() and not force:
+            raise TemplateError(f"Target file exists: {dst} (use --force)")
+
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(item, dst)
+
+
+def create_new_project(target_dir: str, *, force: bool = False) -> Path:
+    """
+    Copy the function template from workpeg_sdk/templates/functions/*
+    into target_dir.
+    """
+    target = Path(target_dir).expanduser().resolve()
+
+    # Get a Traversable pointing at .../workpeg_sdk/templates/functions
+    traversable = (
+        pkg_resources.files("workpeg_sdk") / "templates" / "functions"
+    )
+
+    # as_file() gives us a real filesystem path even if the package
+    # is loaded from a wheel/zip. This completely avoids the old
+    # "not available as a filesystem path" issue.
+    with pkg_resources.as_file(traversable) as src_path:
+        src_root = Path(src_path)
+        _copy_tree(src_root, target, force=force)
+
+    return target
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="workpeg-new-function",
+        description="Create a new Workpeg function"
+        " project from the built-in template.",
+    )
+    p.add_argument(
+        "path",
+        help="Target directory to create/populate (e.g. ./my-function).",
+    )
+    p.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite existing files in the target directory.",
+    )
+    return p
+
+
+def main() -> None:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    try:
+        out = create_new_project(args.path, force=args.force)
+        print(str(out))
+    except TemplateError as e:
+        print(f"ERROR: {e}", file=os.sys.stderr)
+        raise SystemExit(2)

workpeg-0.1.0/src/workpeg_sdk/runtime.py

@@ -0,0 +1,164 @@
+# src/workpeg_sdk/runtime.py
+
+import importlib
+import json
+import os
+import sys
+import traceback
+from typing import Any, Callable, Dict, Tuple
+
+
+DEFAULT_ENTRYPOINT = "app.main:main"
+
+
+class FunctionRuntimeError(Exception):
+    """Custom exception for runtime-level errors."""
+    pass
+
+
+def parse_entrypoint(entry: str) -> Tuple[str, str]:
+    """
+    Parse 'module.path:func_name' into (module, func).
+    """
+    try:
+        module_name, func_name = entry.split(":", 1)
+        module_name = module_name.strip()
+        func_name = func_name.strip()
+        if not module_name or not func_name:
+            raise ValueError
+        return module_name, func_name
+    except ValueError:
+        raise FunctionRuntimeError(
+            f"Invalid FUNCTION_ENTRYPOINT format: '{entry}'. "
+            "Expected 'module.path:func_name'."
+        )
+
+
+def _ensure_cwd_on_syspath() -> None:
+    """
+    Ensure current working directory is at the front of sys.path.
+
+    This is critical when running via a console script installed by pip,
+    because sys.path[0] is the script's directory (e.g. venv/bin),
+    NOT the current working directory.
+    """
+    cwd = os.getcwd()
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+
+def load_function() -> Callable[[Dict[str, Any], Dict[str, Any]], Any]:
+    """
+    Load the user function based on env FUNCTION_ENTRYPOINT or default.
+    """
+    _ensure_cwd_on_syspath()
+
+    entry = os.getenv("FUNCTION_ENTRYPOINT", DEFAULT_ENTRYPOINT)
+    module_name, func_name = parse_entrypoint(entry)
+
+    try:
+        module = importlib.import_module(module_name)
+    except Exception as exc:
+        raise FunctionRuntimeError(
+            f"Failed to import module '{module_name}' from '{entry}': {exc}"
+        ) from exc
+
+    try:
+        fn = getattr(module, func_name)
+    except AttributeError as exc:
+        raise FunctionRuntimeError(
+            f"Module '{module_name}'"
+            f" does not define '{func_name}' from '{entry}'."
+        ) from exc
+
+    if not callable(fn):
+        raise FunctionRuntimeError(
+            f"'{entry}' is not callable. Expected a function."
+        )
+
+    return fn
+
+
+def read_request() -> Dict[str, Any]:
+    """
+    Read a single JSON object from stdin.
+    Expected format: {"context": {...}, "payload": {...}}
+    """
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            raise FunctionRuntimeError("No input received on stdin.")
+        data = json.loads(raw)
+        if not isinstance(data, dict):
+            raise FunctionRuntimeError("Input JSON must be a JSON object.")
+        return data
+    except json.JSONDecodeError as exc:
+        raise FunctionRuntimeError(f"Invalid JSON input: {exc}") from exc
+
+
+def run_once() -> int:
+    """
+    Run a single invocation:
+      - load function
+      - read request
+      - call function
+      - emit JSON result
+
+    Returns exit code (0 on success, 1 on error).
+    """
+    try:
+        fn = load_function()
+        request = read_request()
+
+        context = request.get("context", {})
+        payload = request.get("payload", {})
+
+        if not isinstance(context, dict):
+            raise FunctionRuntimeError(
+                "Field 'context' must be a JSON object.")
+        if not isinstance(payload, dict):
+            raise FunctionRuntimeError(
+                "Field 'payload' must be a JSON object.")
+
+        result = fn(context, payload)
+
+        output = {
+            "status": "success",
+            "result": result,
+        }
+        print(json.dumps(output))
+        return 0
+
+    except FunctionRuntimeError as e:
+        # Runtime / wiring error
+        err_output = {
+            "status": "error",
+            "error_type": "runtime_error",
+            "error": str(e),
+        }
+        # Send JSON to stdout (for the host)
+        # and more detail to stderr (for logs)
+        print(json.dumps(err_output))
+        print(f"[workpeg-runtime] runtime_error: {e}", file=sys.stderr)
+        return 1
+
+    except Exception as e:
+        # User code error
+        trace = traceback.format_exc()
+        err_output = {
+            "status": "error",
+            "error_type": "user_error",
+            "error": str(e),
+            "trace": trace,
+        }
+        print(json.dumps(err_output))
+        print(f"[workpeg-runtime] user_error: {e}\n{trace}", file=sys.stderr)
+        return 1
+
+
+def main() -> None:
+    """
+    Console script entrypoint for 'workpeg-runtime'.
+    """
+    exit_code = run_once()
+    sys.exit(exit_code)

workpeg-0.1.0/src/workpeg_sdk/templates/functions/Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.12-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+RUN useradd -m -u 10001 appuser
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+COPY app /app/app
+
+USER appuser
+
+ENTRYPOINT ["workpeg-runtime"]

workpeg-0.1.0/src/workpeg_sdk/templates/functions/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2011-2025 The Bootstrap Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

workpeg-0.1.0/src/workpeg_sdk/templates/functions/README.md

@@ -0,0 +1,81 @@
+# Workpeg Function Project
+
+This directory was created using **Workpeg SDK**.
+
+It contains everything you need to build and run a single **Workpeg Function**, which can later be attached to a Peg inside Workpeg.
+
+---
+
+## Project Structure
+
+```text
+app/
+  __init__.py
+  main.py        # Your function: def main(context, payload) -> dict
+requirements.txt # Python dependencies (must include workpeg)
+Dockerfile       # Example container runtime using workpeg-runtime
+```
+
+---
+
+## Function Contract
+
+Your function **must** define:
+
+```python
+def main(context: dict, payload: dict) -> dict:
+    ...
+```
+
+- `context` – execution metadata injected by Workpeg (user, peg, execution id, etc.)
+- `payload` – input data sent by the caller
+- return value – must be JSON serializable
+
+By default, the runtime looks for `app.main:main`.
+You can change this using the `FUNCTION_ENTRYPOINT` environment variable:
+
+```bash
+export FUNCTION_ENTRYPOINT="module.path:function_name"
+```
+
+---
+
+## Running Locally
+
+Make sure `workpeg` is installed (or use the generated `requirements.txt`):
+
+```bash
+pip install -r requirements.txt
+```
+
+Then run the function:
+
+```bash
+echo '{"context": {}, "payload": {"hello": "world"}}' | workpeg-runtime
+```
+
+Expected output:
+
+```json
+{ "status": "success", "result": { "hello": "world" } }
+```
+
+---
+
+## Docker (Optional)
+
+You can build and run the container using the included `Dockerfile`:
+
+```bash
+docker build -t my-workpeg-function .
+echo '{"context": {}, "payload": {"hello": "world"}}' | docker run --rm -i my-workpeg-function
+```
+
+---
+
+## More
+
+This template is part of the official Workpeg SDK.
+
+Repo: [https://gitlab.com/workpeg/workpeg](https://gitlab.com/workpeg/workpeg)
+Full documentation and Peg integration guides are coming soon.

workpeg-0.1.0/src/workpeg_sdk/templates/functions/app/main.py

@@ -0,0 +1,2 @@
+def main(context, payload):
+    return payload

workpeg-0.1.0/tests/test_create_new.py

@@ -0,0 +1,66 @@
+import subprocess
+import importlib.resources as pkg_resources
+
+
+def test_create_new_copies_template(tmp_path):
+    project_dir = tmp_path / "my-func"
+
+    # Run the console script
+    result = subprocess.run(
+        ["workpeg-new-function", str(project_dir)],
+        text=True,
+        capture_output=True,
+        cwd=tmp_path,
+    )
+
+    assert result.returncode == 0
+    assert project_dir.exists()
+
+    # Confirm expected files exist
+    assert (project_dir / "app" / "__init__.py").exists()
+    assert (project_dir / "app" / "main.py").exists()
+
+    # Confirm main.py content matches template main.py
+    template_pkg = "workpeg_sdk.templates.functions.app"
+    template_main = pkg_resources.files(
+        template_pkg).joinpath("main.py").read_text()
+
+    created_main = (project_dir / "app" / "main.py").read_text()
+    assert created_main == template_main
+
+
+def test_create_new_refuses_overwrite_without_force(tmp_path):
+    project_dir = tmp_path / "my-func"
+    project_dir.mkdir()
+    (project_dir / "app").mkdir()
+    (project_dir / "app" / "main.py").write_text("existing")
+
+    result = subprocess.run(
+        ["workpeg-new-function", str(project_dir)],
+        text=True,
+        capture_output=True,
+        cwd=tmp_path,
+    )
+
+    assert result.returncode == 2
+    assert "use --force" in (result.stderr or "")
+
+
+def test_create_new_overwrites_with_force(tmp_path):
+    project_dir = tmp_path / "my-func"
+    project_dir.mkdir(parents=True)
+    (project_dir / "app").mkdir()
+    (project_dir / "app" / "main.py").write_text("existing")
+
+    result = subprocess.run(
+        ["workpeg-new-function", str(project_dir), "--force"],
+        text=True,
+        capture_output=True,
+        cwd=tmp_path,
+    )
+
+    assert result.returncode == 0
+
+    # Ensure template main.py replaced the old content
+    created_main = (project_dir / "app" / "main.py").read_text()
+    assert created_main != "existing"

workpeg-0.1.0/tests/test_run_time.py

@@ -0,0 +1,305 @@
+# tests/test_run_time.py
+
+import importlib.resources as pkg_resources
+import subprocess
+import io
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+from workpeg_sdk.runtime import (
+    FunctionRuntimeError,
+    parse_entrypoint,
+    load_function,
+    read_request,
+    run_once,
+)
+
+
+# ------------------------------
+# Helpers
+# ------------------------------
+
+def _clear_app_modules():
+    """Remove any cached 'app' modules so imports see the new temp package."""
+    to_delete = [name for name in sys.modules if name ==
+                 "app" or name.startswith("app.")]
+    for name in to_delete:
+        del sys.modules[name]
+
+
+def _write_simple_app(tmp_path: Path, body: str | None = None):
+    """
+    Create app/main.py in tmp_path.
+    Default main just returns payload.
+    """
+    if body is None:
+        body = """
+def main(context, payload):
+    return payload
+"""
+
+    app_dir = tmp_path / "app"
+    app_dir.mkdir()
+    (app_dir / "__init__.py").write_text("")
+    (app_dir / "main.py").write_text(body)
+
+
+# ------------------------------
+# parse_entrypoint tests
+# ------------------------------
+
+def test_parse_entrypoint_valid():
+    module, func = parse_entrypoint("my.module:handler")
+    assert module == "my.module"
+    assert func == "handler"
+
+
+def test_parse_entrypoint_invalid_raises():
+    with pytest.raises(FunctionRuntimeError):
+        parse_entrypoint("no-colon")
+    with pytest.raises(FunctionRuntimeError):
+        parse_entrypoint(":missing_module")
+    with pytest.raises(FunctionRuntimeError):
+        parse_entrypoint("missing_func:")
+
+
+# ------------------------------
+# load_function tests
+# ------------------------------
+
+def test_load_function_uses_default_entrypoint(tmp_path, monkeypatch):
+    """
+    Ensure load_function() imports app.main:main
+    from the current working directory.
+    """
+    _clear_app_modules()
+    _write_simple_app(tmp_path)
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("FUNCTION_ENTRYPOINT", raising=False)
+
+    fn = load_function()
+    assert callable(fn)
+    result = fn({"ctx": True}, {"hello": "world"})
+    # main just returns payload
+    assert result == {"hello": "world"}
+
+
+def test_load_function_invalid_module_raises(monkeypatch):
+    _clear_app_modules()
+    monkeypatch.setenv("FUNCTION_ENTRYPOINT", "nonexistent.module:main")
+
+    with pytest.raises(FunctionRuntimeError) as exc:
+        load_function()
+    assert "Failed to import module" in str(exc.value)
+
+
+def test_load_function_invalid_attribute_raises(tmp_path, monkeypatch):
+    """
+    Module exists, but function attribute does not.
+    """
+    _clear_app_modules()
+
+    mod_dir = tmp_path / "app"
+    mod_dir.mkdir()
+    (mod_dir / "__init__.py").write_text("")
+    (mod_dir / "main.py").write_text(
+        """
+FOO = 123
+"""
+    )
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FUNCTION_ENTRYPOINT", "app.main:missing_fn")
+
+    with pytest.raises(FunctionRuntimeError) as exc:
+        load_function()
+    assert "does not define 'missing_fn'" in str(exc.value)
+
+
+def test_load_function_not_callable_raises(tmp_path, monkeypatch):
+    """
+    Attribute exists but is not callable.
+    """
+    _clear_app_modules()
+
+    mod_dir = tmp_path / "app"
+    mod_dir.mkdir()
+    (mod_dir / "__init__.py").write_text("")
+    (mod_dir / "main.py").write_text(
+        """
+main = 123  # not callable
+"""
+    )
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("FUNCTION_ENTRYPOINT", raising=False)
+
+    with pytest.raises(FunctionRuntimeError) as exc:
+        load_function()
+    assert "is not callable" in str(exc.value)
+
+
+# ------------------------------
+# read_request tests
+# ------------------------------
+
+def test_read_request_valid(monkeypatch):
+    payload = {"context": {"a": 1}, "payload": {"b": 2}}
+    stdin = io.StringIO(json.dumps(payload))
+    monkeypatch.setattr(sys, "stdin", stdin)
+
+    result = read_request()
+    assert result == payload
+
+
+def test_read_request_empty_raises(monkeypatch):
+    monkeypatch.setattr(sys, "stdin", io.StringIO(""))
+    with pytest.raises(FunctionRuntimeError) as exc:
+        read_request()
+    assert "No input received on stdin" in str(exc.value)
+
+
+def test_read_request_invalid_json_raises(monkeypatch):
+    monkeypatch.setattr(sys, "stdin", io.StringIO("{not-json}"))
+    with pytest.raises(FunctionRuntimeError) as exc:
+        read_request()
+    assert "Invalid JSON input" in str(exc.value)
+
+
+# ------------------------------
+# run_once tests
+# ------------------------------
+
+def test_run_once_success(tmp_path, monkeypatch, capsys):
+    """
+    Full path: load_function + read_request + user main() succeed.
+    """
+    _clear_app_modules()
+    _write_simple_app(tmp_path)
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("FUNCTION_ENTRYPOINT", raising=False)
+
+    input_data = {"context": {"user": 1}, "payload": {"x": 10}}
+    monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps(input_data)))
+
+    exit_code = run_once()
+    captured = capsys.readouterr()
+
+    assert exit_code == 0
+    stdout_json = json.loads(captured.out)
+    assert stdout_json["status"] == "success"
+    # main returns payload unchanged
+    assert stdout_json["result"] == input_data["payload"]
+    assert "[workpeg-runtime]" not in captured.err
+
+
+def test_run_once_runtime_error_invalid_context(tmp_path, monkeypatch, capsys):
+    """
+    If 'context' is not a dict, run_once should emit a runtime_error.
+    """
+    _clear_app_modules()
+    _write_simple_app(tmp_path)
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("FUNCTION_ENTRYPOINT", raising=False)
+
+    # context is a string, not an object
+    input_data = {"context": "not-a-dict", "payload": {"x": 10}}
+    monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps(input_data)))
+
+    exit_code = run_once()
+    captured = capsys.readouterr()
+
+    assert exit_code == 1
+
+    stdout_json = json.loads(captured.out)
+    assert stdout_json["status"] == "error"
+    assert stdout_json["error_type"] == "runtime_error"
+    assert "context' must be a JSON object" in stdout_json["error"]
+
+    assert "[workpeg-runtime] runtime_error" in captured.err
+
+
+def test_run_once_user_error_from_function(tmp_path, monkeypatch, capsys):
+    """
+    If user function raises, run_once should emit user_error.
+    """
+    _clear_app_modules()
+
+    # main will raise ValueError
+    _write_simple_app(
+        tmp_path,
+        body="""
+def main(context, payload):
+    raise ValueError("boom")
+""",
+    )
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("FUNCTION_ENTRYPOINT", raising=False)
+
+    input_data = {"context": {}, "payload": {"x": 1}}
+    monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps(input_data)))
+
+    exit_code = run_once()
+    captured = capsys.readouterr()
+
+    assert exit_code == 1
+
+    stdout_json = json.loads(captured.out)
+    assert stdout_json["status"] == "error"
+    assert stdout_json["error_type"] == "user_error"
+    assert "boom" in stdout_json["error"]
+    assert "trace" in stdout_json
+    assert "ValueError" in stdout_json["trace"]
+
+    assert "[workpeg-runtime] user_error" in captured.err
+
+
+def test_workpeg_runtime_template(tmp_path):
+    """
+    Test using SDK template function copied from package templates.
+    """
+
+    # --- 1. Create app directory ---
+    app_dir = tmp_path / "app"
+    app_dir.mkdir()
+
+    # Make it a package
+    (app_dir / "__init__.py").write_text("")
+
+    # --- 2. Load template from installed package ---
+    template_pkg = "workpeg_sdk.templates.functions.app"
+
+    with pkg_resources.files(template_pkg).joinpath("main.py").open("r") as f:
+        template_code = f.read()
+
+    # --- 3. Write template main.py into temp app ---
+    (app_dir / "main.py").write_text(template_code)
+
+    # --- 4. Prepare input ---
+    input_payload = {
+        "context": {"user_id": 123},
+        "payload": {"hello": "world", "x": 42},
+    }
+
+    # --- 5. Run CLI ---
+    result = subprocess.run(
+        ["workpeg-runtime"],
+        input=json.dumps(input_payload),
+        text=True,
+        capture_output=True,
+        cwd=tmp_path,
+    )
+
+    assert result.returncode == 0
+
+    output = json.loads(result.stdout)
+
+    assert output["status"] == "success"
+    assert output["result"] == input_payload["payload"]