pulseed 0.4.0 → 0.4.1

package/dist/runtime/event/server.js

@@ -0,0 +1,651 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import * as http from "node:http";
+import { PulSeedEventSchema } from "../../base/types/drive.js";
+import { TriggerEventSchema, TriggerMappingsConfigSchema } from "../../base/types/trigger.js";
+import { getEventsDir } from "../../base/utils/paths.js";
+import { findAvailablePort, DEFAULT_PORT, MAX_PORT_ATTEMPTS } from "../port-utils.js";
+import { createEnvelope } from "../types/envelope.js";
+import { EventServerSnapshotReader } from "./server-snapshot-reader.js";
+import { EventServerSseManager } from "./server-sse.js";
+export class EventServer {
+    server = null;
+    driveSystem;
+    host;
+    port;
+    eventsDir;
+    fileWatcher = null;
+    processingFiles = new Set();
+    logger;
+    stateManager;
+    triggerMapper;
+    snapshotReader;
+    sseManager;
+    triggerMappingsCache = null;
+    approvalQueue = new Map();
+    approvalBroker;
+    outboxStore;
+    envelopeHook;
+    commandEnvelopeHook;
+    activeWorkersProvider;
+    constructor(driveSystem, config, logger) {
+        this.driveSystem = driveSystem;
+        this.host = config?.host ?? "127.0.0.1";
+        this.port = config?.port ?? DEFAULT_PORT;
+        // Default events directory: ~/.pulseed/events/
+        this.eventsDir = config?.eventsDir ?? getEventsDir();
+        this.logger = logger;
+        this.stateManager = config?.stateManager;
+        this.triggerMapper = config?.triggerMapper;
+        this.approvalBroker = config?.approvalBroker;
+        this.outboxStore = config?.outboxStore;
+        this.snapshotReader = new EventServerSnapshotReader(this.eventsDir);
+        this.sseManager = new EventServerSseManager(this.logger, this.approvalBroker, this.outboxStore);
+    }
+    /** Start HTTP server, auto-retrying on EADDRINUSE up to MAX_PORT_ATTEMPTS times */
+    async start() {
+        if (this.server) {
+            return; // Already running
+        }
+        await fsp.mkdir(this.eventsDir, { recursive: true });
+        await this.approvalBroker?.start();
+        // If a specific non-zero port was requested, find the first available port
+        // starting from it. Port 0 means OS-assigned — skip auto-detection.
+        const startPort = this.port === 0 ? 0 : await findAvailablePort(this.port);
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => this.handleRequest(req, res));
+            const server = this.server;
+            server.listen(startPort, this.host, () => {
+                // Capture the actual bound port (important for port 0 and auto-retry cases)
+                const addr = server.address();
+                if (addr && typeof addr === "object") {
+                    this.port = addr.port;
+                }
+                this.logger?.info(`EventServer listening on ${this.host}:${this.port}`);
+                resolve();
+            });
+            this.server.on("error", (err) => {
+                // EADDRINUSE should not reach here since findAvailablePort pre-checks,
+                // but guard against a race condition.
+                if (err.code === "EADDRINUSE" && startPort !== 0) {
+                    const fallbackStart = startPort + MAX_PORT_ATTEMPTS;
+                    findAvailablePort(fallbackStart).then((fallback) => {
+                        server.listen(fallback, this.host, () => {
+                            const addr = server.address();
+                            if (addr && typeof addr === "object") {
+                                this.port = addr.port;
+                            }
+                            this.logger?.info(`EventServer listening on ${this.host}:${this.port} (fallback)`);
+                            resolve();
+                        });
+                    }).catch(reject);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    /** Stop HTTP server */
+    async stop() {
+        this.stopFileWatcher();
+        await this.approvalBroker?.stop();
+        this.sseManager.closeAllClients();
+        return new Promise((resolve) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            this.server.close(() => resolve());
+        });
+    }
+    /**
+     * Start watching the events directory for new `.json` files.
+     * When a file appears:
+     *   1. Read and parse it
+     *   2. Validate via PulSeedEventSchema
+     *   3. Dispatch to DriveSystem (writeEvent)
+     *   4. Move to events/processed/ subdirectory
+     *   5. Log errors for malformed files but don't crash
+     *
+     * Creates the events directory if it doesn't exist.
+     */
+    startFileWatcher() {
+        if (this.fileWatcher)
+            return; // already watching
+        fs.mkdirSync(this.eventsDir, { recursive: true });
+        this.fileWatcher = fs.watch(this.eventsDir, (eventType, filename) => {
+            if ((eventType !== "rename" && eventType !== "change") || !filename)
+                return;
+            if (!filename.endsWith(".json") || filename.endsWith(".tmp"))
+                return;
+            const filePath = path.join(this.eventsDir, filename);
+            if (this.processingFiles.has(filename))
+                return;
+            this.processingFiles.add(filename);
+            void (async () => {
+                try {
+                    await this.processEventFile(filePath, filename);
+                }
+                catch (err) {
+                    this.logger?.error(`EventServer: unhandled error processing event file "${filename}": ${String(err)}`);
+                }
+                finally {
+                    this.processingFiles.delete(filename);
+                }
+            })();
+        });
+    }
+    /** Stop the file watcher and clean up the handle. */
+    stopFileWatcher() {
+        if (this.fileWatcher) {
+            this.fileWatcher.close();
+            this.fileWatcher = null;
+        }
+    }
+    /**
+     * Read, validate, dispatch, and move a single event file.
+     * Errors are logged but never propagated (caller must not crash).
+     */
+    async processEventFile(filePath, filename) {
+        try {
+            let stat;
+            try {
+                // Retry on ENOENT: on macOS, fs.watch fires 'rename' before the file
+                // is visible to fsp.stat, so retry up to 3 times with 20ms delay.
+                let lastErr;
+                for (let attempt = 0; attempt < 3; attempt++) {
+                    try {
+                        stat = await fsp.stat(filePath);
+                        break;
+                    }
+                    catch (err) {
+                        const code = err.code;
+                        if (code !== "ENOENT")
+                            throw err;
+                        lastErr = err;
+                        await new Promise((r) => setTimeout(r, 20));
+                    }
+                }
+                if (!stat) {
+                    // File never appeared — already removed
+                    void lastErr; // suppress unused warning
+                    return;
+                }
+            }
+            catch {
+                return; // non-ENOENT error — file already removed or inaccessible
+            }
+            if (!stat.isFile())
+                return;
+            const content = await fsp.readFile(filePath, "utf-8");
+            const raw = JSON.parse(content);
+            const event = PulSeedEventSchema.parse(raw);
+            // Dispatch through Gateway Envelope path or direct
+            if (this.envelopeHook) {
+                await this.envelopeHook(event);
+            }
+            else {
+                await this.driveSystem.writeEvent(event);
+            }
+            // Move to processed/
+            const processedDir = path.join(this.eventsDir, "processed");
+            await fsp.mkdir(processedDir, { recursive: true });
+            const dstPath = path.join(processedDir, filename);
+            await fsp.rename(filePath, dstPath);
+        }
+        catch (err) {
+            this.logger?.error(`EventServer: failed to process event file "${filename}": ${String(err)}`);
+            // Do not re-throw — watcher must keep running
+        }
+    }
+    /** Broadcast an SSE event to all connected clients */
+    async broadcast(eventType, data) {
+        await this.sseManager.broadcast(eventType, data);
+    }
+    /** Request human approval and wait for response (5 min timeout) */
+    async requestApproval(goalId, task) {
+        if (this.approvalBroker) {
+            return this.approvalBroker.requestApproval(goalId, task);
+        }
+        const requestId = `approval-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.approvalQueue.delete(requestId);
+                void this.broadcast("approval_resolved", { requestId, goalId, approved: false, reason: "timeout" });
+                resolve(false);
+            }, 5 * 60 * 1000);
+            this.approvalQueue.set(requestId, { resolve, timer });
+            void this.broadcast("approval_required", { requestId, goalId, task });
+        });
+    }
+    /** Resolve a pending approval request */
+    async resolveApproval(requestId, approved) {
+        if (this.approvalBroker) {
+            return this.approvalBroker.resolveApproval(requestId, approved, "http");
+        }
+        const entry = this.approvalQueue.get(requestId);
+        if (!entry)
+            return false;
+        clearTimeout(entry.timer);
+        this.approvalQueue.delete(requestId);
+        entry.resolve(approved);
+        void this.broadcast("approval_resolved", { requestId, approved });
+        return true;
+    }
+    /** Handle incoming HTTP request */
+    /** Set a hook to intercept incoming events as Envelopes (used by HttpChannelAdapter). */
+    setEnvelopeHook(hook) {
+        this.envelopeHook = hook;
+    }
+    /** Set a hook to intercept command-style HTTP actions as Envelopes. */
+    setCommandEnvelopeHook(hook) {
+        this.commandEnvelopeHook = hook;
+    }
+    setApprovalBroker(broker) {
+        this.approvalBroker = broker;
+        this.sseManager.setApprovalBroker(broker);
+    }
+    setOutboxStore(store) {
+        this.outboxStore = store;
+        this.sseManager.setOutboxStore(store);
+    }
+    setActiveWorkersProvider(provider) {
+        this.activeWorkersProvider = provider;
+    }
+    handleRequest(req, res) {
+        const requestUrl = new URL(req.url ?? "/", "http://127.0.0.1");
+        const urlPath = requestUrl.pathname;
+        // GET /health
+        if (req.method === "GET" && urlPath === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "ok", uptime: process.uptime() }));
+            return;
+        }
+        // POST /events
+        if (req.method === "POST" && urlPath === "/events") {
+            this.handlePostEvents(req, res);
+            return;
+        }
+        // POST /triggers
+        if (req.method === "POST" && urlPath === "/triggers") {
+            this.handlePostTriggers(req, res);
+            return;
+        }
+        // GET /goals
+        if (req.method === "GET" && urlPath === "/goals") {
+            void this.handleGetGoals(res);
+            return;
+        }
+        if (req.method === "GET" && urlPath === "/snapshot") {
+            void this.handleGetSnapshot(res);
+            return;
+        }
+        // GET /goals/:id
+        const goalsMatch = /^\/goals\/([^/]+)$/.exec(urlPath);
+        if (req.method === "GET" && goalsMatch) {
+            void this.handleGetGoalById(res, goalsMatch[1]);
+            return;
+        }
+        // GET /stream — SSE event stream
+        if (req.method === "GET" && urlPath === "/stream") {
+            void this.handleStream(req, res, requestUrl);
+            return;
+        }
+        // GET /daemon/status
+        if (req.method === "GET" && urlPath === "/daemon/status") {
+            void (async () => {
+                const raw = await this.snapshotReader.readDaemonStateRaw();
+                if (raw !== null) {
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(raw);
+                }
+                else {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "daemon state not found" }));
+                }
+            })();
+            return;
+        }
+        // POST /goals/:id/start|stop|approve|chat
+        const goalActionMatch = /^\/goals\/([^/]+)\/([^/]+)$/.exec(urlPath);
+        if (req.method === "POST" && goalActionMatch) {
+            const goalId = goalActionMatch[1];
+            const action = goalActionMatch[2];
+            void (async () => {
+                if (action === "start") {
+                    try {
+                        await this.dispatchCommandEnvelope({
+                            name: "goal_start",
+                            goalId,
+                            payload: { goalId },
+                        });
+                        await this.broadcast("goal_start_requested", { goalId });
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ ok: true, goalId }));
+                    }
+                    catch (err) {
+                        res.writeHead(500, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Command accept failed", details: String(err) }));
+                    }
+                }
+                else if (action === "stop") {
+                    try {
+                        await this.dispatchCommandEnvelope({
+                            name: "goal_stop",
+                            goalId,
+                            payload: { goalId },
+                        });
+                        await this.broadcast("goal_stop_requested", { goalId });
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ ok: true, goalId }));
+                    }
+                    catch (err) {
+                        res.writeHead(500, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Command accept failed", details: String(err) }));
+                    }
+                }
+                else if (action === "approve") {
+                    try {
+                        const body = await readBody(req);
+                        const { requestId, approved } = JSON.parse(body);
+                        if (!this.approvalBroker && !this.approvalQueue.has(requestId)) {
+                            res.writeHead(404, { "Content-Type": "application/json" });
+                            res.end(JSON.stringify({ ok: false }));
+                            return;
+                        }
+                        await this.dispatchCommandEnvelope({
+                            name: "approval_response",
+                            goalId,
+                            priority: "high",
+                            dedupeKey: `approval_response:${requestId}`,
+                            payload: { goalId, requestId, approved },
+                        });
+                        const resolved = await this.resolveApproval(requestId, approved);
+                        res.writeHead(resolved ? 200 : 404, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ ok: resolved }));
+                    }
+                    catch (err) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Invalid approval response", details: String(err) }));
+                    }
+                }
+                else if (action === "chat") {
+                    try {
+                        const body = await readBody(req);
+                        const { message } = JSON.parse(body);
+                        await this.dispatchCommandEnvelope({
+                            name: "chat_message",
+                            goalId,
+                            payload: { goalId, message },
+                        });
+                        await this.broadcast("chat_message_received", { goalId, message });
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ ok: true }));
+                    }
+                    catch (err) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Invalid chat message", details: String(err) }));
+                    }
+                }
+                else {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Not found" }));
+                }
+            })();
+            return;
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+    }
+    handlePostEvents(req, res) {
+        const MAX_BODY_SIZE = 1_048_576; // 1 MB
+        let body = "";
+        let bytesReceived = 0;
+        req.on("data", (chunk) => {
+            bytesReceived += chunk.length;
+            if (bytesReceived > MAX_BODY_SIZE) {
+                res.writeHead(413, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Payload too large" }));
+                req.destroy();
+                return;
+            }
+            body += chunk;
+        });
+        req.on("end", () => {
+            void (async () => {
+                try {
+                    const data = JSON.parse(body);
+                    const event = PulSeedEventSchema.parse(data);
+                    if (this.envelopeHook) {
+                        // Route through Gateway Envelope path and wait for durable accept.
+                        await this.envelopeHook(event);
+                    }
+                    else {
+                        await this.driveSystem.writeEvent(event);
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ status: "accepted", event_type: event.type }));
+                }
+                catch (err) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Invalid event", details: String(err) }));
+                }
+            })();
+        });
+    }
+    handlePostTriggers(req, res) {
+        const MAX_BODY_SIZE = 1_048_576;
+        let body = "";
+        let bytesReceived = 0;
+        req.on("data", (chunk) => {
+            bytesReceived += chunk.length;
+            if (bytesReceived > MAX_BODY_SIZE) {
+                res.writeHead(413, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Payload too large" }));
+                req.destroy();
+                return;
+            }
+            body += chunk;
+        });
+        req.on("end", () => {
+            void (async () => {
+                try {
+                    const data = JSON.parse(body);
+                    const trigger = TriggerEventSchema.parse(data);
+                    let action;
+                    let goalId;
+                    if (this.triggerMapper) {
+                        const resolved = await this.triggerMapper.resolve(trigger, []);
+                        if (resolved.action === "none") {
+                            res.writeHead(200, { "Content-Type": "application/json" });
+                            res.end(JSON.stringify({ status: "no_mapping" }));
+                            return;
+                        }
+                        action = resolved.action;
+                        goalId = resolved.goal_id ?? undefined;
+                    }
+                    else {
+                        const mappingsConfig = await this.loadTriggerMappings();
+                        const mapping = mappingsConfig.mappings.find((m) => m.source === trigger.source && m.event_type === trigger.event_type);
+                        goalId = mapping?.goal_id ?? trigger.goal_id;
+                        if (!mapping) {
+                            if (!trigger.goal_id) {
+                                res.writeHead(200, { "Content-Type": "application/json" });
+                                res.end(JSON.stringify({ status: "no_mapping" }));
+                                return;
+                            }
+                            action = "observe";
+                        }
+                        else {
+                            action = mapping.action;
+                        }
+                    }
+                    await this.executeTriggerAction(action, trigger, goalId ?? undefined);
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ status: "ok", action, goal_id: goalId ?? null }));
+                }
+                catch (err) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Invalid trigger", details: String(err) }));
+                }
+            })();
+        });
+    }
+    async executeTriggerAction(action, trigger, goalId) {
+        if (action === "observe") {
+            const event = PulSeedEventSchema.parse({
+                type: "external",
+                source: trigger.source,
+                timestamp: new Date().toISOString(),
+                data: { ...trigger.data, event_type: trigger.event_type, goal_id: goalId },
+            });
+            try {
+                if (this.envelopeHook) {
+                    await this.envelopeHook(event);
+                }
+                else {
+                    await this.driveSystem.writeEvent(event);
+                }
+            }
+            catch (err) {
+                this.logger?.error(`EventServer: trigger observe failed: ${String(err)}`);
+                throw err;
+            }
+        }
+        else if (action === "create_task") {
+            const filename = `trigger_${Date.now()}_${Math.random().toString(36).slice(2)}.json`;
+            const filePath = path.join(this.eventsDir, filename);
+            const payload = {
+                type: "external",
+                source: trigger.source,
+                timestamp: new Date().toISOString(),
+                data: { ...trigger.data, event_type: trigger.event_type, action: "create_task", goal_id: goalId },
+            };
+            await fsp.writeFile(filePath, JSON.stringify(payload), "utf-8");
+        }
+        else if (action === "notify") {
+            this.logger?.warn(`EventServer: trigger notify — source=${trigger.source} event_type=${trigger.event_type} goal_id=${goalId ?? "none"}`);
+        }
+        else if (action === "wake") {
+            this.logger?.warn(`EventServer: trigger wake — source=${trigger.source} event_type=${trigger.event_type}`);
+        }
+    }
+    async loadTriggerMappings() {
+        if (this.triggerMappingsCache !== null)
+            return this.triggerMappingsCache;
+        const mappingsPath = path.join(this.eventsDir, "..", "trigger-mappings.json");
+        try {
+            const content = await fsp.readFile(mappingsPath, "utf-8");
+            const raw = JSON.parse(content);
+            this.triggerMappingsCache = TriggerMappingsConfigSchema.parse(raw);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "ENOENT") {
+                this.logger?.warn(`EventServer: failed to load trigger-mappings.json: ${String(err)}`);
+            }
+            this.triggerMappingsCache = { mappings: [] };
+        }
+        return this.triggerMappingsCache;
+    }
+    /** Invalidate the trigger mappings cache (for testing or hot-reload). */
+    invalidateTriggerMappingsCache() {
+        this.triggerMappingsCache = null;
+    }
+    async handleGetGoals(res) {
+        try {
+            const goals = await this.snapshotReader.readGoalSummaries();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(goals));
+        }
+        catch (err) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Internal error", details: String(err) }));
+        }
+    }
+    async handleGetGoalById(res, goalId) {
+        try {
+            const goal = await this.snapshotReader.readGoalDetail(goalId);
+            if (goal === null) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Goal not found" }));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(goal));
+        }
+        catch (err) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Internal error", details: String(err) }));
+        }
+    }
+    /** Check if server is running */
+    isRunning() {
+        return this.server !== null && this.server.listening;
+    }
+    /** Check if file watcher is active (internal use) */
+    isWatching() {
+        return this.fileWatcher !== null;
+    }
+    getPort() {
+        return this.port;
+    }
+    getHost() {
+        return this.host;
+    }
+    getEventsDir() {
+        return this.eventsDir;
+    }
+    async handleGetSnapshot(res) {
+        try {
+            const snapshot = await this.buildSnapshot();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(snapshot));
+        }
+        catch (err) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Internal error", details: String(err) }));
+        }
+    }
+    async handleStream(req, res, requestUrl) {
+        await this.sseManager.handleStream(req, res, requestUrl);
+    }
+    async dispatchCommandEnvelope(input) {
+        if (!this.commandEnvelopeHook)
+            return;
+        await this.commandEnvelopeHook(createEnvelope({
+            type: "command",
+            name: input.name,
+            source: "http",
+            goal_id: input.goalId,
+            priority: input.priority,
+            dedupe_key: input.dedupeKey,
+            payload: input.payload,
+        }));
+    }
+    async buildSnapshot() {
+        return this.snapshotReader.buildSnapshot(this.approvalBroker?.getPendingApprovalEvents() ?? [], this.outboxStore, this.activeWorkersProvider);
+    }
+}
+/** Read the full request body as a string (max 1 MB). */
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const MAX = 1_048_576;
+        let body = "";
+        let bytes = 0;
+        req.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > MAX) {
+                reject(new Error("Payload too large"));
+                req.destroy();
+                return;
+            }
+            body += chunk;
+        });
+        req.on("end", () => resolve(body));
+        req.on("error", reject);
+    });
+}
+//# sourceMappingURL=server.js.map