@noopolis/daimon 0.1.2 → 0.2.0

package/dist/runtime/organizationRuntimeHost.js

@@ -0,0 +1,359 @@
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { sanitizeWakeCompletionText } from "./wakeAcceptanceTypes.js";
+import { startOrganizationRuntimeEngine } from "./engineDispatcher.js";
+import { prepareProductionReadiness } from "./organizationRuntimeReadiness.js";
+import { parseOrganizationRuntimeConfig, parseOrganizationRuntimeWakeRequest } from "./organizationRuntime.js";
+/** Creates the public host with Daimon's closed production engine dispatcher. */
+export function createOrganizationRuntimeHost(config, options = {}) {
+    const parsed = parseOrganizationRuntimeConfig(config);
+    if (parsed.agents.some((agent) => agent.attention !== undefined))
+        throw new Error("attention requires createOrganizationRuntimeControlHost and POST /v2/wakes for durable inbox ownership");
+    return createOrganizationRuntimeHostWithAttention(parsed, options, new Map());
+}
+/** @internal Control-owned attention registry, never a caller-supplied config hook. */
+export function createOrganizationRuntimeHostWithAttention(config, options, attention) {
+    const parsed = parseOrganizationRuntimeConfig(config);
+    let agyBusAddress;
+    let grokBroker;
+    return createHost(parsed, (agent, paths) => startOrganizationRuntimeEngine(agent, parsed.host.controlTokenEnv, paths, agyBusAddress, grokBroker, parsed.agents, options.sharedProtectedPaths, attention), async () => {
+        const ready = await prepareProductionReadiness(parsed);
+        agyBusAddress = ready.agyRealm?.busAddress;
+        grokBroker = ready.grokBroker;
+        return {
+            ...ready,
+            async close() {
+                try {
+                    await ready.close();
+                }
+                finally {
+                    agyBusAddress = undefined;
+                    grokBroker = undefined;
+                }
+            }
+        };
+    });
+}
+/** @internal Test-only construction seam; it is intentionally not package-exported. */
+export function createOrganizationRuntimeHostForTest(config, factory, preflight) {
+    return createHost(parseOrganizationRuntimeConfig(config), factory, preflight === undefined ? undefined : async () => {
+        const paths = await preflight();
+        return { paths, close: () => paths.close() };
+    });
+}
+function createHost(config, factory, preflight = undefined) {
+    const maxPendingWakes = 64;
+    const maxActivity = 512;
+    const agents = new Map(config.agents.map((agent) => [agent.id, {
+            config: agent,
+            state: "stopped",
+            draining: false,
+            pending: [],
+            stopped: false
+        }]));
+    const activity = [];
+    let nextActivitySequence = 0;
+    // Capture the expected token before any operation can route by agent id.
+    const controlToken = process.env[config.host.controlTokenEnv];
+    let state = "stopped";
+    let startPromise;
+    let stopPromise;
+    let stopRequested = false;
+    let readiness;
+    const addActivity = (agentId, kind, wakeId) => {
+        activity.push({
+            sequence: nextActivitySequence++,
+            value: { id: randomUUID(), agentId, ...(wakeId === undefined ? {} : { wakeId }), kind, occurredAt: new Date().toISOString() }
+        });
+        if (activity.length > maxActivity)
+            activity.shift();
+    };
+    const stoppedResult = (request, code) => ({
+        version: "noopolis.daimon.wake-result.v1",
+        status: "stopped",
+        agentId: request.agentId,
+        wakeId: request.event.id,
+        code
+    });
+    const settle = (job, result) => {
+        if (job.settled)
+            return;
+        job.settled = true;
+        job.resolve(result);
+    };
+    const drain = async (agent) => {
+        if (agent.draining)
+            return;
+        agent.draining = true;
+        try {
+            while (state === "running" && agent.pending.length > 0) {
+                const job = agent.pending.shift();
+                if (job === undefined)
+                    continue;
+                agent.active = job;
+                agent.state = "running";
+                addActivity(agent.config.id, "wake_started", job.request.event.id);
+                try {
+                    const result = await agent.handle.wake(toCoreWake(job.request));
+                    if (!job.settled && !job.aborting) {
+                        agent.state = "idle";
+                        addActivity(agent.config.id, "wake_completed", job.request.event.id);
+                        settle(job, completed(job.request, result.text, result.durationMs));
+                    }
+                }
+                catch (error) {
+                    if (!job.settled && !job.aborting) {
+                        agent.state = "failed";
+                        settle(job, failed(job.request, error));
+                    }
+                }
+                finally {
+                    if (agent.active === job)
+                        agent.active = undefined;
+                }
+            }
+        }
+        finally {
+            agent.draining = false;
+        }
+    };
+    const start = async () => {
+        if (state === "running")
+            return;
+        if (startPromise !== undefined)
+            return startPromise;
+        if (stopRequested)
+            throw new Error("organization runtime host has been stopped");
+        if (controlToken === undefined || !controlToken.trim()) {
+            throw new Error(`required control token ${config.host.controlTokenEnv} is missing or blank`);
+        }
+        state = "starting";
+        for (const agent of agents.values())
+            agent.state = "starting";
+        startPromise = (async () => {
+            // This runs before a factory can create an adapter or child process.
+            try {
+                readiness = await preflight?.();
+            }
+            catch (error) {
+                state = "stopped";
+                for (const agent of agents.values())
+                    agent.state = "stopped";
+                throw error;
+            }
+            const started = await Promise.allSettled([...agents.values()].map(async (agent) => {
+                const paths = readiness?.paths.forAgent(agent.config);
+                await paths?.verify();
+                agent.handle = await factory(agent.config, paths);
+                await paths?.verify();
+                return agent;
+            }));
+            const failedStart = started.find((result) => result.status === "rejected");
+            if (failedStart !== undefined || stopRequested) {
+                state = "stopping";
+                stopRequested = true;
+                const startedAgents = [...agents.values()].filter((agent) => agent.handle !== undefined);
+                const stopped = await Promise.allSettled(startedAgents.map(async (agent) => {
+                    await agent.handle.stop();
+                    agent.handle = undefined;
+                    agent.stopped = true;
+                    agent.state = "stopped";
+                }));
+                const cleanupFailures = stopped.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+                for (const agent of agents.values()) {
+                    if (agent.handle !== undefined)
+                        agent.state = "stopping";
+                    else if (!agent.stopped)
+                        agent.state = "stopped";
+                }
+                if (cleanupFailures.length > 0) {
+                    // A handle that cannot stop remains visible and retryable.
+                    state = "stopping";
+                    throw new AggregateError([...(failedStart === undefined ? [] : [failedStart.reason]), ...cleanupFailures], "organization runtime startup cleanup failed");
+                }
+                await readiness?.close();
+                readiness = undefined;
+                state = "stopped";
+                if (failedStart !== undefined)
+                    throw failedStart.reason;
+                return;
+            }
+            try {
+                state = "running";
+                for (const agent of agents.values())
+                    agent.state = "idle";
+            }
+            catch (error) {
+                state = "stopping";
+                await Promise.allSettled([...agents.values()].flatMap((agent) => agent.handle === undefined ? [] : [agent.handle.stop()]));
+                await readiness?.close();
+                readiness = undefined;
+                for (const agent of agents.values()) {
+                    agent.handle = undefined;
+                    agent.state = "stopped";
+                }
+                state = "stopped";
+                throw error;
+            }
+        })().finally(() => {
+            startPromise = undefined;
+        });
+        return startPromise;
+    };
+    const wake = async (request) => {
+        let parsed;
+        try {
+            parsed = parseOrganizationRuntimeWakeRequest(request);
+        }
+        catch {
+            return invalidRequest();
+        }
+        if (controlToken === undefined || !tokensEqual(controlToken, parsed.token)) {
+            return rejected(parsed, "unauthorized");
+        }
+        if (state !== "running" || stopRequested) {
+            return stoppedResult(parsed, stopRequested || state === "stopping" ? "host_stopping" : "host_stopped");
+        }
+        const agent = agents.get(parsed.agentId);
+        if (agent === undefined) {
+            addActivity(parsed.agentId, "wake_rejected", parsed.event.id);
+            return rejected(parsed, "unknown_agent");
+        }
+        if (agent.pending.length >= maxPendingWakes) {
+            addActivity(parsed.agentId, "wake_rejected", parsed.event.id);
+            return rejected(parsed, "queue_full");
+        }
+        return new Promise((resolve) => {
+            const job = { request: parsed, resolve, settled: false, aborting: false };
+            agent.pending.push(job);
+            void drain(agent);
+        });
+    };
+    const health = async (agentId) => ({
+        version: "noopolis.daimon.organization-runtime-health.v1",
+        state,
+        agents: [...agents.values()]
+            .filter((agent) => agentId === undefined || agent.config.id === agentId)
+            .map((agent) => ({ agentId: agent.config.id, engine: agent.config.engine.kind, state: agentHealthState(agent) }))
+    });
+    const activityPage = async (request) => {
+        const offset = cursorOffset(request.cursor);
+        if (!Number.isInteger(request.limit) || request.limit < 1 || request.limit > 100) {
+            throw new TypeError("activity.limit must be an integer between 1 and 100");
+        }
+        const filtered = activity.filter((entry) => entry.sequence >= offset
+            && (request.agentId === undefined || entry.value.agentId === request.agentId));
+        const entries = filtered.slice(0, request.limit);
+        const items = entries.map((entry) => entry.value);
+        const next = entries.length === 0 ? undefined : entries[entries.length - 1].sequence + 1;
+        return {
+            version: "noopolis.daimon.organization-runtime-activity.v1",
+            items,
+            ...(next !== undefined && filtered.length > entries.length ? { nextCursor: String(next) } : {})
+        };
+    };
+    const stop = () => {
+        if (stopPromise !== undefined)
+            return stopPromise;
+        stopRequested = true;
+        const attempt = (async () => {
+            if (startPromise !== undefined)
+                await startPromise.catch(() => undefined);
+            if (state === "stopped")
+                return { version: "noopolis.daimon.organization-runtime-stop.v1", state: "stopped" };
+            state = "stopping";
+            const active = [];
+            for (const agent of agents.values()) {
+                for (const job of agent.pending.splice(0))
+                    settle(job, stoppedResult(job.request, "queued_wake_stopped"));
+                if (agent.active !== undefined) {
+                    agent.active.aborting = true;
+                    active.push({ agent, job: agent.active });
+                }
+            }
+            const liveAgents = [...agents.values()].filter((agent) => agent.handle !== undefined && !agent.stopped);
+            const stopped = await Promise.allSettled(liveAgents.map(async (agent) => {
+                await agent.handle.stop();
+                agent.handle = undefined;
+                agent.stopped = true;
+                agent.state = "stopped";
+            }));
+            const failures = stopped.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+            for (const { agent, job } of active) {
+                addActivity(agent.config.id, "wake_aborted", job.request.event.id);
+                settle(job, stoppedResult(job.request, "active_wake_aborted"));
+            }
+            if (failures.length > 0) {
+                for (const agent of liveAgents)
+                    if (agent.handle !== undefined)
+                        agent.state = "stopping";
+                throw new AggregateError(failures, "organization runtime shutdown cleanup failed");
+            }
+            await readiness?.close();
+            readiness = undefined;
+            for (const agent of agents.values())
+                agent.stopped = true;
+            for (const agent of agents.values()) {
+                agent.state = "stopped";
+                addActivity(agent.config.id, "agent_stopped");
+            }
+            state = "stopped";
+            return { version: "noopolis.daimon.organization-runtime-stop.v1", state: "stopped" };
+        })();
+        stopPromise = attempt;
+        void attempt.catch(() => { if (stopPromise === attempt)
+            stopPromise = undefined; });
+        return attempt;
+    };
+    return { start, wake, health, activity: activityPage, stop };
+}
+function toCoreWake(request) {
+    return {
+        id: request.event.id,
+        kind: request.event.kind === "external" ? "manual" : request.event.kind,
+        text: request.event.text
+    };
+}
+function agentHealthState(agent) {
+    const status = agent.handle?.status();
+    return agent.state === "running" || agent.state === "failed" || agent.state === "stopped"
+        ? agent.state
+        : status?.state ?? agent.state;
+}
+function tokensEqual(expected, actual) {
+    const digest = (value) => createHash("sha256").update(value).digest();
+    return timingSafeEqual(digest(expected), digest(actual ?? ""));
+}
+function cursorOffset(cursor) {
+    if (cursor === undefined)
+        return 0;
+    if (!/^(0|[1-9][0-9]{0,15})$/.test(cursor))
+        throw new TypeError("activity.cursor is invalid");
+    const offset = Number(cursor);
+    if (!Number.isSafeInteger(offset))
+        throw new TypeError("activity.cursor is invalid");
+    return offset;
+}
+function completed(request, text, durationMs) {
+    return { version: "noopolis.daimon.wake-result.v1", status: "completed", agentId: request.agentId, wakeId: request.event.id, text: sanitizeWakeCompletionText(text), durationMs };
+}
+/** Engine failures are undiagnosable without the cause, so carry a bounded excerpt. */
+export const ENGINE_FAILURE_DETAIL_MAX_BYTES = 2_048;
+function failed(request, error) {
+    const detail = engineFailureDetail(error);
+    return { version: "noopolis.daimon.wake-result.v1", status: "failed", agentId: request.agentId, wakeId: request.event.id, code: "engine_failed", ...(detail === undefined ? {} : { detail }) };
+}
+export function engineFailureDetail(error) {
+    const raw = error instanceof Error ? error.message : typeof error === "string" ? error : undefined;
+    if (raw === undefined)
+        return undefined;
+    const trimmed = raw.replaceAll(/\s+/gu, " ").trim();
+    if (trimmed.length === 0)
+        return undefined;
+    return Buffer.from(trimmed, "utf8").subarray(0, ENGINE_FAILURE_DETAIL_MAX_BYTES).toString("utf8");
+}
+function rejected(request, code) {
+    return { version: "noopolis.daimon.wake-result.v1", status: "rejected", agentId: request.agentId, wakeId: request.event.id, code };
+}
+function invalidRequest() {
+    return { version: "noopolis.daimon.wake-result.v1", status: "rejected", agentId: "", wakeId: "", code: "invalid_request" };
+}

package/dist/runtime/organizationRuntimeParsing.d.ts

@@ -0,0 +1,6 @@
+import { type OrganizationRuntimeConfig, type OrganizationRuntimeWakeRequest } from "./organizationRuntime.js";
+export declare function parseOrganizationRuntimeConfig(value: unknown): OrganizationRuntimeConfig;
+export declare function parseOrganizationRuntimeWakeRequest(value: unknown): OrganizationRuntimeWakeRequest;
+export declare function validateOrganizationRuntimeConfig(value: unknown): value is OrganizationRuntimeConfig;
+export declare const isOrganizationRuntimeConfig: typeof validateOrganizationRuntimeConfig;
+//# sourceMappingURL=organizationRuntimeParsing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"organizationRuntimeParsing.d.ts","sourceRoot":"","sources":["../../src/runtime/organizationRuntimeParsing.ts"],"names":[],"mappings":"AAEA,OAAO,EAcL,KAAK,yBAAyB,EAK9B,KAAK,8BAA8B,EACpC,MAAM,0BAA0B,CAAC;AAOlC,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CAuBxF;AAED,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,OAAO,GAAG,8BAA8B,CAWlG;AAED,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,yBAAyB,CAEpG;AAED,eAAO,MAAM,2BAA2B,0CAAoC,CAAC"}