@telorun/k8s-runner 0.6.0

package/LICENSE

@@ -0,0 +1,17 @@
+# SUSTAINABLE USE LICENSE (Fair-code)
+
+Copyright (c) 2026 CodeNet Sp. z o.o.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, modify, and distribute the Software for any purpose—including commercial purposes—subject to the following conditions:
+
+1. ANTI-COMPETITION RESTRICTION: The Software may not be provided to third parties as a managed service, commercial SaaS (Software-as-a-Service), PaaS (Platform-as-a-Service), BaaS (Backend-as-a-Service), or similar offering where the primary value provided to the user is the functionality of the Software itself, without a separate commercial license from the copyright holder.
+
+2. PERMITTED COMMERCIAL USE: You are free to use the Software to build, host, and monetize your own commercial applications, products, and services, provided such use does not violate Clause 1.
+
+3. ATTRIBUTION: This copyright notice and license must be included in all copies or substantial portions of the Software.
+
+4. CONTRIBUTIONS: Contributions to the Software are welcome and encouraged. By contributing, you agree that your contributions may be incorporated into the Software and distributed under this license.
+
+5. DISCLAIMER: 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.
+
+For commercial licensing, managed hosting exemptions, or enterprise inquiries, please contact <contact@codenet.pl>.

package/README.md

@@ -0,0 +1,206 @@
+# @telorun/k8s-runner
+
+HTTP service that runs Telo Applications as sandboxed **Kubernetes Pods**. A
+backend over [`@telorun/runner-core`](../../packages/runner-core), sibling to
+[`docker-runner`](../docker-runner) — it presents the identical `/v1` session
+contract (`/v1/health`, `/v1/capabilities`, `/v1/probe`, `/v1/sessions`,
+`/v1/sessions/:id/events` SSE, `/v1/sessions/:id/io` WS) but spawns a Pod per
+session instead of a container. On `/v1/capabilities` it advertises `image` /
+`pullPolicy` as **`readOnly`** (server-enforced — the runner serves untrusted
+code under a hard-ceiling policy), so the editor lets the user edit only the
+runner URL.
+
+## ⚠️ Security posture
+
+The runner is a **dumb executor**: no auth, no per-IP concurrency, no rate
+limiting — only a global `RUNNER_MAX_SESSIONS` backstop. **Do not expose it
+directly to anonymous internet traffic.** Front it with the Telo Cloud control
+plane (or an equivalent abuse-control proxy), which resolves identity → tier →
+limits and forwards to the runner. Standalone, it is safe only on a
+trusted/internal network.
+
+Resource limits are **hard ceilings**: a request may ask for *less* than the
+configured cap but never more (`min(requested, ceiling)`). For a bare runner
+serving an anonymous tier, the ceiling *is* the policy.
+
+## How it works
+
+Per session the runner resolves the image, creates a Pod (`telo run`), watches it
+for status, attaches a PTY over the Pod `attach` subresource for the interactive
+`/io` channel, and — when an ingress base domain is configured — creates a
+per-session Service + Ingress (`<sessionId>.<base-domain>`) garbage-collected via
+an ownerReference to the Pod.
+
+**Every session runs a prebuilt per-app image** — there is no in-pod install
+path. On a session-create the runner stages the bundle plus a generated
+`Dockerfile` (`FROM <base>`, `ENV TELO_CACHE_DIR=/telo-cache`, `RUN telo install`),
+runs a trusted **Kaniko** Job in the `telo-builds` namespace that bakes every
+controller and module manifest into `/telo-cache/{manifests,npm}` and pushes the
+result, then runs the session pod from that image — so the session never installs
+anything on the start path and a slow/unreachable package registry can't stall it.
+
+**The image is keyed on the dependency closure, not the whole bundle** — the
+`imports:` set plus any controllers declared by inline `Telo.Definition` docs
+(see `extractDependencyKey`). A body-only edit (resource config, CEL) reuses the
+existing image; only an import or controller change rebuilds. The per-session
+**body is delivered at boot**, not baked: a body-fetch initContainer untars the
+staged bundle into a writable `/app` emptyDir, and the session runs `telo run
+/app/<entry> --no-cache-write` — reading the baked deps from the read-only
+`/telo-cache` and validating in-memory, so `readOnlyRootFilesystem` stays on with
+nothing written to the cache. Builds are existence-checked before building and
+single-flighted; a build failure surfaces as an actionable error carrying the
+build pod's log tail. `RUNNER_IMAGE_REPOSITORY` is therefore **required** — the
+runner refuses to start without a registry to build into.
+
+**Coming-up progress** is reported over the `/v1` SSE stream as `progress` events
+(`build` → `provision`) while the session is still `starting`. The session is
+created with a fast `201` carrying the `streamUrl` **before** the build runs, so
+the client connects immediately and sees build + provision progress live; the
+backend then runs in the background and a start failure surfaces as a terminal
+`failed` status on the stream. The session flips to `running` when the Pod reaches
+`Running`.
+
+Sandbox hardening is always on (non-root, read-only rootfs, drop-all caps, no
+service-account token, seccomp `RuntimeDefault`); a sandbox RuntimeClass
+(gVisor/Kata) is layered on when configured. In the prebuilt path the per-app
+image is single-tenant, so install scripts run normally inside the trusted build
+(native/postinstall controllers work) with no cross-tenant cache to poison.
+
+## Configuration (env)
+
+| Env | Default | Purpose |
+| --- | --- | --- |
+| `RUNNER_SELF_URL` | _(required)_ | Runner's in-cluster base URL (bundle fetch) |
+| `PORT` | `8062` | HTTP listen port |
+| `RUNNER_SESSION_NAMESPACE` | `telo-sessions` | Namespace for session objects |
+| `RUNNER_IMAGE` | `telorun/node:latest-slim` | Default base image; always offered in the picker and the fallback when the catalog is unreachable |
+| `RUNNER_INIT_IMAGE` | `busybox:stable` | Build-context fetch initContainer image (wget + tar) |
+| `RUNNER_RUNTIME_CLASS` | _(unset → runc)_ | Sandbox RuntimeClass (gvisor/kata) |
+| `SESSION_INGRESS_BASE_DOMAIN` | _(unset → logs-only)_ | Wildcard base for per-session ingress |
+| `SESSION_INGRESS_TLS_SECRET` | _(unset → no TLS block)_ | `kubernetes.io/tls` Secret (in `telo-sessions`) the session Ingress presents; must cover `*.<base-domain>`. Set for Cloudflare Full (Strict) / any origin-cert upstream |
+| `RUNNER_MAX_CPU` | `50m` | CPU ceiling |
+| `RUNNER_MAX_MEMORY` | `100Mi` | Memory ceiling |
+| `RUNNER_MAX_TTL_SECONDS` | `3600` | Wall-clock TTL (Pod `activeDeadlineSeconds`) |
+| `RUNNER_MAX_EPHEMERAL_STORAGE` | `512Mi` | Per-Pod ephemeral-storage ceiling |
+| `RUNNER_MAX_SESSIONS` | `32` | Global session backstop; at capacity the oldest exited session is evicted before a new run is rejected |
+| `RUNNER_EXIT_TTL_MS` | `14400000` | How long exited sessions stay in the registry (so the editor can re-attach and replay their history after a reload) before eviction |
+| `RUNNER_TERMS_FILE` | _(unset)_ | Path to the agreement file (plain text / markdown), read at startup — mount it from a `ConfigMap` (e.g. `/etc/telo/terms.md`). Setting this (or `RUNNER_TERMS_BODY`) enables terms: the runner advertises them on `/v1/capabilities` and rejects `POST /v1/sessions` with `428` unless the client sends `x-telo-accepted-terms` matching the version. An unreadable path fails startup. The public cloud should set this |
+| `RUNNER_TERMS_BODY` | _(unset)_ | Inline agreement text, for short notes; ignored when `RUNNER_TERMS_FILE` is set |
+| `RUNNER_TERMS_TITLE` | `Usage agreement` | Heading shown above the agreement |
+| `RUNNER_TERMS_VERSION` | _(hash of body)_ | Acceptance version; defaults to a content hash so any edit to the body automatically re-prompts every client. Set explicitly only to control material-change vs typo |
+
+### Base-image picker
+
+The runner advertises a menu of base images on `/v1/capabilities`, resolved from
+a Docker Hub repo's tags (filtered) and cached. The editor renders it as an
+editable `image` dropdown; the chosen image is **re-validated server-side**
+against the same list, so a client that skips the editor can't widen the set.
+`RUNNER_IMAGE` is always offered and is the fallback when Docker Hub is
+unreachable. Disable the catalog to lock `image` to `RUNNER_IMAGE`.
+
+Pinned tags (e.g. `0.30.1-slim`) are immutable. A picked **moving** tag like
+`latest-slim` only refreshes when the session's `pullPolicy` is `always`: the
+build then pins the per-app image to the base's current digest, so a moved tag
+yields a new image and rebuilds (otherwise the cached build — keyed on the tag
+string — is reused). Movement detection reads the digest from Docker Hub, so a
+base hosted elsewhere (GHCR, a private registry) can't be tracked — `always`
+degrades to reusing the cached build for it, same as `missing` / `never`.
+
+| Env | Default | Purpose |
+| --- | --- | --- |
+| `RUNNER_BASE_IMAGE_CATALOG_ENABLED` | `true` | Resolve + advertise the picker; `false` locks `image` to `RUNNER_IMAGE` |
+| `RUNNER_BASE_IMAGE_REPO` | `telorun/node` | `namespace/repository` queried on Docker Hub |
+| `RUNNER_BASE_IMAGE_PINNED_ONLY` | `true` | Keep only pinned `MAJOR.MINOR.PATCH[-variant]` tags (drops `latest`, `0`, `0.30`) |
+| `RUNNER_BASE_IMAGE_EXCLUDE_SHA` | `true` | Drop commit-hash tags |
+| `RUNNER_BASE_IMAGE_EXCLUDE_PRERELEASE` | `true` | Drop semver prereleases (`-rc.1`, `-alpha`); `-slim` / `-rust-*` variants are kept |
+| `RUNNER_BASE_IMAGE_INCLUDE` | _(unset)_ | Regex a tag must match (escape hatch) |
+| `RUNNER_BASE_IMAGE_EXCLUDE` | _(unset)_ | Regex that drops a matching tag (escape hatch) |
+| `RUNNER_BASE_IMAGE_LIMIT` | `20` | Cap on advertised tags (newest first) |
+| `RUNNER_BASE_IMAGE_REFRESH_SECONDS` | `3600` | Catalog re-fetch cadence |
+
+### Image build (required)
+
+| Env | Default | Purpose |
+| --- | --- | --- |
+| `RUNNER_IMAGE_REPOSITORY` | _(required)_ | Registry repo for per-app images; tag = bundle hash |
+| `RUNNER_BUILD_NAMESPACE` | `telo-builds` | Namespace the trusted Kaniko build Jobs run in |
+| `RUNNER_BUILDER_IMAGE` | `gcr.io/kaniko-project/executor:latest` | Image builder |
+| `RUNNER_BUILD_TIMEOUT_SECONDS` | `600` | Build Job deadline / wait budget |
+| `RUNNER_REGISTRY_INSECURE` | `false` | Push/pull over HTTP / self-signed |
+| `RUNNER_REGISTRY_API_URL` | _(unset → always build)_ | HTTP(S) base for the manifest existence check (authenticated via the push Secret) |
+| `RUNNER_REGISTRY_PUSH_SECRET` | _(unset)_ | dockerconfig Secret (in `telo-builds`) Kaniko pushes with; also authenticates the existence check |
+| `RUNNER_IMAGE_PULL_SECRET` | _(unset)_ | dockerconfig Secret (in `telo-sessions`) the kubelet pulls per-app images with |
+| `TELO_REGISTRY_URL` | `https://registry.telo.run` | Telo module registry used by `telo install` |
+
+## Deploy (Helm)
+
+The runner **requires a registry to build into** (there is no in-pod install
+fallback), so point it at one your cluster's kubelet can pull from:
+
+```bash
+helm install telo-runner ./chart \
+  --set build.repository=registry.example.com/telo-sessions \
+  --set-file registry.dockerconfigjson=./dockerconfig.json \  # private-registry auth
+  --set session.runtimeClass=gvisor
+```
+
+For a private registry, `registry.dockerconfigjson` creates the dockerconfig
+Secret in **both** namespaces (push in `telo-builds`, pull in `telo-sessions`) and
+wires `RUNNER_REGISTRY_PUSH_SECRET` + `RUNNER_IMAGE_PULL_SECRET` — the kubelet
+needs the pull copy because the per-app image is private. (Or manage the Secrets
+yourself and reference them via `build.pushSecretName` / `build.pullSecretName`.)
+The push Secret doubles as the credential for the manifest existence check, so
+the runner can see an already-built image in a private registry and skip the
+rebuild — without it a private registry answers `401` and every run rebuilds.
+A no-auth registry needs none of this.
+
+The chart provisions the static scaffolding: the runner Deployment (single
+replica — the registry is in-memory and the runner reaps orphaned pods on boot),
+Service, scoped RBAC, the `telo-runner` / restricted-PSS `telo-sessions` /
+baseline-PSS `telo-builds` namespaces, a `ResourceQuota`, and NetworkPolicies
+(session pod-to-pod isolation + the build namespace's registry egress). The
+runner creates per-session and per-build objects at runtime.
+
+The optional in-cluster registry (`--set registry.enabled=true --set
+build.insecureRegistry=true`) derives `build.repository` for you, but works only
+on clusters whose **nodes are configured to trust it** — otherwise an external/
+cloud registry is simpler. Installing with neither a `build.repository` nor
+`registry.enabled` is rejected at template time.
+
+### Origin TLS (Cloudflare et al.)
+
+To have the per-session Ingress present an origin cert (so an upstream like
+Cloudflare in **Full (Strict)** mode validates the origin), give the chart a
+`kubernetes.io/tls` Secret in `telo-sessions`. The cert must cover the wildcard
+`*.<sessionIngress.baseDomain>` — session hosts are a single label
+(`<port>-<sessionId>.<base-domain>`). Two ways:
+
+```bash
+# A — reference a Secret you manage in telo-sessions (cert-manager, your own sync)
+helm install telo-runner ./chart --set sessionIngress.tls.secretName=telo-origin-tls
+
+# B — let the chart create the Secret from your cert + key
+helm install telo-runner ./chart \
+  --set-file sessionIngress.tls.cert=origin.pem \
+  --set-file sessionIngress.tls.key=origin.key
+```
+
+Either wires `SESSION_INGRESS_TLS_SECRET`, and the runner stamps a `spec.tls`
+block on every session Ingress. Leave all three empty to skip TLS at the origin
+(terminated entirely upstream).
+
+> **Egress notes.** (1) The kubelet pulls session images directly and does **not**
+> use cluster DNS, so the in-cluster registry only works where nodes trust it
+> (e.g. containerd `registries.conf`). (2) Core NetworkPolicy is CIDR-only and
+> cannot express the package-registry FQDN allowlist the build namespace needs —
+> use a CNI with FQDN policy (Cilium) or an egress proxy to tighten it.
+
+## Development
+
+```bash
+pnpm --filter @telorun/k8s-runner build   # tsc
+pnpm --filter @telorun/k8s-runner test    # vitest (limits clamp, tar, bundle token)
+```
+
+The Kubernetes backend can't be exercised without a cluster; unit tests cover the
+backend-independent logic (limit clamping, the tar writer, bundle tokens).

package/dist/bundle-store.d.ts

@@ -0,0 +1,32 @@
+import type { FastifyInstance } from "fastify";
+import type { RunBundle } from "@telorun/runner-core";
+/**
+ * Holds image-build contexts in memory and serves them over a tokenized,
+ * cluster-internal URL the build Job's initContainer fetches once. The
+ * per-build unguessable token prevents cross-build disclosure; the entry is
+ * dropped after first fetch (or explicitly on cleanup).
+ */
+export declare class BundleStore {
+    private readonly selfUrl;
+    private readonly bundles;
+    constructor(selfUrl: string);
+    /**
+     * Stages an image-build context — the bundle plus a generated `Dockerfile` at
+     * the context root — and returns the tokenized, single-use URL the build Job's
+     * initContainer fetches. Keyed by `id` (a build id).
+     */
+    stageBuildContext(id: string, bundle: RunBundle, dockerfile: string): Promise<string>;
+    /**
+     * Stages the raw session bundle (no Dockerfile) and returns the tokenized,
+     * single-use URL the session Pod's body-delivery initContainer fetches into
+     * `/app`. Keyed by `sessionId`. The image is keyed only on the dependency
+     * closure, so the per-session body is delivered here at boot rather than baked.
+     */
+    stageSessionBundle(sessionId: string, bundle: RunBundle): Promise<string>;
+    private stage;
+    drop(sessionId: string): void;
+    private take;
+    /** Registers `GET /internal/bundles/:id` on the runner's Fastify app. */
+    registerRoute(app: FastifyInstance): void;
+}
+//# sourceMappingURL=bundle-store.d.ts.map

package/dist/bundle-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-store.d.ts","sourceRoot":"","sources":["../src/bundle-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AActD;;;;;GAKG;AACH,qBAAa,WAAW;IAGV,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;gBAE9B,OAAO,EAAE,MAAM;IAE5C;;;;OAIG;IACG,iBAAiB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAO3F;;;;;OAKG;IACG,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC;YAIjE,KAAK;IAUnB,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAM7B,OAAO,CAAC,IAAI;IASZ,yEAAyE;IACzE,aAAa,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI;CAiB1C"}

package/dist/bundle-store.js

@@ -0,0 +1,86 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { makeBundleTarGz } from "./tar.js";
+/** Staged bundles are dropped after this long even if never fetched, so a
+ *  stuck/never-started Pod can't grow the store unbounded. */
+const STAGING_TTL_MS = 5 * 60 * 1000;
+/**
+ * Holds image-build contexts in memory and serves them over a tokenized,
+ * cluster-internal URL the build Job's initContainer fetches once. The
+ * per-build unguessable token prevents cross-build disclosure; the entry is
+ * dropped after first fetch (or explicitly on cleanup).
+ */
+export class BundleStore {
+    selfUrl;
+    bundles = new Map();
+    constructor(selfUrl) {
+        this.selfUrl = selfUrl;
+    }
+    /**
+     * Stages an image-build context — the bundle plus a generated `Dockerfile` at
+     * the context root — and returns the tokenized, single-use URL the build Job's
+     * initContainer fetches. Keyed by `id` (a build id).
+     */
+    async stageBuildContext(id, bundle, dockerfile) {
+        return this.stage(id, {
+            entryRelativePath: bundle.entryRelativePath,
+            files: [...bundle.files, { relativePath: "Dockerfile", contents: dockerfile }],
+        });
+    }
+    /**
+     * Stages the raw session bundle (no Dockerfile) and returns the tokenized,
+     * single-use URL the session Pod's body-delivery initContainer fetches into
+     * `/app`. Keyed by `sessionId`. The image is keyed only on the dependency
+     * closure, so the per-session body is delivered here at boot rather than baked.
+     */
+    async stageSessionBundle(sessionId, bundle) {
+        return this.stage(sessionId, bundle);
+    }
+    async stage(id, bundle) {
+        this.drop(id);
+        const token = randomBytes(24).toString("hex");
+        const tarGz = await makeBundleTarGz(bundle);
+        const evictTimer = setTimeout(() => this.bundles.delete(id), STAGING_TTL_MS);
+        evictTimer.unref?.();
+        this.bundles.set(id, { token, tarGz, evictTimer });
+        return `${this.selfUrl}/internal/bundles/${id}?token=${token}`;
+    }
+    drop(sessionId) {
+        const existing = this.bundles.get(sessionId);
+        if (existing)
+            clearTimeout(existing.evictTimer);
+        this.bundles.delete(sessionId);
+    }
+    take(sessionId, token) {
+        const stored = this.bundles.get(sessionId);
+        if (!stored)
+            return null;
+        if (!constantTimeEqual(stored.token, token))
+            return null;
+        // Single-use: drop after a successful authenticated fetch.
+        this.drop(sessionId);
+        return stored.tarGz;
+    }
+    /** Registers `GET /internal/bundles/:id` on the runner's Fastify app. */
+    registerRoute(app) {
+        app.get("/internal/bundles/:id", async (req, reply) => {
+            const token = req.query.token ?? "";
+            const tarGz = this.take(req.params.id, token);
+            if (!tarGz) {
+                reply.code(404).send({ error: "not_found" });
+                return;
+            }
+            reply
+                .header("content-type", "application/gzip")
+                .header("cache-control", "no-store")
+                .send(tarGz);
+        });
+    }
+}
+function constantTimeEqual(a, b) {
+    const ab = Buffer.from(a);
+    const bb = Buffer.from(b);
+    if (ab.byteLength !== bb.byteLength)
+        return false;
+    return timingSafeEqual(ab, bb);
+}
+//# sourceMappingURL=bundle-store.js.map

package/dist/bundle-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-store.js","sourceRoot":"","sources":["../src/bundle-store.ts"],"names":[],"mappings":"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"}

package/dist/capabilities.d.ts

@@ -0,0 +1,15 @@
+import { type RunnerCapabilities, type RunnerTerms } from "@telorun/runner-core";
+/** What k8s-runner advertises on `/v1/capabilities`. The runner serves
+ *  untrusted/anonymous code under a hard-ceiling policy. `image` is a base-image
+ *  picker: when an `imageEnum` is supplied (the resolved Docker Hub catalog) the
+ *  editor renders an editable dropdown constrained to that allowlist — which the
+ *  session route re-validates server-side. Without a catalog (disabled /
+ *  first-fetch failure) the list collapses to the single `defaultImage` (locked
+ *  via `enforced`). `pullPolicy` is client-editable: `always` re-pulls the base
+ *  image when its tag has moved upstream (rebuilding the per-app image), which
+ *  is how a picked moving tag like `latest-slim` stays current.
+ *
+ *  `terms`, when set (operator-provided via RUNNER_TERMS_*), are enforced: a
+ *  session won't start until the client acknowledges the current version. */
+export declare function kubernetesRunnerCapabilities(defaultImage: string, terms?: RunnerTerms, imageEnum?: string[]): RunnerCapabilities;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;6EAW6E;AAC7E,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,WAAW,EACnB,SAAS,CAAC,EAAE,MAAM,EAAE,GACnB,kBAAkB,CAiBpB"}

package/dist/capabilities.js

@@ -0,0 +1,30 @@
+import { sessionConfigSchema, } from "@telorun/runner-core";
+/** What k8s-runner advertises on `/v1/capabilities`. The runner serves
+ *  untrusted/anonymous code under a hard-ceiling policy. `image` is a base-image
+ *  picker: when an `imageEnum` is supplied (the resolved Docker Hub catalog) the
+ *  editor renders an editable dropdown constrained to that allowlist — which the
+ *  session route re-validates server-side. Without a catalog (disabled /
+ *  first-fetch failure) the list collapses to the single `defaultImage` (locked
+ *  via `enforced`). `pullPolicy` is client-editable: `always` re-pulls the base
+ *  image when its tag has moved upstream (rebuilding the per-app image), which
+ *  is how a picked moving tag like `latest-slim` stays current.
+ *
+ *  `terms`, when set (operator-provided via RUNNER_TERMS_*), are enforced: a
+ *  session won't start until the client acknowledges the current version. */
+export function kubernetesRunnerCapabilities(defaultImage, terms, imageEnum) {
+    return {
+        displayName: "Telo Public Cloud",
+        description: "Runs the Telo application in sandboxed cloud environment with capped CPU and memory.",
+        config: {
+            schema: sessionConfigSchema({
+                imageDefault: defaultImage,
+                enforced: true,
+                imageEnum,
+                pullPolicyDescription: "Base-image freshness. `always` rebuilds the session image when the base tag has moved upstream (Docker Hub only); `missing` and `never` reuse the cached build.",
+            }),
+        },
+        features: { io: true, ports: true },
+        terms,
+    };
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,GAGpB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;6EAW6E;AAC7E,MAAM,UAAU,4BAA4B,CAC1C,YAAoB,EACpB,KAAmB,EACnB,SAAoB;IAEpB,OAAO;QACL,WAAW,EAAE,mBAAmB;QAChC,WAAW,EACT,sFAAsF;QACxF,MAAM,EAAE;YACN,MAAM,EAAE,mBAAmB,CAAC;gBAC1B,YAAY,EAAE,YAAY;gBAC1B,QAAQ,EAAE,IAAI;gBACd,SAAS;gBACT,qBAAqB,EACnB,iKAAiK;aACpK,CAAC;SACH;QACD,QAAQ,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE;QACnC,KAAK;KACN,CAAC;AACJ,CAAC"}

package/dist/config.d.ts

@@ -0,0 +1,95 @@
+import { RunnerConfigError, type RunnerCoreConfig, type TagFilter } from "@telorun/runner-core";
+export { RunnerConfigError };
+/**
+ * Base-image catalog settings. The runner resolves the menu of base images a
+ * session may pick from `telorun/node`'s Docker Hub tags (configurable repo),
+ * filtered to taste, and advertises it as an editable `image` picker. The
+ * configured `defaultImage` is always offered (and is the fallback when Docker
+ * Hub is unreachable). Disable to lock `image` to `defaultImage` (the old
+ * server-enforced behaviour) — e.g. an air-gapped cluster.
+ */
+export interface BaseImageCatalogConfig {
+    enabled: boolean;
+    /** `namespace/repository` queried on Docker Hub, e.g. `telorun/node`. */
+    repository: string;
+    filter: TagFilter;
+    /** Cap on advertised tags (newest first). */
+    limit: number;
+    /** Background refresh cadence in ms. */
+    refreshIntervalMs: number;
+}
+/**
+ * Resource limits the runner will ever grant. These are HARD CEILINGS, not
+ * defaults a request can exceed: the effective per-session value is
+ * `min(requested, ceiling)` (clamp-down only). For a bare runner serving an
+ * anonymous tier directly, the ceiling IS the policy.
+ */
+export interface LimitCeilings {
+    /** Kubernetes CPU quantity, e.g. "50m". */
+    cpu: string;
+    /** Kubernetes memory quantity, e.g. "100Mi". */
+    memory: string;
+    /** Wall-clock TTL in seconds (Pod activeDeadlineSeconds). */
+    ttlSeconds: number;
+    /** Per-Pod ephemeral-storage limit, e.g. "512Mi". */
+    ephemeralStorage: string;
+}
+/**
+ * On-cluster image-build settings. The runner ALWAYS prebuilds a self-contained
+ * per-app image (controllers + module manifests baked in via `telo install`) and
+ * the session pod runs it directly — there is no in-pod install fallback, so a
+ * registry repository (`RUNNER_IMAGE_REPOSITORY`) is required.
+ */
+export interface ImageBuildConfig {
+    /** Registry repository the per-app image is pushed to / pulled from; the tag
+     *  is the bundle content hash (e.g. `registry.telo-runner.svc:5000/telo-sessions`). */
+    repository: string;
+    /** Namespace the trusted Kaniko build Jobs run in (registry egress lives here). */
+    namespace: string;
+    /** Builder image — Kaniko (or a compatible `--context`/`--destination` executor). */
+    builderImage: string;
+    /** Build Job `activeDeadlineSeconds` and the runner's wait budget. */
+    timeoutSeconds: number;
+    /** Push/pull to an insecure (HTTP / self-signed) registry — the in-cluster default. */
+    insecureRegistry: boolean;
+    /** HTTP(S) base for a best-effort manifest existence check (skip build on hit);
+     *  undefined → always build. */
+    registryApiUrl?: string;
+    /** Telo module registry `telo install` resolves manifests from during the build. */
+    teloRegistryUrl: string;
+    /** Optional dockerconfig Secret (in the build namespace) Kaniko pushes with. */
+    pushSecretName?: string;
+    /** Optional dockerconfig Secret (in the session namespace) the kubelet uses to
+     *  pull per-app images from a private registry. */
+    imagePullSecret?: string;
+}
+export interface K8sRunnerConfig extends RunnerCoreConfig {
+    /** Namespace where session Pods/Services/Ingresses are created. */
+    sessionNamespace: string;
+    /** Default image for spawned session Pods (telorun/node). */
+    defaultImage: string;
+    /** Small image for the bundle/build-context fetch initContainer (needs wget + tar). */
+    initImage: string;
+    /** Optional sandbox RuntimeClass (gvisor/kata). Unset → cluster default (runc). */
+    runtimeClass?: string;
+    /** Wildcard base domain for per-session ingress; unset → logs-only. */
+    sessionIngressBaseDomain?: string;
+    /** Optional IngressClass name for created session Ingresses. */
+    sessionIngressClassName?: string;
+    /** Optional `kubernetes.io/tls` Secret (in the session namespace) the per-session
+     *  Ingress presents so an upstream (e.g. Cloudflare Full (Strict)) can validate
+     *  the origin. Must cover the wildcard `*.<sessionIngressBaseDomain>`. Unset → no TLS block. */
+    sessionIngressTlsSecretName?: string;
+    /** On-cluster image build — the only delivery path (always present). */
+    build: ImageBuildConfig;
+    /** Runner's own in-cluster base URL, used to build the bundle/build-context
+     *  fetch URL the initContainer curls (e.g. http://k8s-runner.telo-runner:8062). */
+    selfUrl: string;
+    /** Label applied to every session object, used for orphan reaping. */
+    managedByLabel: string;
+    limits: LimitCeilings;
+    /** Menu of base images a session may pick (advertised as the `image` enum). */
+    baseImageCatalog: BaseImageCatalogConfig;
+}
+export declare function loadK8sRunnerConfig(env: NodeJS.ProcessEnv): K8sRunnerConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACf,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAE7B;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,SAAS,CAAC;IAClB,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B;2FACuF;IACvF,UAAU,EAAE,MAAM,CAAC;IACnB,mFAAmF;IACnF,SAAS,EAAE,MAAM,CAAC;IAClB,qFAAqF;IACrF,YAAY,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAC;IACvB,uFAAuF;IACvF,gBAAgB,EAAE,OAAO,CAAC;IAC1B;oCACgC;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oFAAoF;IACpF,eAAe,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;uDACmD;IACnD,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACvD,mEAAmE;IACnE,gBAAgB,EAAE,MAAM,CAAC;IACzB,6DAA6D;IAC7D,YAAY,EAAE,MAAM,CAAC;IACrB,uFAAuF;IACvF,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,gEAAgE;IAChE,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC;;oGAEgG;IAChG,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,wEAAwE;IACxE,KAAK,EAAE,gBAAgB,CAAC;IACxB;uFACmF;IACnF,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,aAAa,CAAC;IACtB,+EAA+E;IAC/E,gBAAgB,EAAE,sBAAsB,CAAC;CAC1C;AA0CD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,eAAe,CAsD3E"}

package/dist/config.js

@@ -0,0 +1,76 @@
+import { loadCoreConfig, parseBool, parsePositiveInt, RunnerConfigError, } from "@telorun/runner-core";
+export { RunnerConfigError };
+const DEFAULT_PORT = 8062;
+/** Compile a single optional regex env var into a one-element `RegExp[]`. */
+function parseTagRegex(raw, field) {
+    const v = raw?.trim();
+    if (!v)
+        return undefined;
+    try {
+        return [new RegExp(v)];
+    }
+    catch (err) {
+        throw new RunnerConfigError(`${field} is not a valid regular expression: ${err.message}`);
+    }
+}
+function loadBaseImageCatalogConfig(env) {
+    return {
+        enabled: parseBool(env.RUNNER_BASE_IMAGE_CATALOG_ENABLED, true, "RUNNER_BASE_IMAGE_CATALOG_ENABLED"),
+        repository: env.RUNNER_BASE_IMAGE_REPO?.trim() || "telorun/node",
+        filter: {
+            pinnedOnly: parseBool(env.RUNNER_BASE_IMAGE_PINNED_ONLY, true, "RUNNER_BASE_IMAGE_PINNED_ONLY"),
+            excludeSha: parseBool(env.RUNNER_BASE_IMAGE_EXCLUDE_SHA, true, "RUNNER_BASE_IMAGE_EXCLUDE_SHA"),
+            excludePrerelease: parseBool(env.RUNNER_BASE_IMAGE_EXCLUDE_PRERELEASE, true, "RUNNER_BASE_IMAGE_EXCLUDE_PRERELEASE"),
+            include: parseTagRegex(env.RUNNER_BASE_IMAGE_INCLUDE, "RUNNER_BASE_IMAGE_INCLUDE"),
+            exclude: parseTagRegex(env.RUNNER_BASE_IMAGE_EXCLUDE, "RUNNER_BASE_IMAGE_EXCLUDE"),
+        },
+        limit: parsePositiveInt(env.RUNNER_BASE_IMAGE_LIMIT, 20, "RUNNER_BASE_IMAGE_LIMIT"),
+        refreshIntervalMs: parsePositiveInt(env.RUNNER_BASE_IMAGE_REFRESH_SECONDS, 3600, "RUNNER_BASE_IMAGE_REFRESH_SECONDS") * 1000,
+    };
+}
+export function loadK8sRunnerConfig(env) {
+    const selfUrl = env.RUNNER_SELF_URL?.trim();
+    if (!selfUrl) {
+        throw new RunnerConfigError("RUNNER_SELF_URL env var is required. Set it to the runner's in-cluster base URL " +
+            "(e.g. http://k8s-runner.telo-runner.svc:8062) so session initContainers can fetch the bundle.");
+    }
+    const repository = env.RUNNER_IMAGE_REPOSITORY?.trim();
+    if (!repository) {
+        throw new RunnerConfigError("RUNNER_IMAGE_REPOSITORY env var is required. The runner prebuilds a per-app session image for " +
+            "every run (there is no in-pod install fallback); set it to the registry repository the built " +
+            "images are pushed to / pulled from (e.g. registry.example.com/telo-sessions). The tag is the " +
+            "bundle content hash.");
+    }
+    const build = {
+        repository: repository.replace(/\/+$/, ""),
+        namespace: env.RUNNER_BUILD_NAMESPACE?.trim() || "telo-builds",
+        builderImage: env.RUNNER_BUILDER_IMAGE?.trim() || "gcr.io/kaniko-project/executor:latest",
+        timeoutSeconds: parsePositiveInt(env.RUNNER_BUILD_TIMEOUT_SECONDS, 600, "RUNNER_BUILD_TIMEOUT_SECONDS"),
+        insecureRegistry: env.RUNNER_REGISTRY_INSECURE?.trim() === "true",
+        registryApiUrl: env.RUNNER_REGISTRY_API_URL?.trim() || undefined,
+        teloRegistryUrl: env.TELO_REGISTRY_URL?.trim() || "https://registry.telo.run",
+        pushSecretName: env.RUNNER_REGISTRY_PUSH_SECRET?.trim() || undefined,
+        imagePullSecret: env.RUNNER_IMAGE_PULL_SECRET?.trim() || undefined,
+    };
+    return {
+        ...loadCoreConfig(env, { port: DEFAULT_PORT }),
+        sessionNamespace: env.RUNNER_SESSION_NAMESPACE?.trim() || "telo-sessions",
+        defaultImage: env.RUNNER_IMAGE?.trim() || "telorun/node:latest-slim",
+        initImage: env.RUNNER_INIT_IMAGE?.trim() || "busybox:stable",
+        runtimeClass: env.RUNNER_RUNTIME_CLASS?.trim() || undefined,
+        sessionIngressBaseDomain: env.SESSION_INGRESS_BASE_DOMAIN?.trim() || undefined,
+        sessionIngressClassName: env.SESSION_INGRESS_CLASS?.trim() || undefined,
+        sessionIngressTlsSecretName: env.SESSION_INGRESS_TLS_SECRET?.trim() || undefined,
+        build,
+        selfUrl: selfUrl.replace(/\/+$/, ""),
+        managedByLabel: env.RUNNER_MANAGED_BY?.trim() || "telo-k8s-runner",
+        limits: {
+            cpu: env.RUNNER_MAX_CPU?.trim() || "50m",
+            memory: env.RUNNER_MAX_MEMORY?.trim() || "100Mi",
+            ttlSeconds: parsePositiveInt(env.RUNNER_MAX_TTL_SECONDS, 3600, "RUNNER_MAX_TTL_SECONDS"),
+            ephemeralStorage: env.RUNNER_MAX_EPHEMERAL_STORAGE?.trim() || "512Mi",
+        },
+        baseImageCatalog: loadBaseImageCatalogConfig(env),
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}

package/dist/k8s/backend.d.ts

@@ -0,0 +1,19 @@
+import type { RunnerBackend } from "@telorun/runner-core";
+import type { BundleStore } from "../bundle-store.js";
+import type { K8sRunnerConfig } from "../config.js";
+import type { KubeClient } from "./client.js";
+export interface K8sBackendDeps {
+    kube: KubeClient;
+    config: K8sRunnerConfig;
+    bundleStore: BundleStore;
+}
+export declare function createKubernetesBackend(deps: K8sBackendDeps): RunnerBackend;
+/**
+ * Builds an actionable failure message from a terminal Pod status. Init
+ * containers are inspected first: a failed init container leaves the main
+ * container unstarted, so reading only `containerStatuses` would fall through
+ * to the bare "pod failed". For prebuilt session pods the common failure is the
+ * main container itself (image pull, OOM, a non-zero exit).
+ */
+export declare function podFailureMessage(obj: unknown): string;
+//# sourceMappingURL=backend.d.ts.map

package/dist/k8s/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../src/k8s/backend.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAMV,aAAa,EACd,MAAM,sBAAsB,CAAC;AAG9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAkB9C,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,cAAc,GAAG,aAAa,CAyU3E;AAiGD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAOtD"}