@noopolis/daimon 0.1.2 → 0.2.1

package/dist/runtime/engineBrokerSealLedger.js

@@ -0,0 +1,132 @@
+import { ENGINE_BROKER_MCP_CALL_NAME, ENGINE_BROKER_MCP_OUTSTANDING_MAX, ENGINE_BROKER_MCP_REFUSAL_REASONS, ENGINE_BROKER_MCP_TUNNEL_MAX } from "./engineBrokerMcpCallLog.js";
+import { TURN_USAGE_LEDGER, TURN_USAGE_MAX_IDENTIFIER_CHARS } from "./turnUsageLedger.js";
+/**
+ * The operator-visible half of a sealed terminal turn, as a durable row.
+ *
+ * The seal itself already carries everything an operator needs to read a turn
+ * that stopped acting — the failure code, the worker's own redacted last words,
+ * and `engineBrokerMcpCallLog.ts`'s observation of the tool call the worker was
+ * blocked on. All of it travels in the control-protocol terminal response, and
+ * that response is the one artifact a *hung* turn never produces: the client is
+ * gone before the broker answers, the turn registry record lives in the
+ * broker's own `0700` turn store, and a training slot's control root is tmpfs
+ * that dies with the container. Six live runs reproduced the same signature and
+ * none of them could read the instrument built for it.
+ *
+ * What does survive a slot is the broker's ledger directory: Paideia already
+ * recovers `usage.jsonl` and `requests.jsonl` from it on the failure path. So
+ * this is a third stream beside those two, written by the broker — still the
+ * single sealed usage writer — from the sealed response and nothing else, at
+ * the moment that response is sealed.
+ *
+ * Its rules are the two ledgers' rules:
+ *
+ * - **Numbers, names, timings and closed vocabularies only.** The failure code,
+ *   the accounting, the diagnostic's closed `status`/`stage`/`failure_class`
+ *   and its already-redacted, already-bounded, control-character-free `reason`
+ *   (`engineBrokerNativeClient.ts` produced it; nothing here re-derives it),
+ *   plus tool-call names, GET-tunnel counts and elapsed milliseconds. Never a
+ *   prompt, a body, a
+ *   reply, a bearer, a capability or a session id — none of which the terminal
+ *   response carries in the first place.
+ * - **Absence stays absence.** `mcp` is written only when the facade actually
+ *   observed the turn, `diagnostic` only when the sealed response carried one,
+ *   and `code` only for a failure. A turn that called no tool publishes
+ *   `started: 0`, which is a measurement; a turn the facade never registered
+ *   publishes no `mcp` member at all, which is not.
+ * - **It can never fail a turn.** The row is rendered from an
+ *   already-validated frame and appended through `recordLedgerLines`, which
+ *   swallows every I/O fault.
+ *
+ * A separate stream and a separate `v`, for `turnRequestLedger.ts`'s reason:
+ * Spawnfile's reader pins `noopolis.daimon.turn-usage.v1` and drops any other
+ * `v` outright, and Paideia's request reader refuses a row it cannot type. A
+ * row in a new file is invisible to both.
+ */
+export const TURN_SEAL_LEDGER_VERSION = "noopolis.daimon.turn-seal.v1";
+/** Default location: beside `usage.jsonl` and `requests.jsonl`, no new mount. */
+export const TURN_SEAL_LEDGER = {
+    version: TURN_SEAL_LEDGER_VERSION,
+    directoryPath: TURN_USAGE_LEDGER.directoryPath,
+    filePath: `${TURN_USAGE_LEDGER.directoryPath}/turns.jsonl`,
+    rotatedFilePath: `${TURN_USAGE_LEDGER.directoryPath}/turns.jsonl.1`,
+    fileMode: TURN_USAGE_LEDGER.fileMode
+};
+/** A rendered seal line is bounded by its own contents: a 768-byte reason, 16 bounded names and 8 tunnel timings. */
+export const TURN_SEAL_MAX_LINE_BYTES = 8_192;
+const bounded = (value) => [...value].slice(0, TURN_USAGE_MAX_IDENTIFIER_CHARS).join("");
+/**
+ * One newline-terminated row for one sealed terminal turn.
+ *
+ * Every member is copied from the terminal response the protocol already
+ * validated, so this projection cannot widen what the response admits; it is an
+ * allow-list rather than a spread, so a future additive member of the response
+ * does not silently become a ledger field.
+ */
+export const renderBrokerTurnSealLine = (terminal, entry) => `${JSON.stringify({
+    v: TURN_SEAL_LEDGER_VERSION,
+    agent: bounded(entry.agent),
+    wake: bounded(entry.wake),
+    engine: "grok",
+    at: entry.at,
+    turn: terminal.turnId,
+    outcome: terminal.outcome,
+    requests: terminal.requests,
+    model: terminal.model,
+    limit_reason: terminal.limitReason,
+    ...(terminal.shellClock === undefined ? {} : { shell_clock: terminal.shellClock }),
+    ...(terminal.providerClock === undefined ? {} : { provider_clock: {
+            requests: terminal.providerClock.requests,
+            linesRewritten: terminal.providerClock.linesRewritten,
+            requestsWithoutDateLine: terminal.providerClock.requestsWithoutDateLine,
+            ...(terminal.providerClock.linesIgnored === undefined ? {} : { linesIgnored: terminal.providerClock.linesIgnored }),
+            injectedDate: terminal.providerClock.injectedDate,
+            taskDate: terminal.providerClock.taskDate
+        } }),
+    ...(terminal.kind === "failed" ? { code: terminal.code } : {}),
+    ...(terminal.kind === "failed" && terminal.diagnostic !== undefined
+        ? {
+            diagnostic: {
+                status: terminal.diagnostic.status,
+                stage: terminal.diagnostic.stage,
+                failure_class: terminal.diagnostic.failureClass,
+                exit_code: terminal.diagnostic.exitCode,
+                term_signal: terminal.diagnostic.termSignal,
+                ...(terminal.diagnostic.reason === undefined ? {} : { reason: terminal.diagnostic.reason })
+            }
+        }
+        : {}),
+    ...(terminal.kind === "failed" && terminal.mcpCalls !== undefined
+        ? {
+            mcp: {
+                started: terminal.mcpCalls.started,
+                answered: terminal.mcpCalls.answered,
+                undecoded: terminal.mcpCalls.undecoded,
+                outstanding: terminal.mcpCalls.outstanding
+                    .slice(0, ENGINE_BROKER_MCP_OUTSTANDING_MAX)
+                    .map((call) => ({ name: ENGINE_BROKER_MCP_CALL_NAME.test(call.name) ? call.name : "<invalid>", outstanding_ms: call.outstandingMs })),
+                // Every request the facade refused before it could relay it, by reason
+                // class. Without it a turn whose capability was spent seals as
+                // `answered == started, outstanding: []`, which is what a healthy turn
+                // seals as.
+                ...(terminal.mcpCalls.refusals === undefined
+                    ? {}
+                    : { refusals: Object.fromEntries(ENGINE_BROKER_MCP_REFUSAL_REASONS.map((reason) => [reason, terminal.mcpCalls.refusals[reason]])) }),
+                // The session's standalone GET tunnel, absent for a turn sealed before
+                // the facade observed that channel at all.
+                ...(terminal.mcpCalls.tunnels === undefined
+                    ? {}
+                    : {
+                        tunnels: {
+                            opened: terminal.mcpCalls.tunnels.opened,
+                            closed: terminal.mcpCalls.tunnels.closed,
+                            delivered: terminal.mcpCalls.tunnels.delivered,
+                            open: terminal.mcpCalls.tunnels.open
+                                .slice(0, ENGINE_BROKER_MCP_TUNNEL_MAX)
+                                .map((tunnel) => ({ open_ms: tunnel.openMs, delivered: tunnel.delivered }))
+                        }
+                    })
+            }
+        }
+        : {})
+})}\n`;

package/dist/runtime/engineBrokerService.d.ts

@@ -0,0 +1,43 @@
+import { type BrokerClockObservation } from "./grokBrokerTaskClock.js";
+import { type Socket } from "node:net";
+import { type EngineBrokerCleanupObservation } from "./engineBrokerProtocol.js";
+import type { EngineBrokerTurnAccounting, EngineBrokerTurnLimitOverrides } from "./engineBrokerTurnAccounting.js";
+import { type GrokInferenceGrantIssued, type GrokInferenceGrantRequest } from "./grokInferenceGrants.js";
+export interface EngineBrokerServiceEngine {
+    turn(agentId: string, wakeId: string, prompt: string, mcpEndpoint: string, signal?: AbortSignal, limits?: EngineBrokerTurnLimitOverrides, processClock?: string, slot?: number): Promise<Readonly<{
+        text: string;
+        workerPid: number;
+        workerUid: number;
+        workerStartTime: string;
+    }> & EngineBrokerTurnAccounting & BrokerClockObservation & EngineBrokerCleanupObservation>;
+    readiness(): Readonly<{
+        providerProxyPort: number;
+        mcpFacadePort: number;
+        registrations: number;
+        credentialStale: boolean;
+        realmLease: boolean;
+        workerIsolation: boolean;
+    }>;
+    close(): Promise<void>;
+    resetSlot?(slot: number): Promise<void>;
+    /** Evaluator inference grants; an engine without them refuses every grant request as `unavailable`. Refusals throw {@link GrokInferenceGrantRefused}. */
+    requestInferenceGrant?(request: GrokInferenceGrantRequest): GrokInferenceGrantIssued;
+    releaseInferenceGrant?(grantId: string): boolean;
+}
+export declare function startEngineBrokerService(broker: EngineBrokerServiceEngine, socketPath?: string): Promise<{
+    close: () => Promise<void>;
+    health: () => {
+        activeTurns: number;
+        socketPath: string;
+    };
+}>;
+export declare function startEngineBrokerServiceWithIdentity(broker: EngineBrokerServiceEngine, socketPath: string, expectedUid: number): Promise<{
+    close: () => Promise<void>;
+    health: () => {
+        activeTurns: number;
+        socketPath: string;
+    };
+}>;
+/** @internal The production connection handler, also exercised over an in-memory transport. */
+export declare function serveEngineBrokerConnection(socket: Socket, broker: EngineBrokerServiceEngine, active?: Map<string, AbortController>): void;
+//# sourceMappingURL=engineBrokerService.d.ts.map

package/dist/runtime/engineBrokerService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerService.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerService.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAE/F,OAAO,EAA6B,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,EAEqB,KAAK,8BAA8B,EAC9D,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,0BAA0B,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AAGlH,OAAO,EAA6B,KAAK,wBAAwB,EAAE,KAAK,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AACpI,MAAM,WAAW,yBAAyB;IACxC,IAAI,CACF,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EACpE,MAAM,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,8BAA8B,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAClG,OAAO,CAAC,QAAQ,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;KAC7E,CAAC,GAAG,0BAA0B,GAAG,sBAAsB,GAAG,8BAA8B,CAAC,CAAC;IAC3F,SAAS,IAAG,QAAQ,CAAC;QAAC,iBAAiB,EAAC,MAAM,CAAC;QAAA,aAAa,EAAC,MAAM,CAAC;QAAA,aAAa,EAAC,MAAM,CAAC;QAAA,eAAe,EAAC,OAAO,CAAC;QAAA,UAAU,EAAC,OAAO,CAAC;QAAA,eAAe,EAAC,OAAO,CAAA;KAAC,CAAC,CAAC;IAC9J,KAAK,IAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,SAAS,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,yJAAyJ;IACzJ,qBAAqB,CAAC,CAAC,OAAO,EAAC,yBAAyB,GAAE,wBAAwB,CAAC;IACnF,qBAAqB,CAAC,CAAC,OAAO,EAAC,MAAM,GAAE,OAAO,CAAC;CAChD;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAC,yBAAyB,EAAC,UAAU,SAAyC;;;;;;GAE5H;AACD,wBAAsB,oCAAoC,CAAC,MAAM,EAAC,yBAAyB,EAAC,UAAU,EAAC,MAAM,EAAC,WAAW,EAAC,MAAM;;;;;;GAU/H;AAoBD,+FAA+F;AAC/F,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,yBAAyB,EAAE,MAAM,+BAAqC,GAC7F,IAAI,CA0EN"}

package/dist/runtime/engineBrokerService.js

@@ -0,0 +1,196 @@
+import { brokerClockObservation } from "./grokBrokerTaskClock.js";
+import { chmod, lstat, unlink } from "node:fs/promises";
+import { createServer } from "node:net";
+import { encodeEngineBrokerFrame, EngineBrokerFrameDecoder, EngineBrokerProtocolMismatch, parseEngineBrokerRequest } from "./engineBrokerProtocol.js";
+import { EngineBrokerTurnFailure } from "./grokEngineBroker.js";
+import { GROK_INFERENCE_PROXY_BASE_URL } from "./engineBrokerInferenceProtocol.js";
+import { GrokInferenceGrantRefused } from "./grokInferenceGrants.js";
+export function startEngineBrokerService(broker, socketPath = "/run/daimon-engine-broker/backend.sock") {
+    return startEngineBrokerServiceWithIdentity(broker, socketPath, 2100);
+}
+export async function startEngineBrokerServiceWithIdentity(broker, socketPath, expectedUid) {
+    if (process.getuid?.() !== expectedUid)
+        throw new Error("engine broker service requires broker identity");
+    await removeOwnedSocket(socketPath, expectedUid);
+    const active = new Map(), connections = new Set();
+    const server = createServer((socket) => {
+        connections.add(socket);
+        socket.once("close", () => connections.delete(socket));
+        serveEngineBrokerConnection(socket, broker, active);
+    });
+    await listen(server, socketPath);
+    try {
+        await chmod(socketPath, 0o600);
+        await verifySocket(socketPath, expectedUid);
+    }
+    catch (error) {
+        await closeServer(server, connections);
+        await unlink(socketPath).catch(() => undefined);
+        throw error;
+    }
+    let closed = false;
+    return { close: async () => { if (closed)
+            return; closed = true; for (const controller of active.values())
+            controller.abort(); const results = await Promise.allSettled([closeServer(server, connections), broker.close()]); await unlink(socketPath).catch(() => undefined); const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []); if (failures.length)
+            throw new AggregateError(failures, "engine broker service shutdown failed"); }, health: () => ({ activeTurns: active.size, socketPath }) };
+}
+/**
+ * A connection error is a client that went away, never a reason to take the
+ * broker down with it.
+ *
+ * Without this listener an accepted socket that emits `error` had none, and
+ * node turns an unhandled `error` on a stream into an uncaught exception — so a
+ * single departing client killed the whole service and every other in-flight
+ * turn with it. That is reachable from the ordinary cancellation path: the
+ * client destroys its socket on abort, this side aborts the turn, the engine
+ * rejects, and this side then writes a `failed` frame to a peer that is already
+ * gone. On Linux that write/read races an RST and surfaces as ECONNRESET; macOS
+ * closes cleanly enough that the error never arrives, which is why this was
+ * invisible until the suite ran in a container.
+ *
+ * Treated exactly like `close`: abort whatever turn this connection owned and
+ * drop the socket. The turn's own result is already unreachable — its only
+ * reader has disconnected.
+ */
+function handleSocketError(socket, owned) { socket.on("error", () => { owned()?.controller.abort(); socket.destroy(); }); }
+/** @internal The production connection handler, also exercised over an in-memory transport. */
+export function serveEngineBrokerConnection(socket, broker, active = new Map()) {
+    const decoder = new EngineBrokerFrameDecoder();
+    let started = false;
+    let owned;
+    handleSocketError(socket, () => owned);
+    socket.once("close", () => owned?.controller.abort());
+    socket.on("data", (chunk) => {
+        try {
+            for (const value of decoder.push(chunk)) {
+                const request = parseEngineBrokerRequest(value);
+                if (request.kind === "health") {
+                    if (started)
+                        throw new Error();
+                    started = true;
+                    const ready = broker.readiness();
+                    if (ready.providerProxyPort !== 43123 || ready.mcpFacadePort !== 43124 ||
+                        ready.registrations < 1 || ready.credentialStale || !ready.realmLease || !ready.workerIsolation) {
+                        throw new Error();
+                    }
+                    return send(socket, {
+                        version: request.version, kind: "ready", requestId: request.requestId, brokerUid: 2100,
+                        providerProxyPort: 43123, mcpFacadePort: 43124, registrations: ready.registrations,
+                        credentialStale: false, realmLease: true, workerIsolation: true
+                    });
+                }
+                if (request.kind === "cancel_turn") {
+                    if (owned?.turnId !== request.turnId)
+                        throw new Error("turn not owned by connection");
+                    owned.controller.abort();
+                    continue;
+                }
+                if (request.kind === "request_inference_grant" || request.kind === "release_inference_grant") {
+                    if (started)
+                        throw new Error();
+                    started = true;
+                    serveInferenceGrant(socket, broker, request);
+                    continue;
+                }
+                if (request.kind === "reset_slot") {
+                    if (started || broker.resetSlot === undefined)
+                        throw new Error();
+                    started = true;
+                    void broker.resetSlot(request.slot).then(() => send(socket, {
+                        version: request.version, kind: "slot_reset", requestId: request.requestId, slot: request.slot
+                    }), () => socket.destroy());
+                    continue;
+                }
+                const key = `${request.slot ?? request.agentId}:${request.turnId}`;
+                if (started || active.has(key))
+                    throw new Error();
+                started = true;
+                const controller = new AbortController();
+                owned = { turnId: request.turnId, controller };
+                active.set(key, controller);
+                socket.write(encodeEngineBrokerFrame({
+                    version: request.version, kind: "accepted", requestId: request.requestId, turnId: request.turnId
+                }));
+                void broker.turn(request.agentId, request.wakeId, request.prompt, request.mcpEndpoint, controller.signal, request.limits, request.processClock, request.slot).then((result) => send(socket, {
+                    version: request.version, kind: "completed", requestId: request.requestId, turnId: request.turnId,
+                    text: result.text, ...brokerClockObservation(result.shellClock, result.providerClock),
+                    ...(result.cleanupDiagnostic === undefined ? {} : { cleanupDiagnostic: result.cleanupDiagnostic }),
+                    workerPid: result.workerPid, workerUid: result.workerUid, workerStartTime: result.workerStartTime,
+                    outcome: "completed", usage: result.usage, model: result.model, requests: result.requests, limitReason: "none"
+                }), (error) => failed(socket, request, error, controller.signal.aborted)).finally(() => {
+                    if (active.get(key) === controller)
+                        active.delete(key);
+                    owned = undefined;
+                });
+            }
+        }
+        catch (error) {
+            if (error instanceof EngineBrokerProtocolMismatch && !socket.writableEnded) {
+                // Flush one small, closed diagnostic before FIN; destroy would lose it.
+                socket.pause();
+                socket.end(encodeEngineBrokerFrame(error.diagnostic));
+            }
+            else
+                socket.destroy();
+        }
+    });
+}
+/**
+ * Every failure the broker raises for a known registration carries its
+ * accounting (a wake that tried to raise a limit: `usage: null`, zero
+ * requests). A failure with no registration behind it (unknown agent, closed
+ * broker) has no declared model to report, so it is refused as a bare
+ * connection close and the client reports the broker unavailable.
+ */
+function failed(socket, request, error, aborted) {
+    const accounting = error instanceof EngineBrokerTurnFailure ? error.accounting : undefined;
+    if (accounting === undefined) {
+        socket.destroy();
+        return;
+    }
+    const code = error instanceof EngineBrokerTurnFailure ? error.code : aborted ? "cancelled" : "engine_failed";
+    send(socket, {
+        version: request.version, kind: "failed", requestId: request.requestId, turnId: request.turnId, code,
+        ...(error instanceof EngineBrokerTurnFailure ? brokerClockObservation(error.shellClock, error.providerClock) : {}),
+        ...(error instanceof EngineBrokerTurnFailure && error.diagnostic ? { diagnostic: error.diagnostic } : {}),
+        ...(error instanceof EngineBrokerTurnFailure && error.mcpCalls ? { mcpCalls: error.mcpCalls } : {}),
+        ...(error instanceof EngineBrokerTurnFailure && error.cleanupDiagnostic ? { cleanupDiagnostic: error.cleanupDiagnostic } : {}),
+        outcome: "failed", usage: accounting.usage, model: accounting.model,
+        requests: accounting.requests, limitReason: accounting.limitReason
+    });
+}
+/** One grant verb per connection, answered and closed; any failure becomes a closed-code refusal and never touches turn state. */
+function serveInferenceGrant(socket, broker, request) {
+    const refuse = (code) => send(socket, { version: request.version, kind: "inference_grant_refused", requestId: request.requestId, code });
+    try {
+        if (request.kind === "release_inference_grant") {
+            if (!broker.releaseInferenceGrant)
+                return refuse("unavailable");
+            return send(socket, { version: request.version, kind: "inference_grant_released", requestId: request.requestId, grantId: request.grantId, released: broker.releaseInferenceGrant(request.grantId) });
+        }
+        if (!broker.requestInferenceGrant)
+            return refuse("unavailable");
+        const grant = broker.requestInferenceGrant({ model: request.model, reasoningEffort: request.reasoningEffort, purpose: request.purpose });
+        send(socket, { version: request.version, kind: "inference_grant", requestId: request.requestId, grantId: grant.grantId, token: grant.token, baseUrl: GROK_INFERENCE_PROXY_BASE_URL, model: grant.policy.model, reasoningEffort: grant.policy.reasoningEffort, purpose: grant.purpose, expiresAt: new Date(grant.expiresAt).toISOString(), limits: grant.limits });
+    }
+    catch (error) {
+        refuse(error instanceof GrokInferenceGrantRefused ? error.code : "unavailable");
+    }
+}
+function send(socket, response) { if (!socket.destroyed)
+    socket.end(encodeEngineBrokerFrame(response)); }
+async function removeOwnedSocket(file, uid) { try {
+    const entry = await lstat(file);
+    if (!entry.isSocket() || Number(entry.uid) !== uid)
+        throw new Error("unsafe broker socket");
+    await unlink(file);
+}
+catch (error) {
+    if (error.code !== "ENOENT")
+        throw error;
+} }
+async function verifySocket(file, uid) { const entry = await lstat(file); if (!entry.isSocket() || Number(entry.uid) !== uid || (Number(entry.mode) & 0o777) !== 0o600)
+    throw new Error("unsafe broker socket"); }
+function listen(server, file) { return new Promise((resolve, reject) => { server.once("error", reject); server.listen(file, () => { server.off("error", reject); resolve(); }); }); }
+function closeServer(server, connections) { for (const socket of connections)
+    socket.destroy(); return new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve())); }

package/dist/runtime/engineBrokerServiceCli.d.ts

@@ -0,0 +1,5 @@
+import { parseEngineBrokerServiceConfig } from "./engineBrokerServiceConfig.js";
+export { parseEngineBrokerServiceConfig };
+export declare const ENGINE_BROKER_SERVICE_CONFIG = "/etc/daimon-engine-broker/service.json";
+export declare function runEngineBrokerServiceCli(): Promise<void>;
+//# sourceMappingURL=engineBrokerServiceCli.d.ts.map

package/dist/runtime/engineBrokerServiceCli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerServiceCli.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerServiceCli.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAC;AAGhF,OAAO,EAAE,8BAA8B,EAAE,CAAC;AAE1C,eAAO,MAAM,4BAA4B,2CAA2C,CAAC;AAGrF,wBAAsB,yBAAyB,IAAG,OAAO,CAAC,IAAI,CAAC,CAO9D"}

package/dist/runtime/engineBrokerServiceCli.js

@@ -0,0 +1,32 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { startEngineBrokerService } from "./engineBrokerService.js";
+import { parseEngineBrokerServiceConfig } from "./engineBrokerServiceConfig.js";
+import { startGrokEngineBroker } from "./grokEngineBroker.js";
+export { parseEngineBrokerServiceConfig };
+export const ENGINE_BROKER_SERVICE_CONFIG = "/etc/daimon-engine-broker/service.json";
+const MAX_CONFIG_BYTES = 65_536;
+export async function runEngineBrokerServiceCli() {
+    if (process.getuid?.() !== 2100)
+        throw new Error("engine broker service requires broker identity");
+    const config = parseEngineBrokerServiceConfig(await readRootConfig(ENGINE_BROKER_SERVICE_CONFIG));
+    const broker = await startGrokEngineBroker({ grokCommand: "/usr/local/bin/grok", nativeClient: "/opt/daimon/bin/daimon-engine-broker", credentialHome: config.credentialHome, turnStore: config.turnStore, registrations: config.registrations, maxRunRequests: config.maxRunRequests, runRequestStore: config.runRequestStore, ...(config.inferenceLedgerPath === undefined ? {} : { inferenceLedgerPath: config.inferenceLedgerPath }) });
+    const service = await startEngineBrokerService(broker);
+    let stopping;
+    const stop = () => { stopping ??= service.close(); return stopping; };
+    const onSignal = () => { void stop().catch(() => { process.exitCode = 1; }); };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+}
+async function readRootConfig(file) { const handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW); try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.uid !== 0 || stat.gid !== 2100 || (stat.mode & 0o777) !== 0o440 || stat.size < 2 || stat.size > MAX_CONFIG_BYTES)
+        throw new Error("unsafe engine broker service config");
+    const bytes = await handle.readFile();
+    if (bytes.length > MAX_CONFIG_BYTES)
+        throw new Error("unsafe engine broker service config");
+    return JSON.parse(bytes.toString("utf8"));
+}
+finally {
+    await handle.close();
+} }

package/dist/runtime/engineBrokerServiceConfig.d.ts

@@ -0,0 +1,55 @@
+import { type EngineBrokerTurnLimits } from "./engineBrokerTurnAccounting.js";
+import { type GrokBrokerModelPolicy } from "./grokBrokerModelPolicy.js";
+export declare const ENGINE_BROKER_SERVICE_V1: "noopolis.daimon.engine-broker-service.v1";
+export declare const ENGINE_BROKER_SERVICE_V3: "noopolis.daimon.engine-broker-service.v3";
+export declare const ENGINE_BROKER_SERVICE_V2: "noopolis.daimon.engine-broker-service.v2";
+/** One root-provisioned broker slot. Every field is fixed at provisioning time; a wake can only lower `limits`. */
+export type EngineBrokerServiceRegistration = Readonly<{
+    agentId: string;
+    slot: number;
+    workerUid: number;
+    workspace: string;
+    profilePath: string;
+    eventsPath: string;
+    profileSha256: string;
+    /** Per-slot usage ledger the broker appends turn rows to; per-request rows go to `requests.jsonl` and per-turn seals to `turns.jsonl` beside it. */
+    usageLedgerPath: string;
+    limits: EngineBrokerTurnLimits;
+    model: GrokBrokerModelPolicy;
+}>;
+/**
+ * `inferenceLedgerPath` (v2, optional) is where evaluator inference grants
+ * append their rows (`inferenceUsageLedger.ts`). Without it the broker refuses
+ * every grant request. It can never be a subject ledger: not any
+ * registration's usage ledger or its `requests.jsonl`, and not the container
+ * ledger the wake fuse sums.
+ */
+export type EngineBrokerServiceConfig = Readonly<{
+    credentialHome: string;
+    turnStore: string;
+    registrations: readonly EngineBrokerServiceRegistration[];
+    inferenceLedgerPath?: string;
+    maxRunRequests?: number;
+    runRequestStore?: string;
+}>;
+/** The per-request stream written beside a registration's usage ledger. */
+export declare const engineBrokerRequestLedgerPathFor: (usageLedgerPath: string) => string;
+/**
+ * The per-turn seal stream written beside the other two
+ * (`engineBrokerSealLedger.ts`): the operator-visible half of a sealed terminal
+ * response, for the turn whose response never reaches a client.
+ */
+export declare const engineBrokerSealLedgerPathFor: (usageLedgerPath: string) => string;
+/**
+ * Strict `service.json` parser.
+ *
+ * v3 retains seven-field registrations and binds slotPolicies by slot; agent IDs
+ * may repeat, while worker UIDs, slots and ledger streams must be distinct.
+ * v2 requires every registration to declare its usage ledger, limits and model
+ * (`model.id`/`model.reasoningEffort` from the closed lists); unknown keys at
+ * any level are refused. v1 is still accepted and receives today's defaults:
+ * the container ledger, {@link DEFAULT_GROK_BROKER_TURN_LIMITS}, and
+ * `grok-4.6`/`low`.
+ */
+export declare function parseEngineBrokerServiceConfig(value: unknown): EngineBrokerServiceConfig;
+//# sourceMappingURL=engineBrokerServiceConfig.d.ts.map

package/dist/runtime/engineBrokerServiceConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerServiceConfig.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerServiceConfig.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgE,KAAK,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC5I,OAAO,EAAuF,KAAK,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAK7J,eAAO,MAAM,wBAAwB,EAAG,0CAAmD,CAAC;AAC5F,eAAO,MAAM,wBAAwB,EAAG,0CAAmD,CAAC;AAC5F,eAAO,MAAM,wBAAwB,EAAG,0CAAmD,CAAC;AAE5F,mHAAmH;AACnH,MAAM,MAAM,+BAA+B,GAAG,QAAQ,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IACpI,oJAAoJ;IACpJ,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,KAAK,EAAE,qBAAqB,CAAC;CAC9B,CAAC,CAAC;AACH;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,SAAS,+BAA+B,EAAE,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAc5O,2EAA2E;AAC3E,eAAO,MAAM,gCAAgC,GAAI,iBAAiB,MAAM,KAAG,MAAgF,CAAC;AAE5J;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GAAI,iBAAiB,MAAM,KAAG,MAA6E,CAAC;AAEtJ;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CAwDxF"}

package/dist/runtime/engineBrokerServiceConfig.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+import { DEFAULT_GROK_BROKER_TURN_LIMITS, parseEngineBrokerTurnLimits } from "./engineBrokerTurnAccounting.js";
+import { DEFAULT_GROK_BROKER_MODEL_POLICY, GROK_BROKER_MODELS, GROK_BROKER_REASONING_EFFORTS } from "./grokBrokerModelPolicy.js";
+import { grokWorkerEventsPathFor } from "./grokWorkerSandboxProfile.js";
+import { TURN_REQUEST_LEDGER } from "./turnRequestLedger.js";
+import { TURN_USAGE_LEDGER } from "./turnUsageLedger.js";
+export const ENGINE_BROKER_SERVICE_V1 = "noopolis.daimon.engine-broker-service.v1";
+export const ENGINE_BROKER_SERVICE_V3 = "noopolis.daimon.engine-broker-service.v3";
+export const ENGINE_BROKER_SERVICE_V2 = "noopolis.daimon.engine-broker-service.v2";
+const V1_REGISTRATION = ["agentId", "slot", "workerUid", "workspace", "profilePath", "eventsPath", "profileSha256"];
+const V2_REGISTRATION = [...V1_REGISTRATION, "usageLedgerPath", "limits", "model"];
+const invalid = () => new TypeError("invalid engine broker service config");
+const plain = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const exact = (value, fields) => { if (Object.keys(value).length !== fields.length || fields.some((field) => !Object.hasOwn(value, field)))
+    throw invalid(); };
+/**
+ * Absolute and canonical: no `.`/`..`/empty components and no trailing slash.
+ * The native launcher derives HOME, GROK_HOME and TMPDIR from the registered
+ * home and refuses a non-canonical one, so the broker's view must match it.
+ */
+const absolute = (item) => typeof item === "string" && item.length > 1 && item.startsWith("/") && !item.endsWith("/") && path.posix.normalize(item) === item && !item.split("/").slice(1).some((part) => part === "." || part === "..") && !item.includes("\0");
+/** The per-request stream written beside a registration's usage ledger. */
+export const engineBrokerRequestLedgerPathFor = (usageLedgerPath) => path.posix.join(path.posix.dirname(usageLedgerPath), "requests.jsonl");
+/**
+ * The per-turn seal stream written beside the other two
+ * (`engineBrokerSealLedger.ts`): the operator-visible half of a sealed terminal
+ * response, for the turn whose response never reaches a client.
+ */
+export const engineBrokerSealLedgerPathFor = (usageLedgerPath) => path.posix.join(path.posix.dirname(usageLedgerPath), "turns.jsonl");
+/**
+ * Strict `service.json` parser.
+ *
+ * v3 retains seven-field registrations and binds slotPolicies by slot; agent IDs
+ * may repeat, while worker UIDs, slots and ledger streams must be distinct.
+ * v2 requires every registration to declare its usage ledger, limits and model
+ * (`model.id`/`model.reasoningEffort` from the closed lists); unknown keys at
+ * any level are refused. v1 is still accepted and receives today's defaults:
+ * the container ledger, {@link DEFAULT_GROK_BROKER_TURN_LIMITS}, and
+ * `grok-4.6`/`low`.
+ */
+export function parseEngineBrokerServiceConfig(value) {
+    if (!plain(value))
+        throw invalid();
+    const v3 = value.version === ENGINE_BROKER_SERVICE_V3;
+    const v2 = v3 || value.version === ENGINE_BROKER_SERVICE_V2;
+    if (!v2 && value.version !== ENGINE_BROKER_SERVICE_V1)
+        throw invalid();
+    const top = ["version", "credentialHome", "turnStore", "registrations", ...(v3 ? ["slotPolicies"] : [])];
+    if (v3 && Object.hasOwn(value, "maxRunRequests")) {
+        if (!Number.isSafeInteger(value.maxRunRequests) || value.maxRunRequests < 1)
+            throw invalid();
+        top.push("maxRunRequests");
+    }
+    if (v3 && Object.hasOwn(value, "runRequestStore")) {
+        if (!absolute(value.runRequestStore) || value.maxRunRequests === undefined)
+            throw invalid();
+        top.push("runRequestStore");
+    }
+    exact(value, v2 && Object.hasOwn(value, "inferenceLedgerPath") ? [...top, "inferenceLedgerPath"] : top);
+    if (!absolute(value.credentialHome) || !absolute(value.turnStore) || !Array.isArray(value.registrations) || value.registrations.length === 0)
+        throw invalid();
+    const policies = new Map();
+    if (v3) {
+        if (!Array.isArray(value.slotPolicies) || value.slotPolicies.length !== value.registrations.length)
+            throw invalid();
+        for (const policy of value.slotPolicies) {
+            if (!plain(policy))
+                throw invalid();
+            exact(policy, ["slot", "usageLedgerPath", "limits", "model"]);
+            if (!Number.isSafeInteger(policy.slot) || policy.slot < 0 || policies.has(policy.slot))
+                throw invalid();
+            policies.set(policy.slot, policy);
+        }
+    }
+    const seen = new Set(), slots = new Set(), workers = new Set();
+    const ledgers = new Set();
+    const registrations = value.registrations.map((entry) => {
+        if (!plain(entry))
+            throw invalid();
+        exact(entry, v2 && !v3 ? V2_REGISTRATION : V1_REGISTRATION);
+        const { agentId, slot, workerUid, workspace, profilePath, eventsPath, profileSha256 } = entry;
+        if (typeof agentId !== "string" || !agentId.trim() || (!v3 && seen.has(agentId)) || !Number.isSafeInteger(slot) || slot < 0 || slots.has(slot) || !Number.isSafeInteger(workerUid) || workerUid < 2200 || workers.has(workerUid) || !absolute(workspace) || !absolute(profilePath) || !absolute(eventsPath) || typeof profileSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(profileSha256) || eventsPath !== grokWorkerEventsPathFor(profilePath) || !profilePath.endsWith("/sandbox.toml"))
+            throw invalid();
+        seen.add(agentId);
+        slots.add(slot);
+        workers.add(workerUid);
+        const base = { agentId, slot: slot, workerUid: workerUid, workspace, profilePath, eventsPath, profileSha256 };
+        if (!v2)
+            return { ...base, usageLedgerPath: TURN_USAGE_LEDGER.filePath, limits: DEFAULT_GROK_BROKER_TURN_LIMITS, model: DEFAULT_GROK_BROKER_MODEL_POLICY };
+        const policy = v3 ? policies.get(slot) : entry;
+        if (policy === undefined)
+            throw invalid();
+        const usageLedgerPath = policy.usageLedgerPath;
+        if (!ledgerPath(usageLedgerPath) || usageLedgerPath === engineBrokerRequestLedgerPathFor(usageLedgerPath) || usageLedgerPath === engineBrokerSealLedgerPathFor(usageLedgerPath))
+            throw invalid();
+        const streams = [usageLedgerPath, engineBrokerRequestLedgerPathFor(usageLedgerPath), engineBrokerSealLedgerPathFor(usageLedgerPath)];
+        if (v3 && streams.some((file) => ledgers.has(file)))
+            throw invalid();
+        streams.forEach((file) => ledgers.add(file));
+        let limits;
+        try {
+            limits = parseEngineBrokerTurnLimits(policy.limits);
+        }
+        catch {
+            throw invalid();
+        }
+        return { ...base, usageLedgerPath, limits, model: parseServiceModel(policy.model) };
+    });
+    const base = { credentialHome: value.credentialHome, turnStore: value.turnStore, registrations,
+        ...(value.runRequestStore === undefined ? {} : { runRequestStore: value.runRequestStore }),
+        ...(value.maxRunRequests === undefined ? {} : { maxRunRequests: value.maxRunRequests }) };
+    if (!Object.hasOwn(value, "inferenceLedgerPath"))
+        return base;
+    const inferenceLedgerPath = value.inferenceLedgerPath;
+    if (!ledgerPath(inferenceLedgerPath))
+        throw invalid();
+    const subject = new Set([TURN_USAGE_LEDGER.filePath, TURN_REQUEST_LEDGER.filePath, ...registrations.flatMap((entry) => [entry.usageLedgerPath, engineBrokerRequestLedgerPathFor(entry.usageLedgerPath), engineBrokerSealLedgerPathFor(entry.usageLedgerPath)])]);
+    if (subject.has(inferenceLedgerPath))
+        throw invalid();
+    return { ...base, inferenceLedgerPath };
+}
+const ledgerPath = (item) => absolute(item) && item.endsWith(".jsonl") && path.posix.normalize(item) === item;
+function parseServiceModel(value) {
+    if (!plain(value))
+        throw invalid();
+    exact(value, ["id", "reasoningEffort"]);
+    if (!GROK_BROKER_MODELS.includes(value.id) || !GROK_BROKER_REASONING_EFFORTS.includes(value.reasoningEffort))
+        throw invalid();
+    return Object.freeze({ model: value.id, reasoningEffort: value.reasoningEffort });
+}

package/dist/runtime/engineBrokerSingleflight.d.ts

@@ -0,0 +1,13 @@
+export declare class EngineBrokerSingleflight<T> {
+    private active;
+    run(operation: () => Promise<T>): Promise<T>;
+}
+export declare class EngineBrokerGenerationFence {
+    private generation;
+    private stale;
+    restore(generation: number): void;
+    snapshot(): number;
+    promote(expected: number): number;
+    markStale(): void;
+}
+//# sourceMappingURL=engineBrokerSingleflight.d.ts.map

package/dist/runtime/engineBrokerSingleflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerSingleflight.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerSingleflight.ts"],"names":[],"mappings":"AAAA,qBAAa,wBAAwB,CAAC,CAAC;IACrC,OAAO,CAAC,MAAM,CAAyB;IACvC,GAAG,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAM7C;AAED,qBAAa,2BAA2B;IACtC,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,UAAU,EAAC,MAAM,GAAE,IAAI;IAC/B,QAAQ,IAAI,MAAM;IAClB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IACjC,SAAS,IAAI,IAAI;CAClB"}