@verax-ai/body 0.1.0

package/dist/tools/message.d.ts

@@ -0,0 +1,4 @@
+import { type Principal, type ToolCall, type ToolResult } from "@verax-ai/proxy";
+export declare function messageRead(_call: ToolCall, stateDir: string, principal: Principal): Promise<ToolResult>;
+/** No-network stub: appends to the tenant outbox. Mail/WA reuse the same egress list. */
+export declare function messageSend(call: ToolCall, stateDir: string, ref: string, principal: Principal): Promise<ToolResult>;

package/dist/tools/message.js

@@ -0,0 +1,44 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tenantKey } from "@verax-ai/proxy";
+function tenantDir(stateDir, principal) {
+    return join(stateDir, "tenants", tenantKey(principal));
+}
+export async function messageRead(_call, stateDir, principal) {
+    const path = join(tenantDir(stateDir, principal), "inbox.jsonl");
+    let rows = [];
+    try {
+        const text = await readFile(path, "utf8");
+        rows = text
+            .split("\n")
+            .filter((line) => line !== "")
+            .map((line) => JSON.parse(line));
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(rows) }],
+        isError: false,
+    };
+}
+/** No-network stub: appends to the tenant outbox. Mail/WA reuse the same egress list. */
+export async function messageSend(call, stateDir, ref, principal) {
+    const row = {
+        to: call.arguments.to,
+        text: call.arguments.text,
+        ref,
+    };
+    const dir = tenantDir(stateDir, principal);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    appendFileSync(join(dir, "outbox.jsonl"), `${JSON.stringify(row)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify({ queued: true, ref }) }],
+        isError: false,
+    };
+}

package/dist/tools/spend.d.ts

@@ -0,0 +1,3 @@
+import type { ToolCall, ToolResult } from "@verax-ai/proxy";
+/** Authorizes a payment; does not move money. */
+export declare function spendAuthorize(call: ToolCall, ref: string): Promise<ToolResult>;

package/dist/tools/spend.js

@@ -0,0 +1,19 @@
+/** Authorizes a payment; does not move money. */
+export async function spendAuthorize(call, ref) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    authorized: true,
+                    ref,
+                    amountMinor: call.arguments.amountMinor,
+                    currency: call.arguments.currency,
+                    payee: call.arguments.payee,
+                    reference: call.arguments.reference,
+                }),
+            },
+        ],
+        isError: false,
+    };
+}

package/dist/unlock.d.ts

@@ -0,0 +1,9 @@
+export declare function pidAlive(pid: number): boolean;
+export declare function readLockFile(path: string): {
+    pid: number;
+    startedAt: number;
+} | null;
+export declare function runUnlock(stateDir: string, writeErr?: (s: string) => void, options?: {
+    force?: boolean;
+    unlink?: (path: string) => void;
+}): number;

package/dist/unlock.js

@@ -0,0 +1,109 @@
+import { appendFileSync, existsSync, readFileSync, unlinkSync } from "node:fs";
+import { userInfo } from "node:os";
+import { join } from "node:path";
+export function pidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+export function readLockFile(path) {
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof raw.pid !== "number" || typeof raw.startedAt !== "number")
+            return null;
+        return { pid: raw.pid, startedAt: raw.startedAt };
+    }
+    catch {
+        return null;
+    }
+}
+function operatorName() {
+    try {
+        const name = userInfo().username;
+        return name.length > 0 ? name : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function errnoCode(err) {
+    return err.code ?? "ERR";
+}
+function appendUnlockRow(stateDir, row) {
+    appendFileSync(join(stateDir, "unlocks.jsonl"), `${JSON.stringify(row)}\n`, {
+        encoding: "utf8",
+    });
+}
+export function runUnlock(stateDir, writeErr = (s) => process.stderr.write(s), options = {}) {
+    const lockPath = join(stateDir, "ledger.lock");
+    if (!existsSync(lockPath)) {
+        writeErr("no-lock\n");
+        return 1;
+    }
+    const existing = readLockFile(lockPath);
+    if (!existing) {
+        if (!options.force) {
+            writeErr("lock-unreadable\n");
+            return 1;
+        }
+    }
+    else if (pidAlive(existing.pid)) {
+        writeErr(`still-running:${existing.pid}\n`);
+        return 1;
+    }
+    const operator = operatorName();
+    const base = existing
+        ? {
+            removedPid: existing.pid,
+            startedAt: existing.startedAt,
+            operator,
+        }
+        : {
+            removedPid: null,
+            startedAt: null,
+            operator,
+            reason: "unreadable",
+        };
+    try {
+        appendUnlockRow(stateDir, { atMs: Date.now(), ...base, result: "removing" });
+    }
+    catch (err) {
+        writeErr(`record-failed:${errnoCode(err)}\n`);
+        return 1;
+    }
+    const unlink = options.unlink ?? unlinkSync;
+    try {
+        unlink(lockPath);
+    }
+    catch (err) {
+        const code = errnoCode(err);
+        try {
+            appendUnlockRow(stateDir, {
+                atMs: Date.now(),
+                ...base,
+                result: "unlink-failed",
+                error: code,
+            });
+        }
+        catch (recordErr) {
+            writeErr(`record-failed:${errnoCode(recordErr)}\n`);
+            return 1;
+        }
+        writeErr(`unlink-failed:${code}\n`);
+        return 1;
+    }
+    try {
+        appendUnlockRow(stateDir, { atMs: Date.now(), ...base, result: "removed" });
+    }
+    catch (err) {
+        writeErr(`record-failed:${errnoCode(err)}\n`);
+        return 1;
+    }
+    return 0;
+}

package/dist/wiring.d.ts

@@ -0,0 +1,23 @@
+import { createProxy, FileLedger, type EffectSigner, type ExplainOpts, type Principal, type RecordSigner, type ToolCall, type ToolResult } from "@verax-ai/proxy";
+export type ToolFn = (call: ToolCall, principal: Principal, ref?: string) => Promise<ToolResult>;
+export declare const TOOL_NAMES: readonly ["memory.get", "memory.put", "audit.explain", "message.read", "message.send", "spend"];
+export type BodyServices = {
+    proxy: ReturnType<typeof createProxy>;
+    ledger: FileLedger;
+    policyHash: string;
+    policyDocument: unknown;
+    listTools: () => readonly string[];
+    explainOpts: () => Promise<ExplainOpts>;
+};
+/**
+ * Tool functions live in a Map that is not exported. The only way to
+ * reach them at runtime is `proxy.call` -> `inner`.
+ */
+export declare function createBodyServices(opts: {
+    stateDir: string;
+    policyFile: string;
+    recordSigner: RecordSigner;
+    effectSigner: EffectSigner;
+    now?: () => number;
+    nonce?: () => string;
+}): BodyServices;

package/dist/wiring.js

@@ -0,0 +1,101 @@
+import { createProxy, FileLedger, loadPolicy, tenantKey, } from "@verax-ai/proxy";
+import { readFileSync } from "node:fs";
+import { persistPolicySnapshot } from "./policy-store.js";
+import { inputsPrincipal } from "./inputs-read.js";
+import { memoryBelongsToOtherTenant, memoryGet, memoryPut, readMemoryMeta } from "./tools/memory.js";
+import { auditExplain } from "./tools/audit.js";
+import { messageRead, messageSend } from "./tools/message.js";
+import { spendAuthorize } from "./tools/spend.js";
+import { requestWitnessSign } from "./witness.js";
+export const TOOL_NAMES = [
+    "memory.get",
+    "memory.put",
+    "audit.explain",
+    "message.read",
+    "message.send",
+    "spend",
+];
+/**
+ * Tool functions live in a Map that is not exported. The only way to
+ * reach them at runtime is `proxy.call` -> `inner`.
+ */
+export function createBodyServices(opts) {
+    const ledger = new FileLedger(opts.stateDir);
+    ledger.remoteWitness = (row, resultHash) => requestWitnessSign(opts.stateDir, row, resultHash);
+    const policyText = readFileSync(opts.policyFile, "utf8");
+    const policyDocument = JSON.parse(policyText);
+    const policy = loadPolicy(policyText);
+    persistPolicySnapshot(opts.stateDir, policy.hash, policyDocument);
+    const now = opts.now ?? (() => Date.now());
+    const nonce = opts.nonce ?? (() => crypto.randomUUID());
+    const registry = new Map();
+    registry.set("memory.get", (call, principal) => memoryGet(call, opts.stateDir, now, principal));
+    registry.set("memory.put", (call, principal) => memoryPut(call, opts.stateDir, principal));
+    const explainOpts = async () => {
+        const env = process.env.VERAX_RECORD_PUBKEY_PIN;
+        const pem = env && env.trim() !== "" ? env : opts.recordSigner.publicKeyPem;
+        return {
+            ...(pem
+                ? {
+                    issuerTrust: {
+                        publicKeyPem: pem,
+                        source: env && env.trim() !== "" ? "env" : "own-key",
+                    },
+                }
+                : {}),
+        };
+    };
+    registry.set("audit.explain", async (call) => auditExplain(call, ledger, await explainOpts()));
+    registry.set("message.read", (call, principal) => messageRead(call, opts.stateDir, principal));
+    registry.set("message.send", (call, principal, ref) => messageSend(call, opts.stateDir, ref ?? "", principal));
+    registry.set("spend", (call, _principal, ref) => spendAuthorize(call, ref ?? ""));
+    const inner = async (call, principal, ref) => {
+        const fn = registry.get(call.name);
+        if (!fn) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "unknown-tool", name: call.name }) }],
+                isError: true,
+            };
+        }
+        return fn(call, principal, ref);
+    };
+    const proxy = createProxy({
+        policy,
+        recordSigner: opts.recordSigner,
+        effectSigner: opts.effectSigner,
+        ledger,
+        now,
+        nonce,
+        inner,
+        resolveInput: (id, principal) => readMemoryMeta(opts.stateDir, id, principal),
+        checkTenantMismatch: async (call, principal) => {
+            if (call.name === "memory.get") {
+                const id = call.arguments.id;
+                if (typeof id !== "string")
+                    return false;
+                return memoryBelongsToOtherTenant(opts.stateDir, id, tenantKey(principal));
+            }
+            if (call.name === "audit.explain") {
+                const ref = call.arguments.ref;
+                if (typeof ref !== "string" || ref === "")
+                    return false;
+                const decisions = await ledger.decisions();
+                if (!decisions.some((d) => d.claims.ref === ref))
+                    return false;
+                const owner = await inputsPrincipal(opts.stateDir, ref);
+                if (owner === null)
+                    return true;
+                return tenantKey(owner) !== tenantKey(principal);
+            }
+            return false;
+        },
+    });
+    return {
+        proxy,
+        ledger,
+        policyHash: policy.hash,
+        policyDocument,
+        listTools: () => TOOL_NAMES,
+        explainOpts,
+    };
+}

package/dist/witness.d.ts

@@ -0,0 +1,33 @@
+import { writeFileAtomic } from "./atomic-write.ts";
+import { type SignedCheckpoint } from "@cedulon/checkpoint";
+import { type LedgerEffect } from "@verax-ai/proxy";
+export type WitnessListen = {
+    pid: number;
+    port: number;
+    token: string;
+    publicKeyPem: string;
+    startedAt: number;
+};
+type EffectRowWire = {
+    ref: string;
+    effectHash: string;
+    effectClass: string;
+    timestampMs: number;
+    actor?: string;
+};
+/** The same writer the listen file goes through, so its test measures it. */
+export declare const writeListenForTest: typeof writeFileAtomic;
+export declare function loadOrCreateWitnessKeys(stateDir: string): {
+    privateKeyPem: string;
+    publicKeyPem: string;
+};
+export declare function readWitnessListen(stateDir: string): WitnessListen | null;
+export type CheckpointWindow = {
+    epoch: number;
+    startMs: number;
+    endMs: number;
+};
+export declare function requestWitnessCheckpoint(stateDir: string, window: CheckpointWindow): Promise<SignedCheckpoint | null>;
+export declare function requestWitnessSign(stateDir: string, row: EffectRowWire, resultHash: string | undefined): Promise<Pick<LedgerEffect, "receipt" | "attestation" | "witnessClass"> | null>;
+export declare function runWitness(stateDir: string): Promise<void>;
+export {};

package/dist/witness.js

@@ -0,0 +1,321 @@
+import { randomBytes, generateKeyPairSync } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { createServer } from "node:http";
+import { join } from "node:path";
+import { writeFileAtomic } from "./atomic-write.js";
+import { buildCheckpointClaims, checkpointHash, signCheckpoint, totalsFromDecisionRecords, } from "@cedulon/checkpoint";
+import { decisionRecordHash } from "@cedulon/core";
+import { checkpointsPath, signEffectAttestation } from "@verax-ai/proxy";
+import { pidAlive } from "./unlock.js";
+const WITNESS_CLASS = "same-org";
+function listenPath(stateDir) {
+    return join(stateDir, "witness.listen.json");
+}
+function statusPath(stateDir) {
+    return join(stateDir, "witness-status.jsonl");
+}
+function writePemAtomic(path, pem) {
+    writeFileAtomic(path, pem);
+}
+/** The same writer the listen file goes through, so its test measures it. */
+export const writeListenForTest = writeFileAtomic;
+export function loadOrCreateWitnessKeys(stateDir) {
+    const dir = join(stateDir, "keys");
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const priv = join(dir, "witness.private.pem");
+    const pub = join(dir, "witness.public.pem");
+    if (existsSync(priv) && existsSync(pub)) {
+        return { privateKeyPem: readFileSync(priv, "utf8"), publicKeyPem: readFileSync(pub, "utf8") };
+    }
+    if (existsSync(priv) || existsSync(pub)) {
+        throw new Error("witness-keys-partial");
+    }
+    const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+    const pair = {
+        publicKeyPem: publicKey.export({ type: "spki", format: "pem" }).toString(),
+        privateKeyPem: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
+    };
+    writePemAtomic(priv, pair.privateKeyPem);
+    writePemAtomic(pub, pair.publicKeyPem);
+    return pair;
+}
+export function readWitnessListen(stateDir) {
+    try {
+        const raw = JSON.parse(readFileSync(listenPath(stateDir), "utf8"));
+        if (typeof raw.pid !== "number" ||
+            typeof raw.port !== "number" ||
+            typeof raw.token !== "string" ||
+            typeof raw.publicKeyPem !== "string") {
+            return null;
+        }
+        return {
+            pid: raw.pid,
+            port: raw.port,
+            token: raw.token,
+            publicKeyPem: raw.publicKeyPem,
+            startedAt: typeof raw.startedAt === "number" ? raw.startedAt : 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function appendStatus(stateDir, row) {
+    appendFileSync(statusPath(stateDir), `${JSON.stringify(row)}\n`, { encoding: "utf8" });
+}
+function asRow(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const o = raw;
+    if (typeof o.ref !== "string" ||
+        typeof o.effectHash !== "string" ||
+        typeof o.effectClass !== "string" ||
+        typeof o.timestampMs !== "number") {
+        return null;
+    }
+    return {
+        ref: o.ref,
+        effectHash: o.effectHash,
+        effectClass: o.effectClass,
+        timestampMs: o.timestampMs,
+        ...(typeof o.actor === "string" ? { actor: o.actor } : {}),
+    };
+}
+async function readJson(req, limit = 65_536) {
+    const chunks = [];
+    let n = 0;
+    for await (const chunk of req) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        n += buf.length;
+        if (n > limit)
+            throw new Error("too-large");
+        chunks.push(buf);
+    }
+    const text = Buffer.concat(chunks).toString("utf8");
+    return text === "" ? {} : JSON.parse(text);
+}
+function send(res, status, body) {
+    const text = JSON.stringify(body);
+    res.writeHead(status, {
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(text),
+        "x-content-type-options": "nosniff",
+    });
+    res.end(text);
+}
+function loadDecisions(stateDir) {
+    try {
+        const text = readFileSync(join(stateDir, "decisions.jsonl"), "utf8");
+        const out = [];
+        for (const line of text.split("\n")) {
+            if (line === "")
+                continue;
+            out.push(JSON.parse(line));
+        }
+        return out;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+}
+function lastCheckpointHash(stateDir) {
+    try {
+        const text = readFileSync(checkpointsPath(stateDir), "utf8").trim();
+        if (text === "")
+            return null;
+        const lines = text.split("\n").filter((l) => l !== "");
+        const last = JSON.parse(lines[lines.length - 1] ?? "{}");
+        if (typeof last.coseHex !== "string" || !last.claims)
+            return null;
+        return checkpointHash(last);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        return null;
+    }
+}
+function signWindowCheckpoint(stateDir, window, keys) {
+    const startMs = window.startMs;
+    const endMs = window.endMs;
+    const inWindow = loadDecisions(stateDir).filter((d) => d.claims.timestampMs >= startMs && d.claims.timestampMs < endMs);
+    const claims = buildCheckpointClaims(window.epoch, inWindow, startMs, endMs, lastCheckpointHash(stateDir), totalsFromDecisionRecords, (row) => decisionRecordHash(row));
+    const signed = signCheckpoint(claims, keys.privateKeyPem, keys.publicKeyPem);
+    appendFileSync(checkpointsPath(stateDir), `${JSON.stringify(signed)}\n`, { encoding: "utf8" });
+    return signed;
+}
+export async function requestWitnessCheckpoint(stateDir, window) {
+    const listen = readWitnessListen(stateDir);
+    if (!listen || !pidAlive(listen.pid))
+        return null;
+    try {
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), 800);
+        const res = await fetch(`http://127.0.0.1:${listen.port}/checkpoint`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ token: listen.token, ...window }),
+            signal: ac.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        if (typeof body.coseHex !== "string" || !body.claims)
+            return null;
+        return body;
+    }
+    catch {
+        return null;
+    }
+}
+export async function requestWitnessSign(stateDir, row, resultHash) {
+    const listen = readWitnessListen(stateDir);
+    if (!listen || !pidAlive(listen.pid)) {
+        appendStatus(stateDir, {
+            atMs: Date.now(),
+            ref: row.ref,
+            result: "self-fallback",
+            reason: "unreachable",
+        });
+        return null;
+    }
+    try {
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), 400);
+        const res = await fetch(`http://127.0.0.1:${listen.port}/sign`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ token: listen.token, row, resultHash: resultHash ?? null }),
+            signal: ac.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok) {
+            appendStatus(stateDir, {
+                atMs: Date.now(),
+                ref: row.ref,
+                result: "self-fallback",
+                reason: "unreachable",
+            });
+            return null;
+        }
+        const body = (await res.json());
+        if (body.witnessClass !== WITNESS_CLASS || !body.receipt || !body.attestation?.coseHex) {
+            appendStatus(stateDir, {
+                atMs: Date.now(),
+                ref: row.ref,
+                result: "self-fallback",
+                reason: "unreachable",
+            });
+            return null;
+        }
+        appendStatus(stateDir, { atMs: Date.now(), ref: row.ref, result: "signed", pid: listen.pid });
+        return {
+            witnessClass: WITNESS_CLASS,
+            receipt: body.receipt,
+            attestation: body.attestation,
+        };
+    }
+    catch {
+        appendStatus(stateDir, {
+            atMs: Date.now(),
+            ref: row.ref,
+            result: "self-fallback",
+            reason: "unreachable",
+        });
+        return null;
+    }
+}
+export async function runWitness(stateDir) {
+    mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+    const existing = readWitnessListen(stateDir);
+    if (existing && pidAlive(existing.pid)) {
+        process.stderr.write(`witness-already-running:${existing.pid}\n`);
+        process.exit(1);
+    }
+    const keys = loadOrCreateWitnessKeys(stateDir);
+    const token = randomBytes(16).toString("hex");
+    const server = createServer((req, res) => {
+        void (async () => {
+            try {
+                const url = new URL(req.url ?? "/", "http://127.0.0.1");
+                if (req.method === "GET" && url.pathname === "/health") {
+                    send(res, 200, { ok: true, pid: process.pid });
+                    return;
+                }
+                if (req.method === "POST" && url.pathname === "/sign") {
+                    const body = (await readJson(req));
+                    if (body.token !== token) {
+                        send(res, 401, { error: "unauthorized" });
+                        return;
+                    }
+                    const row = asRow(body.row);
+                    if (!row) {
+                        send(res, 400, { error: "row-invalid" });
+                        return;
+                    }
+                    const resultHash = typeof body.resultHash === "string" ? body.resultHash : undefined;
+                    const signed = signEffectAttestation(row, WITNESS_CLASS, resultHash, keys);
+                    send(res, 200, { witnessClass: WITNESS_CLASS, ...signed });
+                    return;
+                }
+                if (req.method === "POST" && url.pathname === "/checkpoint") {
+                    const body = (await readJson(req));
+                    if (body.token !== token) {
+                        send(res, 401, { error: "unauthorized" });
+                        return;
+                    }
+                    if (typeof body.epoch !== "number" ||
+                        !Number.isInteger(body.epoch) ||
+                        typeof body.startMs !== "number" ||
+                        typeof body.endMs !== "number" ||
+                        body.endMs <= body.startMs) {
+                        send(res, 400, { error: "window-invalid" });
+                        return;
+                    }
+                    const signed = signWindowCheckpoint(stateDir, { epoch: body.epoch, startMs: body.startMs, endMs: body.endMs }, keys);
+                    send(res, 200, signed);
+                    return;
+                }
+                send(res, 404, { error: "not-found" });
+            }
+            catch {
+                send(res, 400, { error: "bad-request" });
+            }
+        })();
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const addr = server.address();
+    if (!addr || typeof addr === "string") {
+        server.close();
+        throw new Error("witness-bind");
+    }
+    const listen = {
+        pid: process.pid,
+        port: addr.port,
+        token,
+        publicKeyPem: keys.publicKeyPem,
+        startedAt: Date.now(),
+    };
+    writeFileAtomic(listenPath(stateDir), `${JSON.stringify(listen)}\n`);
+    process.stderr.write(`witness-pid:${process.pid}\n`);
+    process.stderr.write(`witness-port:${addr.port}\n`);
+    await new Promise((resolve) => {
+        const shutdown = () => {
+            try {
+                unlinkSync(listenPath(stateDir));
+            }
+            catch {
+                // already gone
+            }
+            server.close(() => resolve());
+        };
+        process.once("SIGINT", shutdown);
+        process.once("SIGTERM", shutdown);
+    });
+}