Admin UI -> HTTP API (PanOS guest) -> Local JSON state

// /app/internal-api.js
import http from "node:http";
import { readFile, writeFile } from "node:fs/promises";

const dbPath = "/tmp/state.json";

async function loadState() {
  try {
    return JSON.parse(await readFile(dbPath, "utf8"));
  } catch {
    return { tickets: [] };
  }
}

async function saveState(state) {
  await writeFile(dbPath, JSON.stringify(state, null, 2));
}

http
  .createServer(async (req, res) => {
    if (req.method === "GET" && req.url === "/tickets") {
      const state = await loadState();
      res.writeHead(200, { "content-type": "application/json" });
      res.end(JSON.stringify(state.tickets));
      return;
    }

    if (req.method === "POST" && req.url === "/tickets") {
      let body = "";
      req.on("data", (chunk) => (body += chunk));
      req.on("end", async () => {
        const payload = JSON.parse(body || "{}");
        const state = await loadState();
        const ticket = { id: crypto.randomUUID(), ...payload };
        state.tickets.push(ticket);
        await saveState(state);
        res.writeHead(201, { "content-type": "application/json" });
        res.end(JSON.stringify(ticket));
      });
      return;
    }

    res.writeHead(404);
    res.end("not found");
  })
  .listen(8080, () => {
    console.log("internal-api-ready");
  });

curl -s http://127.0.0.1:8080/tickets
curl -s -X POST http://127.0.0.1:8080/tickets -d '{"title":"Boot issue"}'

// /app/bridge.js
import http from "node:http";
import os from "node:os";

http
  .createServer((req, res) => {
    if (req.url === "/v1/diagnostics") {
      res.writeHead(200, { "content-type": "application/json" });
      res.end(
        JSON.stringify({
          node: process.version,
          cpus: os.cpus().length,
          loadavg: os.loadavg(),
          uptime: process.uptime(),
        })
      );
      return;
    }

    res.writeHead(404);
    res.end();
  })
  .listen(8090);

// web/src/features/runtime/getDiagnostics.ts
export type RuntimeDiagnostics = {
  node: string;
  cpus: number;
  loadavg: [number, number, number];
  uptime: number;
};

export async function getDiagnostics(apiBase: string): Promise<RuntimeDiagnostics> {
  const response = await fetch(`${apiBase}/v1/diagnostics`, {
    headers: { accept: "application/json" },
  });

  if (!response.ok) {
    throw new Error(`Diagnostics request failed: ${response.status}`);
  }

  return response.json();
}

// /app/batch.js
import { readFile, writeFile } from "node:fs/promises";

const inPath = process.env.INPUT_FILE ?? "/tmp/input.ndjson";
const outPath = process.env.OUTPUT_FILE ?? "/tmp/report.json";

const lines = (await readFile(inPath, "utf8")).trim().split("\n");
const events = lines.map((line) => JSON.parse(line));

const byType = events.reduce((acc, event) => {
  acc[event.type] = (acc[event.type] ?? 0) + 1;
  return acc;
}, {});

const report = {
  generatedAt: new Date().toISOString(),
  total: events.length,
  byType,
};

await writeFile(outPath, JSON.stringify(report, null, 2));
console.log("report-ready", outPath);

#!/usr/bin/env bash
set -euo pipefail

./1-build.sh

timeout 80s ./2-run.sh > /tmp/boot.log 2>&1 || true

if ! grep -q "Shell Ready" /tmp/boot.log; then
  echo "PanOS failed to boot"
  cat /tmp/boot.log
  exit 1
fi

echo "PanOS boot smoke passed"

// tools/assert-runtime-contract.mjs
import assert from "node:assert/strict";

const response = await fetch("http://127.0.0.1:8080/runtime");
assert.equal(response.status, 200);

const body = await response.json();
assert.equal(typeof body.node, "string");
assert.equal(typeof body.uptimeSec, "number");

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

sensor read -> normalize -> buffer -> publish -> ack -> rotate logs

// /app/gateway-core.js
import { appendFile } from "node:fs/promises";

function normalize(raw) {
  return {
    id: raw.id,
    ts: Date.now(),
    temperatureC: Number(raw.temp),
    pressureKpa: Number(raw.pressure),
  };
}

async function publish(event) {
  await appendFile("/tmp/gateway.log", JSON.stringify(event) + "\n");
  return true;
}

export async function processReading(raw) {
  const event = normalize(raw);
  const ok = await publish(event);
  if (!ok) throw new Error("publish-failed");
  return event;
}

// /app/plugin-host.js
import { readdir } from "node:fs/promises";

export async function loadPlugins(pluginDir = "/app/plugins") {
  const entries = await readdir(pluginDir);
  const plugins = [];

  for (const entry of entries) {
    if (!entry.endsWith(".mjs")) continue;
    const module = await import(`${pluginDir}/${entry}`);
    if (typeof module.setup === "function") {
      plugins.push(await module.setup());
    }
  }

  return plugins;
}