@synopackageland/templates 0.9.8 → 0.10.0

package/templates/native-node-vue/README.md

@@ -0,0 +1,56 @@
+# Native Node.js with Vue
+
+The Vue shell is the same as the Go template's. Edit `frontend/src/App.vue`
+and `main.ts` to build a DSM-window app with the public `@synopackageland/ui`
+components and embedded theme. The shell, sign-in, files, portal, jobs and
+delegate components come from `@synopackageland/sdk/vue` (types from
+`@synopackageland/sdk`); its version must equal the `backend.sdk` in dsm-package.yaml. See
+<https://github.com/synopackageland/syno-pkg-land-sdk> for the components and their props.
+
+```sh
+cd frontend
+npm ci
+npm test
+npm run build
+```
+
+The base app reads package status and edits the package greeting through
+`ctx.call`. Errors show the app's own `frontend/src/i18n` text, or the SDK's
+`bridgeErrorCopy` for the codes the bridge runtime adds (`app_unavailable`
+and the services' refusals). Each window has its own Vue mount, request state
+and host subscriptions; unmount disposes subscriptions and ignores late responses.
+
+The `--with jobs`, `root-ops` and `delegate` examples add their methods to
+the Node.js App; the shell's panels call them with `ctx.call`. The SDK's
+background-jobs page and executor settings call the runtime's own browser
+methods (`bg.*`, `executor.*`); check the SDK release notes for the ones a
+bridge App's runtime serves.
+
+Use the installed `@synopackageland/ui`; package.json pins its version.
+`App.vue` lays the shell out with the SDK's `AppShell` (`@synopackageland/sdk/vue`):
+`pages` from `shellPages`, the header buttons in `#actions` and the pages in its
+default slot. Given `ctx`, it follows the launch. In a DSM desktop window it
+keeps `wide-layout="window"`, even maximized; the DSM host sets the 700px
+minimum window width. A Portal or standalone launch owns the whole page
+(`ctx.fullPage`, from the generated window): `AppShell` takes
+`wide-layout="web"` (the SaaS layout at 1200px or wider, mobile on a phone) and
+a device-width viewport, undone at unmount, since DSM's page has no
+device-width viewport. Its full-page sidebar names the App with
+`ctx.displayName` and `ctx.appIcon` (without them the page title and icon) and
+shows the signed-in DSM account and its role from `ctx.user`. See the ui's
+`docs/adaptive-layout.md`.
+`AppShell`'s `app-root` wraps it in an app-local `AppRoot` (app modal scope, on
+a full page as well, bounded at `height: 100%`) with the UI locale from
+`locale`; do not add another `AppRoot`.
+In a DSM window (not a full page) that `AppRoot` takes
+`dialog-bounds="viewport"`, so Dialogs can be dragged out of the window, and
+pressing one calls `ctx.host.activateWindow()` to bring the window to the
+front. Elsewhere Dialogs stay inside the App. A confirmed sign-in need sets
+`denied`: the `#denied` slot's `LoginPage` takes the place of the App's pages.
+Import `themes/dsm7-embedded.css` and assign each mount a unique
+`app.config.idPrefix` before mounting.
+
+Start with AGENTS.md, `synopkgland skill list` and `synopkgland skill path`.
+Read `synopkgland skill show ui-vue` for direct Vue component work. For UI
+discovery, run `npx --no syno-pkg-land-ui catalog --json` and
+`npx --no syno-pkg-land-ui describe Button --json` from the installed frontend.

package/templates/native-node-vue/gitignore

@@ -0,0 +1,4 @@
+dist/
+node_modules/
+backend/build/
+backend/app/*.js

package/templates/native-python/README.md

@@ -0,0 +1,150 @@
+# __DISPLAY_NAME__
+
+A native DSM package (`__PACKAGE__`): a Python App behind the SDK's runtime,
+and a UI that opens in its own DSM window. It installs as an **unsigned** SPK,
+runs as its own DSM package account, needs no containers, and has no root by default.
+
+```text
+DSM main menu → DSM window (ui/app.js)
+                   │  ctx.call("greeting.get")  same-origin POST + DSM session
+                   ▼
+   /webman/3rdparty/__PACKAGE__/cgi/api.cgi   (the SDK runtime, runs as package user)
+      1. transport guards: POST, JSON, same origin, ≤ 1 MiB, bounded JSON complexity
+      2. one DSM authentication, the entry gate and app/permissions.json
+      3. DSM's own Python 3 (3.8 or later) runs `backend/app/main.py` once per call
+      4. your method, which may ask the runtime for services (files, jobs, executor)
+```
+
+## Quick start
+
+Needs Node.js with `synopkgland` installed, and Python 3.8 or later.
+
+```bash
+(cd backend && python3 -m unittest discover -s tests)   # method tests
+synopkgland build           # → dist/__PACKAGE__-0.1.0-0001-{x86_64,aarch64}.spk
+synopkgland inspect dist/__PACKAGE__-0.1.0-0001-x86_64.spk
+```
+
+Install: Package Center → Settings → General → Trust Level "Any publisher",
+then Manual Install with the SPK for your NAS's CPU. Open
+**__DISPLAY_NAME__** from the DSM main menu: it shows who you are signed in
+as, what the backend reports, and (for administrators) a form that stores a
+greeting in the package's data folder.
+
+## Project layout
+
+| Path | What it is | Edit it? |
+| --- | --- | --- |
+| `dsm-package.yaml` | Package identity, version/build, arches, where backend and UI come from | Yes |
+| `ui/app.js`, `ui/app.css` | The app inside the DSM window | Yes — your UI |
+| `i18n/messages/<locale>.json` | UI text in nine languages | Yes |
+| `i18n/glossary.json` | DSM's own UI terms, and which messages must use them | Add terms |
+| `backend/app/routes.py` | Your methods: `build` registers them | Yes — your backend |
+| `backend/app/jobs.py`, `root_ops.py`, `delegate.py` | Capability examples (stubs unless `init --with` added them) | Yes |
+| `backend/app/permissions.json` | Who may call each of your methods | Yes |
+| `backend/app/main.py` | Runs the App on the runtime's channel | Rarely |
+| `backend/tests/` | unittest tests; `support.call` plays the runtime | Yes |
+| `backend/vendor/synopkgland_app` | The Python SDK for tests, copied by `synopkgland init` from the SDK release; the build ships its own copy of the release `backend.sdk` names | No |
+| `dist/` | Built SPKs (ignored by git) | No |
+
+`build` generates everything else: `INFO`, `conf/privilege`
+(`run-as: package`), lifecycle scripts, icons, the DSM window wrapper and the
+runtime CGI at `ui/cgi/api.cgi`.
+
+## Add a method
+
+Register it in `build`. Every method defaults to DSM administrator membership;
+all access rules live in `backend/app/permissions.json`:
+
+```python
+def build(cfg):
+    app = App()
+    ...
+    app.method("notes.list")(lambda ctx, params: list_notes(cfg, ctx, params))  # new: administrators by default
+    return app
+
+
+def list_notes(cfg, ctx, params):
+    p = fields(params, folder=str)  # anything else is bad_request
+    return {"owner": ctx.user, "notes": []}
+```
+
+Add a test to `backend/tests/` with `support.call(app, "notes.list", {"folder": "work"}, services={...})`. Call it from the UI with `ctx.call("notes.list", { folder: "work" })`.
+
+Raise `Error(code, message)` (or `Error.bad_request(message)`) for an error the browser may see; any other exception is `internal`, with the traceback in the package's log. A refusal from `ctx.runtime` is an `Error` too, so the browser sees the runtime's code.
+
+The runtime refuses before your App runs: `session_required`, `admin_required`,
+`unknown_method`, `request_timeout` and the transport guards' codes. The UI
+shows `error.<code>` from its catalogs.
+
+### Who can call what
+
+The shipped policy is:
+
+```json
+{"schema": 1, "default": "administrators", "methods": {}}
+```
+
+The default must remain `administrators`. An intentional exception belongs in
+`methods`, for example `"notes.list": "authenticated"`; `"public"` explicitly
+allows anonymous calls. Such exceptions also enable ordinary-user launcher
+access.
+
+| JSON rule | No session | Ordinary user | Administrators group member |
+| --- | --- | --- | --- |
+| absent or `administrators` | `session_required` | `admin_required` | runs |
+| explicit `authenticated` | `session_required` | runs | runs |
+| explicit `public` | runs | runs | runs |
+| method the App does not register | `session_required` | `unknown_method` | `unknown_method` |
+
+Missing or invalid JSON, duplicate keys, unknown permissions and rules for
+methods the App does not register fail closed. Changing policy requires
+rebuilding the SPK.
+
+## Capabilities
+
+`synopkgland init --with` adds examples that use the runtime's services through
+`ctx.runtime`; each comes with its tests:
+
+| `--with` | Methods | Runtime services |
+| --- | --- | --- |
+| `jobs` | `hash.submit`, `hash.get`, `hash.cancel` | `files.read` with the caller's session, `bg.submit`, `bg.get`, `bg.cancel` |
+| `root-ops` | `whoami.run` | `root.run` of `root/whoami.sh`, once an administrator approves the executor |
+| `delegate` | `report.save` | `delegate.move_from_staging` into a folder the caller chose |
+
+A service refuses with its own code (`limit_exceeded`, `read_failed`, the
+executor's refusals); the examples pass it on to the browser. `synopkgland add`
+works on Go backends only: start a Python App with the capabilities it needs.
+
+## The SDK
+
+`backend.sdk` in dsm-package.yaml names the SDK release: the build ships its runtime and its Python SDK as `backend/app/vendor/synopkgland_app`, and reads the method list from `main.py --describe`. `backend/vendor/synopkgland_app` is the same SDK for tests; replace it with the new release's when you change `backend.sdk`. Upgrade the SDK by changing that version; `synopkgland check`
+refuses versions this CLI does not support. The bridge protocol, the services
+and their codes are documented in the SDK repository:
+<https://github.com/synopackageland/syno-pkg-land-sdk> (`spec/bridge/v1`).
+
+## UI and languages
+
+The UI is the same as the Go template's. `ui/app.js` registers
+`window.DsmPackageApps[<package>].mount(root, ctx)`; `ctx.call(method, params)`
+is the only transport and `ctx.t(key, values)` reads
+`i18n/messages/<locale>.json` (`en`, `zh-TW`, `zh-CN`, `ja`, `ko`, `de`,
+`fr`, `es`, `it`). Add `error.<code>` for every code your methods return.
+`synopkgland check` and `build` refuse a language file with missing or extra
+keys, a dropped `{placeholder}` or a listed message that drifts from the
+glossary. `--ui vue` gives the Vue shell in `frontend/` instead.
+
+## Data, upgrades, uninstall
+
+The App stores data in `/var/packages/__PACKAGE__/var` (`SYNOPKGLAND_DATA_DIR`,
+kept across upgrades). Bump `build` for every SPK you hand out and `version`
+for feature releases. Uninstalling keeps the data unless the administrator
+ticks **Also delete the app data listed above** in the uninstall wizard.
+
+## Support matrix
+
+| | Status |
+| --- | --- |
+| Build hosts | macOS, Linux |
+| Target CPUs | x86_64 and aarch64 DSM models (one SPK each); armv7 is opt-in in `arches`, built but not NAS-verified |
+| DSM | 7.1 or later declared (`os_min_ver`) |

package/templates/native-python/backend/app/delegate.py

@@ -0,0 +1,5 @@
+"""Saves to a user's destination: `synopkgland init --with delegate` replaces this stub with an example."""
+
+
+def register(app, cfg):
+    pass

package/templates/native-python/backend/app/jobs.py

@@ -0,0 +1,5 @@
+"""Background jobs: `synopkgland init --with jobs` replaces this stub with an example."""
+
+
+def register(app, cfg):
+    pass

package/templates/native-python/backend/app/main.py

@@ -0,0 +1,5 @@
+"""The App: the runtime starts it once per call (spec/bridge/v1)."""
+
+import routes
+
+routes.build(routes.Config.from_env()).run()

package/templates/native-python/backend/app/params.py

@@ -0,0 +1,10 @@
+"""Request params, checked strictly: the browser sends what it likes."""
+
+from synopkgland_app import Error
+
+
+def fields(params, **types):
+    """params as an object with exactly these fields of these types, else bad_request."""
+    if not isinstance(params, dict) or set(params) != set(types) or not all(isinstance(params[k], t) for k, t in types.items()):
+        raise Error.bad_request("params must be {%s}" % ", ".join(sorted(types)))
+    return params

package/templates/native-python/backend/app/permissions.json

@@ -0,0 +1,5 @@
+{
+  "schema": 1,
+  "default": "administrators",
+  "methods": {}
+}

package/templates/native-python/backend/app/root_ops.py

@@ -0,0 +1,5 @@
+"""Root operations: `synopkgland init --with root-ops` replaces this stub with an example."""
+
+
+def register(app, cfg):
+    pass

package/templates/native-python/backend/app/routes.py

@@ -0,0 +1,107 @@
+"""The App's methods. Register a method in build() and give it a rule in
+permissions.json unless only administrators may call it: the runtime has
+checked the DSM session, the entry gate and that rule before a handler runs.
+"""
+
+import json
+import os
+import platform
+import sys
+import tempfile
+import time
+
+from synopkgland_app import App, Error
+
+import delegate
+import jobs
+import root_ops
+from params import fields
+
+
+class Config:
+    """Where the App's state lives; the runtime sets the environment."""
+
+    def __init__(self, package, data_dir, packages_root="/var/packages"):
+        self.package = package
+        # The package's own data directory (/var/packages/<package>/var), kept across upgrades.
+        self.data_dir = data_dir
+        self.packages_root = packages_root
+
+    @classmethod
+    def from_env(cls):
+        return cls(os.environ.get("SYNOPKGLAND_PACKAGE", ""), os.environ.get("SYNOPKGLAND_DATA_DIR", ""))
+
+
+def build(cfg):
+    app = App()
+    app.method("app.status")(lambda ctx, params: status(cfg, ctx))
+    app.method("greeting.get")(lambda ctx, params: get_greeting(cfg))
+    app.method("greeting.set")(lambda ctx, params: set_greeting(cfg, ctx, params))
+    # Each capability module is a stub until `synopkgland init --with` adds its example.
+    for capability in (jobs, root_ops, delegate):
+        capability.register(app, cfg)
+    return app
+
+
+def status(cfg, ctx):
+    result = {
+        "package": cfg.package,
+        "version": installed_version(cfg),
+        "user": ctx.user,
+        "admin": ctx.admin,
+        "process": {"uid": os.getuid(), "gid": os.getgid()},
+        "language": "Python " + platform.python_version(),
+        "platform": sys.platform + "/" + platform.machine(),
+        "time": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+    }
+    try:
+        # Served only when dsm-package.yaml declares a portal.
+        result["portal"] = ctx.runtime("portal.status")
+    except Error:
+        pass
+    return result
+
+
+def installed_version(cfg):
+    """The version in the package's INFO, or "" outside DSM."""
+    try:
+        with open(os.path.join(cfg.packages_root, cfg.package, "INFO"), encoding="utf-8") as info:
+            for line in info:
+                if line.startswith("version="):
+                    return line[len("version=") :].strip().strip('"')
+    except OSError:
+        pass
+    return ""
+
+
+def greeting_path(cfg):
+    return os.path.join(cfg.data_dir, "greeting.json")
+
+
+def get_greeting(cfg):
+    try:
+        with open(greeting_path(cfg), encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return {"text": "Hello"}
+
+
+def set_greeting(cfg, ctx, params):
+    text = fields(params, text=str)["text"]
+    if not 1 <= len(text) <= 200:
+        raise Error.bad_request("text must be 1 to 200 characters")
+    greeting = {"text": text, "updated_by": ctx.user}
+    write_file_atomic(greeting_path(cfg), json.dumps(greeting).encode())
+    return greeting
+
+
+def write_file_atomic(path, data):
+    """Replace path in one rename, so readers never see half a file."""
+    fd, tmp = tempfile.mkstemp(dir=os.path.dirname(path), prefix=".tmp-")
+    try:
+        with os.fdopen(fd, "wb") as f:
+            f.write(data)
+        os.replace(tmp, path)
+    except BaseException:
+        os.unlink(tmp)
+        raise

package/templates/native-python/backend/tests/support.py

@@ -0,0 +1,72 @@
+"""Calls an App method the way the runtime does: over a channel, with the
+hello, the call, the services the method asks for and its result."""
+
+import json
+import os
+import sys
+import threading
+
+_backend = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+# The App's own directory, and the SDK the runtime ships in the App's vendor/.
+sys.path[:0] = [os.path.join(_backend, "app"), os.path.join(_backend, "vendor")]
+
+from synopkgland_app import Error  # noqa: E402
+
+
+class Reply:
+    """A call's result frame, and the services the method asked for in order."""
+
+    def __init__(self, frame, services):
+        self.ok = frame["ok"]
+        self.data = frame.get("data")
+        self.error = frame.get("error")
+        self.services = services
+
+
+def call(app, method, params=None, user="admin", admin=True, services=None):
+    """Answer one call of method; services maps an op to fn(params), which
+    returns the result or raises Error. An op it lacks is unknown_service."""
+    services = services or {}
+    to_app, app_in = os.pipe()
+    app_out, from_app = os.pipe()
+    rfile, wfile = os.fdopen(to_app, "rb"), os.fdopen(from_app, "wb")
+
+    def serve():
+        try:
+            app.serve(rfile, wfile)
+        finally:
+            wfile.close()
+
+    thread = threading.Thread(target=serve, daemon=True)
+    thread.start()
+    out, inp = os.fdopen(app_in, "wb"), os.fdopen(app_out, "rb")
+    send = lambda frame: (out.write(json.dumps(frame).encode() + b"\n"), out.flush())
+    send({"t": "hello", "versions": [1]})
+    inp.readline()
+    ctx = {"user": user, "admin": admin, "locale": "en", "request_id": "0" * 32, "deadline_ms": 30000}
+    send({"t": "call", "id": "1", "method": method, "params": params, "ctx": ctx})
+    asked = []
+    try:
+        for line in inp:
+            frame = json.loads(line)
+            if frame["t"] == "result":
+                return Reply(frame, asked)
+            asked.append((frame["op"], frame["params"]))
+            send(_answer(services, frame))
+        raise AssertionError("the App ended the channel without a result")
+    finally:
+        out.close()
+        thread.join(5)
+        rfile.close()
+        inp.close()
+
+
+def _answer(services, frame):
+    reply = {"t": "svc_result", "id": frame["id"]}
+    service = services.get(frame["op"])
+    try:
+        if service is None:
+            raise Error("unknown_service", "no service " + frame["op"])
+        return dict(reply, ok=True, result=service(frame["params"]))
+    except Error as e:
+        return dict(reply, ok=False, error={"code": e.code, "message": e.message})

package/templates/native-python/backend/tests/test_routes.py

@@ -0,0 +1,73 @@
+import json
+import os
+import tempfile
+import unittest
+
+from support import call
+
+import routes
+
+
+class RoutesTest(unittest.TestCase):
+    def setUp(self):
+        self.dir = tempfile.TemporaryDirectory()
+        self.addCleanup(self.dir.cleanup)
+        root = self.dir.name
+        self.data = os.path.join(root, "var")
+        os.mkdir(self.data)
+        self.cfg = routes.Config("ExampleApp", self.data, packages_root=os.path.join(root, "packages"))
+        self.app = routes.build(self.cfg)
+
+    def write_info(self, text):
+        os.makedirs(os.path.join(self.cfg.packages_root, "ExampleApp"))
+        with open(os.path.join(self.cfg.packages_root, "ExampleApp", "INFO"), "w") as f:
+            f.write(text)
+
+    def test_status_reports_the_caller_and_the_installed_version(self):
+        self.write_info('package="ExampleApp"\nversion="0.1.0-0001"\n')
+        reply = call(self.app, "app.status", user="alice", admin=False)
+        self.assertTrue(reply.ok, reply.error)
+        status = reply.data
+        self.assertEqual((status["package"], status["version"]), ("ExampleApp", "0.1.0-0001"))
+        self.assertEqual((status["user"], status["admin"]), ("alice", False))
+        self.assertEqual(status["process"], {"uid": os.getuid(), "gid": os.getgid()})
+        self.assertTrue(status["language"].startswith("Python 3."), status["language"])
+        self.assertRegex(status["platform"], r"^\w+/\w+$")
+        self.assertRegex(status["time"], r"^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ$")
+
+    def test_status_without_info_has_no_version(self):
+        self.assertEqual(call(self.app, "app.status").data["version"], "")
+
+    def test_status_shows_the_portal_when_the_runtime_offers_it(self):
+        portal = {"enabled": True, "alias": "example"}
+        reply = call(self.app, "app.status", services={"portal.status": lambda params: portal})
+        self.assertEqual(reply.data["portal"], portal)
+        self.assertEqual(reply.services, [("portal.status", None)])
+
+    def test_status_without_a_portal_leaves_it_out(self):
+        reply = call(self.app, "app.status")
+        self.assertTrue(reply.ok, reply.error)
+        self.assertNotIn("portal", reply.data)
+
+    def test_greeting_defaults_to_hello(self):
+        self.assertEqual(call(self.app, "greeting.get").data, {"text": "Hello"})
+
+    def test_greeting_set_stores_the_text_and_who_set_it(self):
+        reply = call(self.app, "greeting.set", {"text": "Hi 👋"}, user="alice")
+        self.assertEqual(reply.data, {"text": "Hi 👋", "updated_by": "alice"})
+        self.assertEqual(call(self.app, "greeting.get").data, {"text": "Hi 👋", "updated_by": "alice"})
+        self.assertEqual(os.listdir(self.data), ["greeting.json"])
+
+    def test_greeting_counts_characters_not_bytes(self):
+        self.assertTrue(call(self.app, "greeting.set", {"text": "é" * 200}).ok)
+
+    def test_greeting_set_refuses_invalid_params_and_keeps_the_old_text(self):
+        for params in [None, [], {}, {"text": ""}, {"text": "x" * 201}, {"text": 5}, {"text": "hi", "extra": 1}]:
+            with self.subTest(params=params):
+                reply = call(self.app, "greeting.set", params)
+                self.assertEqual(reply.error["code"], "bad_request")
+        self.assertEqual(os.listdir(self.data), [])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/templates/native-python/dsm-package.yaml

@@ -0,0 +1,77 @@
+# Standalone native DSM package: an unsigned SPK that runs as its own package
+# `synopkgland build` reads this file.
+schema: 2
+
+# INFO.package: letters and digits, starting with a letter. It also names the
+# DSM app (SYNO.SDS.<package>) and the CGI URL /webman/3rdparty/<package>/.
+package: __PACKAGE__
+version: 0.1.0
+# Increase for every SPK you hand out with the same version (INFO 0.1.0-0001).
+build: 1
+displayname: __DISPLAY_NAME__
+description: A native DSM package with a Python backend and a DSM window UI.
+# Package Center and DSM window icon: a square PNG of at least 256x256, or a
+# folder of icon_<size>.png. Omit to use the SDK default icon.
+# icon: assets/icon.png
+maintainer: Your Name
+# Optional INFO/website metadata. Omit fields you do not need.
+# metadata:
+#   contact_email: you@example.com
+#   support_email: support@example.com
+#   homepage: https://example.com
+#   source_url: https://github.com/you/your-app
+#   issues_url: https://github.com/you/your-app/issues
+#   license: MIT
+#   long_description:
+#     en: |-
+#       Explain what the app does and how to use it.
+#     zh-TW: Translated description.
+#   changelog:          # text, or per-language like long_description
+#     en: |-
+#       - Most important change first. Omit to use Release notes.
+#     zh-TW: |-
+#       - Translated changes.
+#   screenshots: [https://example.com/screenshot.png]
+os_min_ver: "7.1-42661"
+
+# One SPK per architecture. Supported: x86_64, aarch64, armv7 (add it here to
+# build it; armv7 is built but not NAS-verified).
+arches: [x86_64, aarch64]
+
+# The SDK's Go runtime is the CGI: it checks the DSM session, the entry gate
+# and app/permissions.json, then runs `python3 main.py` in backend/app as the
+# package account, once per call, with DSM's own Python (3.8 or later).
+# sdk is the SDK release whose runtime and Python SDK (vendor/synopkgland_app)
+# the build ships; the build reads the methods from `main.py --describe`.
+backend:
+  runtime: python
+  dir: backend/app
+  entry: main.py
+  sdk: 0.10.0
+
+ui:
+  # Static files served at /webman/3rdparty/<package>/app/. app.js and app.css
+  # are required; anything else (images, chunks) is copied as is.
+  dir: ui
+
+# UI languages: i18n/messages/<locale>.json for en, zh-TW, zh-CN, ja, ko, de,
+# fr, es and it (DSM's other languages fall back to English). build checks
+# that every language has the en.json keys and placeholders, and that the keys
+# listed in the glossary use DSM's own wording.
+i18n:
+  messages: i18n/messages
+  glossary: i18n/glossary.json
+  # Package Center text per language (INFO displayname_<lang>/description_<lang>).
+  # English comes from displayname/description above.
+  info:
+    zh-TW: { description: 以 Python 後端與 DSM 視窗介面打造的原生 DSM 套件。 }
+    zh-CN: { description: 以 Python 后端与 DSM 窗口界面构建的原生 DSM 套件。 }
+    ja: { description: Python バックエンドと DSM ウィンドウ UI を備えたネイティブ DSM パッケージ。 }
+    ko: { description: Python 백엔드와 DSM 창 UI를 갖춘 네이티브 DSM 패키지. }
+    de: { description: Ein natives DSM-Paket mit Python-Backend und DSM-Fenster-Oberfläche. }
+    fr: { description: Un paquet DSM natif avec un backend Python et une interface en fenêtre DSM. }
+    es: { description: Un paquete nativo de DSM con backend en Python e interfaz en ventana de DSM. }
+    it: { description: Un pacchetto DSM nativo con backend Python e interfaccia in una finestra DSM. }
+
+# Optional SDK capabilities; delegate/rootOps share administrator-approved executor setup.
+capabilities: {}

package/templates/native-python/gitignore

@@ -0,0 +1,2 @@
+dist/
+__pycache__/

package/templates/native-python-delegate/backend/app/delegate.py

@@ -0,0 +1,42 @@
+"""Saves to a user's destination: write a report and move it there.
+
+The browser picks the destination with the SDK's Background saves page and
+sends its delegation ID; the executor checks that it is the caller's grant
+and writes the file as the caller, never as root. A save that failed may be
+repeated with the same job ID: the same file is sent again, and the executor
+copies it at most once.
+"""
+
+import os
+import re
+import time
+
+from synopkgland_app import Error
+
+from params import fields
+
+JOB_ID = re.compile(r"[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}\Z")
+
+
+def register(app, cfg):
+    app.method("report.save")(lambda ctx, params: save(cfg, ctx, params))
+
+
+def save(cfg, ctx, params):
+    p = fields(params, delegation_id=str, job_id=str)
+    if not JOB_ID.match(p["job_id"]):
+        raise Error.bad_request("job_id must be 1 to 128 letters, digits, '.', '_' or '-'")
+    name = "report-%s.txt" % p["job_id"]
+    # The runtime's delegate service moves files from here.
+    staging = os.path.join(cfg.data_dir, "executor-staging")
+    os.makedirs(staging, mode=0o700, exist_ok=True)
+    path = os.path.join(staging, name)
+    try:
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    except FileExistsError:
+        pass
+    else:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write("Report for %s, %s\n" % (ctx.user, time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())))
+    move = {"delegation_id": p["delegation_id"], "job_id": p["job_id"], "staging": name, "name": name, "size": os.path.getsize(path)}
+    return ctx.runtime("delegate.move_from_staging", move)