@uns-kit/cli 0.0.15 → 0.0.16

package/README.md

@@ -27,6 +27,10 @@ pnpm run dev
 - `uns-kit configure-devops [path]` – add Azure DevOps tooling (dependencies, script, config) to an existing project.
 - `uns-kit configure-vscode [path]` – copy VS Code launch/workspace files into an existing project.
 - `uns-kit configure-codegen [path]` – scaffold GraphQL code generation and UNS refresh scripts.
+- `uns-kit configure-api [path]` – copy UNS API examples and add `@uns-kit/api`.
+- `uns-kit configure-cron [path]` – copy UNS cron examples and add `@uns-kit/cron`.
+- `uns-kit configure-temporal [path]` – copy UNS Temporal examples and add `@uns-kit/temporal`.
+- `uns-kit configure-python [path]` – copy Python gateway client scaffolding (no npm dependency required).
 - `uns-kit help` – display usage information.
 
 ### Configure Azure DevOps
@@ -60,6 +64,41 @@ pnpm run refresh-uns
 
 Adds `codegen.ts`, seeds `src/uns/` placeholder types, and wires the GraphQL Code Generator / `refresh-uns` script into `package.json`. After installing the new dev dependencies you can regenerate strongly-typed operations (`pnpm run codegen`) and rebuild UNS topics/tags from your environment (`pnpm run refresh-uns`).
 
+### Add UNS API scaffolding
+
+```bash
+uns-kit configure-api
+pnpm install
+```
+
+Copies API-oriented examples (under `src/examples/`) and adds `@uns-kit/api` to your project dependencies.
+
+### Add cron-based scaffolding
+
+```bash
+uns-kit configure-cron
+pnpm install
+```
+
+Adds cron-oriented example stubs and installs `@uns-kit/cron`.
+
+### Add Temporal scaffolding
+
+```bash
+uns-kit configure-temporal
+pnpm install
+```
+
+Copies Temporal example placeholders and installs `@uns-kit/temporal`.
+
+### Add Python gateway scaffolding
+
+```bash
+uns-kit configure-python
+```
+
+Copies the Python gateway client template (examples, scripts, requirements, proto) into your project so you can iterate on the gRPC gateway from Python alongside your TypeScript project.
+
 ### Extend the Config Schema
 
 Edit `src/config/project.config.extension.ts` inside your generated project and run `pnpm run generate-config-schema`. This regenerates `config.schema.json` and `src/config/app-config.ts` so editors and runtime types stay in sync.

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { execFile } from "node:child_process";
 import { access, cp, mkdir, readFile, readdir, stat, writeFile, copyFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
@@ -54,6 +55,50 @@ async function main() {
         }
         return;
     }
+    if (command === "configure-api") {
+        const targetPath = args[1];
+        try {
+            await configureApi(targetPath);
+        }
+        catch (error) {
+            console.error(error.message);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (command === "configure-cron") {
+        const targetPath = args[1];
+        try {
+            await configureCron(targetPath);
+        }
+        catch (error) {
+            console.error(error.message);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (command === "configure-temporal") {
+        const targetPath = args[1];
+        try {
+            await configureTemporal(targetPath);
+        }
+        catch (error) {
+            console.error(error.message);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (command === "configure-python") {
+        const targetPath = args[1];
+        try {
+            await configurePython(targetPath);
+        }
+        catch (error) {
+            console.error(error.message);
+            process.exitCode = 1;
+        }
+        return;
+    }
     if (command === "create") {
         const projectName = args[1];
         if (!projectName) {
@@ -81,6 +126,10 @@ function printHelp() {
         "  configure-devops [dir]  Configure Azure DevOps tooling in an existing project\n" +
         "  configure-vscode [dir]  Add VS Code workspace configuration files\n" +
         "  configure-codegen [dir] Copy GraphQL codegen template and dependencies\n" +
+        "  configure-api [dir]     Copy UNS API examples and add @uns-kit/api\n" +
+        "  configure-cron [dir]    Copy UNS cron examples and add @uns-kit/cron\n" +
+        "  configure-temporal [dir] Copy UNS Temporal examples and add @uns-kit/temporal\n" +
+        "  configure-python [dir]   Copy Python gateway client scaffolding\n" +
         "  help                    Show this message\n");
 }
 async function createProject(projectName) {
@@ -307,6 +356,40 @@ async function configureCodegen(targetPath) {
         console.log("  Existing package.json already contained required scripts and dependencies.");
     }
 }
+async function configureApi(targetPath) {
+    await configurePlugin({
+        targetPath,
+        templateName: "api",
+        dependencyName: "@uns-kit/api",
+        dependencySpecifier: resolveUnsPackageSpecifier("@uns-kit/api", "../../uns-api/package.json"),
+        label: "UNS API",
+    });
+}
+async function configureCron(targetPath) {
+    await configurePlugin({
+        targetPath,
+        templateName: "cron",
+        dependencyName: "@uns-kit/cron",
+        dependencySpecifier: resolveUnsPackageSpecifier("@uns-kit/cron", "../../uns-cron/package.json"),
+        label: "UNS cron",
+    });
+}
+async function configureTemporal(targetPath) {
+    await configurePlugin({
+        targetPath,
+        templateName: "temporal",
+        dependencyName: "@uns-kit/temporal",
+        dependencySpecifier: resolveUnsPackageSpecifier("@uns-kit/temporal", "../../uns-temporal/package.json"),
+        label: "UNS Temporal",
+    });
+}
+async function configurePython(targetPath) {
+    await configurePlugin({
+        targetPath,
+        templateName: "python",
+        label: "UNS Python client",
+    });
+}
 async function ensureGitRepository(dir) {
     try {
         const { stdout } = await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], {
@@ -393,6 +476,65 @@ async function copyTemplateDirectory(sourceDir, targetDir, targetRoot) {
     }
     return { copied, skipped };
 }
+async function configurePlugin(options) {
+    const { targetPath, templateName, dependencyName, dependencySpecifier, label } = options;
+    const targetDir = path.resolve(process.cwd(), targetPath ?? ".");
+    const templateDir = path.resolve(__dirname, `../templates/${templateName}`);
+    const packagePath = path.join(targetDir, "package.json");
+    try {
+        await access(templateDir);
+    }
+    catch (error) {
+        throw new Error(`${label} template directory is missing. Please ensure templates/${templateName} exists.`);
+    }
+    let pkgRaw;
+    try {
+        pkgRaw = await readFile(packagePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`Could not find package.json in ${targetDir}`);
+        }
+        throw error;
+    }
+    const pkg = JSON.parse(pkgRaw);
+    const { copied, skipped } = await copyTemplateDirectory(templateDir, targetDir, targetDir);
+    let pkgChanged = false;
+    if (dependencyName && dependencySpecifier) {
+        const deps = (pkg.dependencies ??= {});
+        if (deps[dependencyName] !== dependencySpecifier) {
+            deps[dependencyName] = dependencySpecifier;
+            pkgChanged = true;
+        }
+    }
+    if (pkgChanged) {
+        await writeFile(packagePath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    }
+    console.log(`\n${label} assets processed.`);
+    if (copied.length) {
+        console.log("  Added files:");
+        for (const file of copied) {
+            console.log(`    ${file}`);
+        }
+    }
+    if (skipped.length) {
+        console.log("  Skipped existing files:");
+        for (const file of skipped) {
+            console.log(`    ${file}`);
+        }
+    }
+    if (!copied.length && !skipped.length) {
+        console.log("  No template files were copied.");
+    }
+    if (dependencyName && dependencySpecifier) {
+        if (pkgChanged) {
+            console.log(`  Added dependency ${dependencyName}@${dependencySpecifier}. Run pnpm install to fetch it.`);
+        }
+        else {
+            console.log("  Existing package.json already contained the required dependency.");
+        }
+    }
+}
 async function resolveAzureGitApi(organization) {
     const tokensUrl = `https://dev.azure.com/${organization}/_usersSettings/tokens`;
     const envPat = process.env.AZURE_PAT?.trim();
@@ -682,6 +824,54 @@ function normalizePackageName(input) {
         .replace(/^-+|-+$/g, "")
         || "uns-app";
 }
+function resolveUnsPackageSpecifier(packageName, relativeLocalPath) {
+    const localPath = path.resolve(__dirname, relativeLocalPath);
+    if (existsSync(localPath)) {
+        const pkg = require(localPath);
+        const version = pkg?.version ?? "0.0.1";
+        return `workspace:^${version}`;
+    }
+    const version = resolveUnsPackageVersion(packageName, relativeLocalPath);
+    return `^${version}`;
+}
+function resolveUnsPackageVersion(packageName, relativeLocalPath) {
+    const attempt = (factory) => {
+        try {
+            return factory();
+        }
+        catch (error) {
+            return undefined;
+        }
+    };
+    const directVersion = attempt(() => {
+        const pkg = require(`${packageName}/package.json`);
+        return pkg?.version;
+    });
+    if (directVersion) {
+        return directVersion;
+    }
+    const workspaceVersion = attempt(() => {
+        const pkgPath = path.resolve(__dirname, relativeLocalPath);
+        const pkg = require(pkgPath);
+        return pkg?.version;
+    });
+    if (workspaceVersion) {
+        return workspaceVersion;
+    }
+    const cliDependencyVersion = attempt(() => {
+        const cliPkg = require("../package.json");
+        const range = cliPkg.dependencies?.[packageName];
+        if (typeof range === "string") {
+            const match = range.match(/\d+\.\d+\.\d+/);
+            return match?.[0];
+        }
+        return undefined;
+    });
+    if (cliDependencyVersion) {
+        return cliDependencyVersion;
+    }
+    return "0.0.1";
+}
 function resolveCoreVersion() {
     const attempt = (factory) => {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uns-kit/cli",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "Command line scaffolding tool for UNS applications",
   "type": "module",
   "license": "MIT",
@@ -25,7 +25,7 @@
     "templates"
   ],
   "dependencies": {
-    "@uns-kit/core": "0.0.19"
+    "@uns-kit/core": "0.0.20"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",

package/templates/api/src/examples/api-example.ts

@@ -0,0 +1,61 @@
+/**
+ * Change this file according to your specifications and rename it to index.ts
+ */
+import { UnsProxyProcess, ConfigFile } from "@uns-kit/core";
+import { IApiProxyOptions } from "@uns-kit/core";
+import type { UnsEvents } from "@uns-kit/core";
+import { type UnsProxyProcessWithApi } from "@uns-kit/api";
+
+/**
+ * Load the configuration from a file.
+ * On the server, this file is provided by the `uns-datahub-controller`.
+ * In the development environment, you are responsible for creating and maintaining this file and its contents.
+ */
+const config = await ConfigFile.loadConfig();
+
+/**
+ * Connect to the API proxy process
+ */
+const unsProxyProcess = new UnsProxyProcess(config.infra.host!, {processName: config.uns.processName}) as UnsProxyProcessWithApi;
+const apiOptions: IApiProxyOptions = config.uns?.jwksWellKnownUrl
+  ? {
+      jwks: {
+        wellKnownJwksUrl: config.uns.jwksWellKnownUrl,
+        activeKidUrl: config.uns.kidWellKnownUrl,
+      },
+    }
+  : {
+      jwtSecret: "CHANGEME",
+    };
+const apiInput = await unsProxyProcess.createApiProxy("templateUnsApiInput", apiOptions);
+
+/**
+ * Register an API endpoint and event handler
+ */
+apiInput.get("sij/", "summary-1",{
+  tags: ["Tag1"],
+  apiDescription: "Test API endpoint 1",
+  queryParams: [
+    { name: "filter", type: "string", required: true, description: "Filter za podatke" },
+    { name: "limit", type: "number", required: false, description: "Koliko podatkov želiš" },
+  ]
+}); 
+
+apiInput.get("sij/", "summary-2",{
+  tags: ["Tag2"],
+  apiDescription: "Test API endpoint 2",
+  queryParams: [
+    { name: "filter", type: "string", required: true, description: "Filter za podatke" },
+    { name: "limit", type: "number", required: false, description: "Koliko podatkov želiš" },
+  ]
+});
+
+apiInput.event.on("apiGetEvent", (event: UnsEvents["apiGetEvent"]) => {
+  try {
+    const appContext = event.req.appContext;
+    // Add SQL query or any other code here
+    event.res.send("OK");
+  } catch (error) {
+    event.res.status(400).send("Error");
+  }    
+});

package/templates/cron/src/examples/cron-example.ts

@@ -0,0 +1,45 @@
+/**
+ * Change this file according to your specifications and rename it to index.ts
+ */
+import { UnsProxyProcess, ConfigFile, logger } from "@uns-kit/core";
+import type { IUnsMessage, UnsEvents } from "@uns-kit/core";
+import { type UnsProxyProcessWithCron } from "@uns-kit/cron";
+import { UnsTags } from "../uns/uns-tags.js";
+import { UnsTopics } from "../uns/uns-topics.js";
+import { PhysicalMeasurements } from "@uns-kit/core/uns/uns-measurements.js";
+import { UnsPacket } from "@uns-kit/core/uns/uns-packet.js";
+
+
+/**
+ * Load the configuration from a file.
+ * On the server, this file is provided by the `uns-datahub-controller`.
+ * In the development environment, you are responsible for creating and maintaining this file and its contents.
+ */
+const config = await ConfigFile.loadConfig();
+
+/**
+ * Connect to the output broker and create a crontab proxy
+ */
+const unsProxyProcess = new UnsProxyProcess(config.infra.host!, {processName:config.uns.processName}) as UnsProxyProcessWithCron;;
+const mqttOutput = await unsProxyProcess.createUnsMqttProxy((config.output?.host)!, "templateUnsRttOutput", config.uns.instanceMode, config.uns.handover, { publishThrottlingDelay: 1000});
+const cronInput = await unsProxyProcess.createCrontabProxy("* * * * * *");
+
+/**
+ * Event listener for cron events.
+ * On each cron event, publish a message to the MQTT output broker.
+ */
+cronInput.event.on("cronEvent", async (event: UnsEvents["cronEvent"]) => {
+  try {
+    const time = UnsPacket.formatToISO8601(new Date());
+    const numberValue: number = 42;
+    const message: IUnsMessage = { data: { time, value: numberValue, uom: PhysicalMeasurements.MiliVolt } };
+    const topic: UnsTopics = "sij/";
+    const tags: UnsTags[] = [];
+    const packet = await UnsPacket.unsPacketFromUnsMessage(message);
+    mqttOutput.publishMqttMessage({ topic, attribute: "data-number", packet, description: "Number value", tags });
+  } catch (error) {
+    const reason = error instanceof Error ? error : new Error(String(error));
+    logger.error(`Error publishing message to MQTT: ${reason.message}`);
+    throw error;
+  }
+});

package/templates/default/README.md

@@ -25,4 +25,6 @@ Update `config.json` with your broker, UNS URLs, and credentials. The generated
 - Run `uns-kit configure-devops` to add the Azure DevOps pull-request tooling.
 - Run `uns-kit configure-vscode` to copy workspace/launch configuration for VS Code.
 - Run `uns-kit configure-codegen` to scaffold GraphQL code generation and UNS refresh scripts.
+- Run `uns-kit configure-api` / `configure-cron` / `configure-temporal` to pull in example stubs and install the matching UNS plugins.
+- Run `uns-kit configure-python` to copy the Python gateway client template (examples, scripts, proto).
 - Commit your new project and start building!

package/templates/default/src/examples/uns-gateway.ts

@@ -0,0 +1,7 @@
+import { startUnsGateway } from "../uns-grpc/uns-gateway-server.js";
+
+const addr = await startUnsGateway();
+console.log(`UNS Gateway listening on ${addr.address} (UDS=${addr.isUDS})`);
+// Keep alive
+setInterval(() => {}, 1 << 30);
+

package/templates/python/examples/README.md

@@ -0,0 +1,84 @@
+# Python Examples for the UNS gRPC Gateway
+
+These examples demonstrate how to use the Node-based UNS Gateway (MQTT + UNS infra) from Python via gRPC. They mirror the TypeScript examples for data, table, cron-like publishing, and API endpoints.
+
+The gateway centralizes all UNS rules (packet format, sequenceId, interval, produced topics, handover). Python focuses on business logic and ML/ETL while calling the gateway.
+
+## Prerequisites
+
+- Build the Node project once: `npm run build`
+- Generate Python stubs and venv: `cd python && ./scripts/setup.sh && source venv/bin/activate`
+- Ensure `config.json` is present at repo root (Node gateway reads brokers and UNS options from it)
+
+## Gateway Address
+
+- If `--addr` is omitted, each script auto‑generates a unique address:
+  - Unix/macOS: `unix:/tmp/uns-gateway-<script>-<pid>.sock`
+  - Windows: `127.0.0.1:<ephemeral_port>`
+- You can still pass an explicit `--addr` if you want a fixed address.
+
+All examples accept `--addr` and `--auto`. With `--auto`, the example will spawn the gateway via `npm run gateway` and wait until it's ready.
+
+Imports note: Examples add the generated stubs folder (`python/gen`) to `sys.path` so you can run them from the repo root or from the `python/` folder. Ensure you’ve run `./scripts/setup.sh` so `gen` exists.
+
+Readiness: Examples call the gateway’s `Ready()` RPC to wait for the requested components (publisher/subscriber/API) to be active before publishing or subscribing. No manual sleeps are required.
+
+## Common Flags
+
+- `--addr`: Gateway address (`unix:/path.sock` or `host:port`)
+- `--auto`: Auto-start the gateway if not running
+
+## Scripts
+
+- `data_transformer.py`
+  - Subscribes to input topics (default `raw/#`) and publishes UNS data packets (`sij/` + `data-number`).
+  - Examples:
+    - Unix/macOS: `python python/examples/data_transformer.py --addr unix:/tmp/uns-gateway.sock --auto --in raw/# --out-topic sij/ --attribute data-number --uom mV --group electricity`
+    - Windows: `python python/examples/data_transformer.py --addr 127.0.0.1:50051 --auto --in raw/# --out-topic sij/ --attribute data-number --uom mV --group electricity`
+
+- `table_transformer.py`
+  - Subscribes to `iba/zrm` JSON and publishes a UNS table packet (`sij/acroni/hv/` + `zrm`).
+  - Examples:
+    - Unix/macOS: `python python/examples/table_transformer.py --addr unix:/tmp/uns-gateway.sock --auto --in-topic iba/zrm --out-topic sij/acroni/hv/ --attribute zrm`
+    - Windows: `python python/examples/table_transformer.py --addr 127.0.0.1:50051 --auto --in-topic iba/zrm --out-topic sij/acroni/hv/ --attribute zrm`
+
+- `data_publisher_loop.py`
+  - Cron-like loop that publishes a data value periodically (default 1000 ms).
+  - Examples:
+    - Unix/macOS: `python python/examples/data_publisher_loop.py --addr unix:/tmp/uns-gateway.sock --auto --out-topic sij/ --attribute data-number --uom mV --period-ms 1000`
+    - Windows: `python python/examples/data_publisher_loop.py --addr 127.0.0.1:50051 --auto --out-topic sij/ --attribute data-number --uom mV --period-ms 1000`
+
+- `data_publish_once.py`
+  - Sends a single UNS data packet.
+  - Examples:
+    - Unix/macOS: `python python/examples/data_publish_once.py --addr unix:/tmp/uns-gateway.sock --auto --out-topic sij/ --attribute data-number --value 42 --uom mV --group electricity`
+    - Windows: `python python/examples/data_publish_once.py --addr 127.0.0.1:50051 --auto --out-topic sij/ --attribute data-number --value 42 --uom mV --group electricity`
+
+- `data_subscribe.py`
+  - Subscribes to topics via the gateway and prints messages.
+  - Examples:
+    - Unix/macOS: `python python/examples/data_subscribe.py --addr unix:/tmp/uns-gateway.sock --auto raw/# some/other/topic`
+    - Windows: `python python/examples/data_subscribe.py --addr 127.0.0.1:50051 --auto raw/# some/other/topic`
+
+- `api_register_and_serve.py`
+  - Registers `/api/sij/summary-1` and `/api/sij/summary-2` endpoints and serves requests over a bidirectional stream.
+  - Examples:
+    - Unix/macOS: `python python/examples/api_register_and_serve.py --addr unix:/tmp/uns-gateway.sock --auto`
+    - Windows: `python python/examples/api_register_and_serve.py --addr 127.0.0.1:50051 --auto`
+    - Then call: `http://<gateway-host>:<gateway-port>/api/sij/summary-1?filter=foo&limit=10`
+
+- `api_handler.py`
+  - Another API handler demo that returns structured JSON responses. Similar to `api_register_and_serve.py`.
+
+## Auth
+
+- If `config.json` sets `uns.jwksWellKnownUrl`, the gateway enforces JWT via JWKS (and path rules), matching UnsApiProxy behavior.
+- Otherwise, it uses a dev `jwtSecret` ("CHANGEME"). For local testing, you can:
+  - Remove JWKS settings in `config.json` and rely on the dev secret, or
+  - Provide a valid Bearer token as required by your environment.
+
+## Notes
+
+- The gateway binds to `--addr` or the `UNS_GATEWAY_ADDR` env var. Examples pass `--addr` explicitly.
+- On Unix/macOS, a stable UDS path (e.g., `/tmp/uns-gateway.sock`) is recommended for simplicity.
+- All examples will auto-start the gateway when `--auto` is used.

package/templates/python/examples/api_handler.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import queue
+from typing import Dict, Iterable, Optional
+
+import grpc
+
+import sys, os
+# Ensure generated stubs (python/gen) are importable as top-level modules
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'gen')))
+import uns_gateway_pb2 as pb2
+import uns_gateway_pb2_grpc as gw
+
+
+def make_channel(addr: str) -> grpc.Channel:
+    # Supports unix:/path.sock or host:port
+    return grpc.insecure_channel(addr)
+
+
+def register_endpoints(stub: gw.UnsGatewayStub) -> None:
+    # Mirror TS api-example.ts for two GET endpoints under /api/sij/summary-1 and -2
+    qp = [
+        pb2.ApiQueryParam(name="filter", type="string", required=True, description="Filter za podatke"),
+        pb2.ApiQueryParam(name="limit", type="number", required=False, description="Koliko podatkov želiš"),
+    ]
+
+    for idx, tag in [(1, "Tag1"), (2, "Tag2")]:
+        req = pb2.RegisterApiGetRequest(
+            topic="sij/",
+            attribute=f"summary-{idx}",
+            api_description=f"Test API endpoint {idx}",
+            tags=[tag],
+            query_params=qp,
+        )
+        res = stub.RegisterApiGet(req)
+        if not res.ok:
+            raise RuntimeError(f"Failed to register summary-{idx}: {res.error}")
+
+
+def serve_requests(stub: gw.UnsGatewayStub, echo: bool = False) -> None:
+    q: "queue.Queue[pb2.ApiEventResponse|None]" = queue.Queue()
+
+    def req_iter():
+        while True:
+            item = q.get()
+            if item is None:
+                break
+            yield item
+
+    stream = stub.ApiEventStream(req_iter())
+    try:
+        for ev in stream:
+            # ev.path e.g. /sij/summary-1; ev.query is a map<string,string>
+            path = ev.path
+            query: Dict[str, str] = dict(ev.query)
+            filt = query.get("filter", "")
+            limit = query.get("limit")
+            endpoint = "summary-1" if path.endswith("summary-1") else ("summary-2" if path.endswith("summary-2") else "unknown")
+
+            # Your business logic here. This example returns JSON reflecting the request.
+            body = {
+                "status": "OK",
+                "endpoint": endpoint,
+                "filter": filt,
+                "limit": int(limit) if (limit is not None and limit.isdigit()) else None,
+                "data": [
+                    {"id": 1, "value": 42},
+                    {"id": 2, "value": 43},
+                ],
+            }
+
+            q.put(
+                pb2.ApiEventResponse(
+                    id=ev.id,
+                    status=200,
+                    headers={"Content-Type": "application/json"},
+                    body=json.dumps(body),
+                )
+            )
+    except KeyboardInterrupt:
+        q.put(None)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Python API handler for UNS gRPC Gateway")
+    parser.add_argument("--addr", default=os.environ.get("GATEWAY_ADDR", "unix:/tmp/template-uns-rtt-1.6.14-uns-gateway.sock"), help="Gateway address (unix:/path.sock or host:port)")
+    parser.add_argument("--echo", action="store_true", help="Echo simple OK response instead of JSON body")
+    args = parser.parse_args()
+
+    with make_channel(args.addr) as ch:
+        stub = gw.UnsGatewayStub(ch)
+        register_endpoints(stub)
+        serve_requests(stub, echo=args.echo)
+
+
+if __name__ == "__main__":
+    main()