runtime-api/
├─ app/
│  ├─ server.js
│  ├─ routes/
│  │  ├─ health.js
│  │  └─ runtime.js
│  ├─ middleware/
│  │  └─ request-id.js
│  └─ lib/
│     ├─ logger.js
│     └─ config.js
└─ package.json

import http from "node:http";
import { randomUUID } from "node:crypto";

function json(res, status, body) {
  res.writeHead(status, { "content-type": "application/json" });
  res.end(JSON.stringify(body));
}

const server = http.createServer((req, res) => {
  const requestId = randomUUID();

  if (req.url === "/health") {
    return json(res, 200, { status: "ok", requestId });
  }

  if (req.url === "/runtime") {
    return json(res, 200, {
      requestId,
      node: process.version,
      pid: process.pid,
      uptimeSec: Math.floor(process.uptime()),
    });
  }

  return json(res, 404, { requestId, error: "not-found" });
});

server.listen(8080, "0.0.0.0", () => {
  console.log("runtime-api-up");
});

batch-processor/
├─ app/
│  ├─ batch.js
│  ├─ parser.js
│  └─ writer.js
└─ data/
   ├─ input.ndjson
   └─ output.json

import { parseInput } from "./parser.js";
import { writeOutput } from "./writer.js";

const inputPath = process.env.INPUT_PATH ?? "/tmp/input.ndjson";
const outputPath = process.env.OUTPUT_PATH ?? "/tmp/output.json";

const rows = await parseInput(inputPath);
const summary = {
  total: rows.length,
  byKind: rows.reduce((acc, row) => {
    acc[row.kind] = (acc[row.kind] ?? 0) + 1;
    return acc;
  }, {}),
};

await writeOutput(outputPath, summary);
console.log("batch-complete", summary);

gateway/
├─ app/
│  ├─ main.js
│  ├─ readers/
│  │  ├─ serial.js
│  │  └─ gpio.js
│  ├─ adapters/
│  │  ├─ mqtt.js
│  │  └─ http.js
│  └─ queue/
│     └─ memory-queue.js
└─ config/
   └─ devices.json

import { readFromDevices } from "./readers/serial.js";
import { publishBatch } from "./adapters/http.js";

setInterval(async () => {
  try {
    const samples = await readFromDevices();
    await publishBatch(samples);
    console.log("gateway-cycle-ok", { count: samples.length });
  } catch (error) {
    console.error("gateway-cycle-failed", error);
  }
}, 5000);

export type PluginContext = {
  env: Record<string, string | undefined>;
  logger: { info(msg: string, data?: unknown): void };
};

export interface PluginModule {
  id: string;
  setup(ctx: PluginContext): Promise<void>;
  execute(input: unknown): Promise<unknown>;
}

import { readdir } from "node:fs/promises";

export async function loadPluginModules(dir) {
  const files = await readdir(dir);
  const modules = [];

  for (const file of files) {
    if (!file.endsWith(".mjs")) continue;
    const mod = await import(`${dir}/${file}`);
    if (mod.default?.id && typeof mod.default.execute === "function") {
      modules.push(mod.default);
    }
  }

  return modules;
}

name: panos-release-check

on:
  push:
    branches: [main]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: ./0-install-deps.sh
      - run: ./1-build.sh
      - run: timeout 80s ./2-run.sh > boot.log 2>&1 || true
      - run: grep -E "PanOS|Shell Ready" boot.log

import assert from "node:assert/strict";
import { readFile } from "node:fs/promises";

const bootLog = await readFile("boot.log", "utf8");
assert.match(bootLog, /Shell Ready/);
assert.match(bootLog, /Linux version/);

console.log("release-contract-ok");

defaults -> file config -> env config -> runtime overrides

const defaults = {
  port: 8080,
  logLevel: "info",
  mode: "production",
};

const env = {
  port: Number(process.env.PORT ?? defaults.port),
  logLevel: process.env.LOG_LEVEL ?? defaults.logLevel,
  mode: process.env.MODE ?? defaults.mode,
};

export const config = { ...defaults, ...env };

export function log(level, event, data = {}) {
  console.log(
    JSON.stringify({
      ts: new Date().toISOString(),
      level,
      event,
      ...data,
    })
  );
}

import { log } from "./logger.js";

log("info", "startup", { node: process.version });
log("error", "upstream.timeout", { retries: 3 });