@lovelybunch/api 1.0.66 → 1.0.67

package/dist/routes/api/v1/events/events.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Integration tests for Events API routes
+ */
+export {};

package/dist/routes/api/v1/events/events.test.js

@@ -0,0 +1,289 @@
+/**
+ * Integration tests for Events API routes
+ */
+import { describe, it, expect, beforeEach, afterEach, beforeAll } from "vitest";
+import { Hono } from "hono";
+import { promises as fs } from "fs";
+import path from "path";
+import os from "os";
+import { getLogger, resetLogger } from "@lovelybunch/core/logging";
+import events from "./index.js";
+describe("Events API Routes", () => {
+    let app;
+    let testDir;
+    let logsDir;
+    beforeAll(() => {
+        // Create the Hono app with routes
+        app = new Hono();
+        app.route("/api/v1/events", events);
+    });
+    beforeEach(async () => {
+        // Create a temporary directory for tests
+        testDir = path.join(os.tmpdir(), `coconut-events-test-${Date.now()}`);
+        logsDir = path.join(testDir, "logs");
+        await fs.mkdir(logsDir, { recursive: true });
+        // Reset the logger and create a new one with test directory
+        resetLogger();
+        getLogger({
+            coconutId: "test-coconut",
+            logsDir: logsDir,
+        });
+    });
+    afterEach(async () => {
+        // Clean up logger and test directory
+        const logger = getLogger();
+        await logger.close();
+        resetLogger();
+        try {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+        catch (err) {
+            // Ignore cleanup errors
+        }
+    });
+    describe("POST /api/v1/events", () => {
+        it("should enqueue a single event", async () => {
+            const event = {
+                kind: "proposal.create",
+                actor: "human:test@example.com",
+                subject: "proposal:cp-123",
+                tags: ["proposal"],
+                payload: { intent: "Test proposal" },
+            };
+            const res = await app.request("/api/v1/events", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(event),
+            });
+            expect(res.status).toBe(200);
+            const data = await res.json();
+            expect(data.accepted).toBe(1);
+            expect(data.last_seq).toBeGreaterThan(0);
+            // Verify event was written to file
+            await getLogger().flush();
+            const logFile = path.join(logsDir, "events-current.jsonl");
+            const content = await fs.readFile(logFile, "utf-8");
+            const lines = content.trim().split("\n");
+            expect(lines.length).toBeGreaterThan(0);
+            const loggedEvent = JSON.parse(lines[lines.length - 1]);
+            expect(loggedEvent.kind).toBe("proposal.create");
+            expect(loggedEvent.actor).toBe("human:test@example.com");
+        });
+        it("should enqueue multiple events", async () => {
+            const events = [
+                {
+                    kind: "proposal.create",
+                    actor: "human:test@example.com",
+                    subject: "proposal:cp-1",
+                },
+                {
+                    kind: "proposal.update",
+                    actor: "human:test@example.com",
+                    subject: "proposal:cp-2",
+                },
+                {
+                    kind: "proposal.status.change",
+                    actor: "human:test@example.com",
+                    subject: "proposal:cp-3",
+                },
+            ];
+            const res = await app.request("/api/v1/events", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(events),
+            });
+            expect(res.status).toBe(200);
+            const data = await res.json();
+            expect(data.accepted).toBe(3);
+            expect(data.last_seq).toBeGreaterThan(0);
+        });
+    });
+    describe("GET /api/v1/events", () => {
+        beforeEach(async () => {
+            // Pre-populate with some events
+            const logger = getLogger();
+            for (let i = 1; i <= 10; i++) {
+                logger.log({
+                    kind: "proposal.create",
+                    actor: "human:test@example.com",
+                    subject: `proposal:cp-${i}`,
+                    payload: { index: i },
+                });
+            }
+            await logger.flush();
+        });
+        it("should fetch events from current file", async () => {
+            const res = await app.request("/api/v1/events");
+            expect(res.status).toBe(200);
+            const data = await res.json();
+            expect(data.items).toBeDefined();
+            expect(Array.isArray(data.items)).toBe(true);
+            expect(data.items.length).toBe(10);
+            expect(data.next_since_seq).toBeGreaterThan(0);
+            expect(data.eof).toBe(true);
+        });
+        it("should support pagination with since_seq", async () => {
+            const res1 = await app.request("/api/v1/events?limit=5");
+            expect(res1.status).toBe(200);
+            const data1 = await res1.json();
+            expect(data1.items.length).toBe(5);
+            expect(data1.eof).toBe(false);
+            const nextSeq = data1.next_since_seq;
+            const res2 = await app.request(`/api/v1/events?since_seq=${nextSeq}&limit=5`);
+            expect(res2.status).toBe(200);
+            const data2 = await res2.json();
+            expect(data2.items.length).toBeGreaterThan(0);
+        });
+        it("should respect limit parameter", async () => {
+            const res = await app.request("/api/v1/events?limit=3");
+            expect(res.status).toBe(200);
+            const data = await res.json();
+            expect(data.items.length).toBe(3);
+            expect(data.eof).toBe(false);
+        });
+        it("should return empty array when no events exist", async () => {
+            // Clean up existing events
+            await getLogger().close();
+            resetLogger();
+            await fs.rm(logsDir, { recursive: true, force: true });
+            await fs.mkdir(logsDir, { recursive: true });
+            getLogger({
+                coconutId: "test-coconut",
+                logsDir: logsDir,
+            });
+            const res = await app.request("/api/v1/events");
+            expect(res.status).toBe(200);
+            const data = await res.json();
+            expect(data.items).toEqual([]);
+            expect(data.next_since_seq).toBe(0);
+            expect(data.eof).toBe(true);
+        });
+    });
+    describe("GET /api/v1/events/status", () => {
+        beforeEach(async () => {
+            // Pre-populate with some events
+            const logger = getLogger();
+            for (let i = 1; i <= 5; i++) {
+                logger.log({
+                    kind: "proposal.create",
+                    subject: `proposal:cp-${i}`,
+                });
+            }
+            await logger.flush();
+        });
+        it("should return logging system status", async () => {
+            const res = await app.request("/api/v1/events/status");
+            expect(res.status).toBe(200);
+            const data = await res.json();
+            expect(data.currentFile).toBe("events-current.jsonl");
+            expect(data.sizeBytes).toBeGreaterThan(0);
+            expect(data.lastSeq).toBe(5);
+            expect(data.rotateBytes).toBe(128 * 1024 * 1024);
+            expect(data.logsDir).toBeDefined();
+        });
+        it("should handle missing log file gracefully", async () => {
+            // Clean up existing events
+            await getLogger().close();
+            resetLogger();
+            await fs.rm(logsDir, { recursive: true, force: true });
+            await fs.mkdir(logsDir, { recursive: true });
+            getLogger({
+                coconutId: "test-coconut",
+                logsDir: logsDir,
+            });
+            const res = await app.request("/api/v1/events/status");
+            expect(res.status).toBe(200);
+            const data = await res.json();
+            expect(data.currentFile).toBeNull();
+            expect(data.sizeBytes).toBe(0);
+            expect(data.lastSeq).toBe(0);
+        });
+    });
+    describe("POST /api/v1/events/purge", () => {
+        beforeEach(async () => {
+            // Create some rotated files with different timestamps
+            const oldDate = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000); // 7 days ago
+            const recentDate = new Date(Date.now() - 1 * 24 * 60 * 60 * 1000); // 1 day ago
+            await fs.writeFile(path.join(logsDir, "events-20250101-120000.jsonl"), "");
+            await fs.utimes(path.join(logsDir, "events-20250101-120000.jsonl"), oldDate, oldDate);
+            await fs.writeFile(path.join(logsDir, "events-20250115-120000.jsonl"), "");
+            await fs.utimes(path.join(logsDir, "events-20250115-120000.jsonl"), recentDate, recentDate);
+        });
+        it("should delete old rotated files", async () => {
+            const beforeIso = new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString(); // 3 days ago
+            const res = await app.request("/api/v1/events/purge", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ beforeIso }),
+            });
+            expect(res.status).toBe(200);
+            const data = await res.json();
+            expect(data.deleted).toBe(1);
+            // Verify old file was deleted and recent file remains
+            const files = await fs.readdir(logsDir);
+            expect(files).toContain("events-20250115-120000.jsonl");
+            expect(files).not.toContain("events-20250101-120000.jsonl");
+        });
+        it("should never delete current file", async () => {
+            const logger = getLogger();
+            logger.log({ kind: "proposal.create", subject: "proposal:cp-1" });
+            await logger.flush();
+            const futureDate = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(); // tomorrow
+            const res = await app.request("/api/v1/events/purge", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ beforeIso: futureDate }),
+            });
+            expect(res.status).toBe(200);
+            // Current file should still exist
+            const currentFile = path.join(logsDir, "events-current.jsonl");
+            const exists = await fs
+                .access(currentFile)
+                .then(() => true)
+                .catch(() => false);
+            expect(exists).toBe(true);
+        });
+        it("should return error for missing beforeIso", async () => {
+            const res = await app.request("/api/v1/events/purge", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({}),
+            });
+            expect(res.status).toBe(400);
+            const data = await res.json();
+            expect(data.error).toBe("beforeIso is required");
+        });
+        it("should return error for invalid ISO date", async () => {
+            const res = await app.request("/api/v1/events/purge", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ beforeIso: "not-a-date" }),
+            });
+            expect(res.status).toBe(400);
+            const data = await res.json();
+            expect(data.error).toBe("Invalid ISO date");
+        });
+    });
+    describe("GET /api/v1/events/stream", () => {
+        it("should stream events via SSE", async () => {
+            // Pre-populate with some events
+            const logger = getLogger();
+            for (let i = 1; i <= 3; i++) {
+                logger.log({
+                    kind: "proposal.create",
+                    subject: `proposal:cp-${i}`,
+                    payload: { index: i },
+                });
+            }
+            await logger.flush();
+            const res = await app.request("/api/v1/events/stream");
+            expect(res.status).toBe(200);
+            expect(res.headers.get("content-type")).toContain("text/event-stream");
+            expect(res.headers.get("cache-control")).toContain("no-cache");
+            expect(res.headers.get("connection")).toContain("keep-alive");
+            // Note: Full SSE testing would require streaming the response body,
+            // which is complex in this test environment. This test validates
+            // that the endpoint returns the correct headers for SSE.
+        });
+    });
+});

package/dist/routes/api/v1/events/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Events API routes index
+ * Routes for Coconut activity logging events ingestion, retrieval, and streaming
+ */
+import { Hono } from 'hono';
+declare const events: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default events;

package/dist/routes/api/v1/events/index.js

@@ -0,0 +1,19 @@
+/**
+ * Events API routes index
+ * Routes for Coconut activity logging events ingestion, retrieval, and streaming
+ */
+import { Hono } from 'hono';
+import { GET, POST } from './route.js';
+import { GET as getStream } from './stream/route.js';
+import { GET as getStatus } from './status/route.js';
+import { POST as postPurge } from './purge/route.js';
+const events = new Hono();
+// Main events endpoints
+events.get('/', GET); // GET /api/v1/events?since_seq=&limit= - Fetch paged events
+events.post('/', POST); // POST /api/v1/events - Enqueue events
+// Streaming endpoint
+events.get('/stream', getStream); // GET /api/v1/events/stream?since_seq= - SSE streaming
+// Status and management endpoints
+events.get('/status', getStatus); // GET /api/v1/events/status - System diagnostics
+events.post('/purge', postPurge); // POST /api/v1/events/purge - Delete old rotated files
+export default events;

package/dist/routes/api/v1/events/purge/route.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Events purge endpoint
+ */
+import { Context } from "hono";
+/**
+ * POST /api/v1/events/purge
+ * Delete rotated files older than a timestamp
+ * Note: The current file is never deleted
+ */
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    deleted: number;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+    message: any;
+}, 500, "json">)>;

package/dist/routes/api/v1/events/purge/route.js

@@ -0,0 +1,62 @@
+/**
+ * Events purge endpoint
+ */
+import { promises as fs } from "fs";
+import path from "path";
+import { findGaitDirectory } from "../../../../../lib/gait-path.js";
+/**
+ * Get the events directory path
+ */
+async function getEventsDir() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, "logs");
+}
+/**
+ * POST /api/v1/events/purge
+ * Delete rotated files older than a timestamp
+ * Note: The current file is never deleted
+ */
+export async function POST(c) {
+    try {
+        const eventsDir = await getEventsDir();
+        if (!eventsDir) {
+            return c.json({ error: "Events directory not found" }, 404);
+        }
+        const body = await c.req.json();
+        const beforeIso = body.beforeIso;
+        if (!beforeIso) {
+            return c.json({ error: "beforeIso is required" }, 400);
+        }
+        const beforeDate = new Date(beforeIso);
+        if (isNaN(beforeDate.getTime())) {
+            return c.json({ error: "Invalid ISO date" }, 400);
+        }
+        // Read all files in the events directory
+        const files = await fs.readdir(eventsDir);
+        let deleted = 0;
+        for (const file of files) {
+            // Only process rotated event files (not events-current.jsonl or .seq)
+            if (!file.startsWith("events-") || file === "events-current.jsonl") {
+                continue;
+            }
+            const filePath = path.join(eventsDir, file);
+            const stats = await fs.stat(filePath);
+            // Check if file is older than the threshold
+            if (stats.mtime < beforeDate) {
+                await fs.unlink(filePath);
+                deleted++;
+            }
+        }
+        return c.json({
+            deleted,
+        });
+    }
+    catch (error) {
+        return c.json({
+            error: "Failed to purge events",
+            message: error.message,
+        }, 500);
+    }
+}

package/dist/routes/api/v1/events/route.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Events API routes for Coconut activity logging
+ * Provides endpoints for logging, querying, and streaming events
+ */
+import { Context } from "hono";
+/**
+ * POST /api/v1/events
+ * Enqueue one or many events
+ */
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    accepted: number;
+    last_seq: number;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+    message: any;
+}, 500, "json">)>;
+/**
+ * GET /api/v1/events?since_seq=&limit=
+ * Fetch a page of events from the current file
+ */
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    items: any[];
+    next_since_seq: number;
+    eof: boolean;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+    message: any;
+}, 500, "json">)>;

package/dist/routes/api/v1/events/route.js

@@ -0,0 +1,109 @@
+/**
+ * Events API routes for Coconut activity logging
+ * Provides endpoints for logging, querying, and streaming events
+ */
+import { getLogger } from "@lovelybunch/core/logging";
+import { promises as fs } from "fs";
+import * as fsSync from "fs";
+import path from "path";
+import { findGaitDirectory } from "../../../../lib/gait-path.js";
+import readline from "readline";
+/**
+ * Get the events directory path
+ */
+async function getEventsDir() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, "logs");
+}
+/**
+ * POST /api/v1/events
+ * Enqueue one or many events
+ */
+export async function POST(c) {
+    try {
+        const body = await c.req.json();
+        const logger = getLogger();
+        // Handle array of events or single event
+        const events = Array.isArray(body) ? body : [body];
+        let lastSeq = 0;
+        for (const event of events) {
+            logger.log(event);
+            lastSeq = logger.getSeq();
+        }
+        return c.json({
+            accepted: events.length,
+            last_seq: lastSeq,
+        });
+    }
+    catch (error) {
+        return c.json({
+            error: "Failed to enqueue events",
+            message: error.message,
+        }, 500);
+    }
+}
+/**
+ * GET /api/v1/events?since_seq=&limit=
+ * Fetch a page of events from the current file
+ */
+export async function GET(c) {
+    try {
+        const eventsDir = await getEventsDir();
+        if (!eventsDir) {
+            return c.json({ error: "Events directory not found" }, 404);
+        }
+        const url = new URL(c.req.url);
+        const sinceSeq = parseInt(url.searchParams.get("since_seq") || "0", 10);
+        const limit = Math.min(parseInt(url.searchParams.get("limit") || "1000", 10), 5000);
+        const currentFile = path.join(eventsDir, "events-current.jsonl");
+        // Check if file exists
+        try {
+            await fs.access(currentFile);
+        }
+        catch {
+            return c.json({
+                items: [],
+                next_since_seq: 0,
+                eof: true,
+            });
+        }
+        // Read events from file
+        const items = [];
+        const fileStream = fsSync.createReadStream(currentFile);
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity,
+        });
+        let lastSeq = sinceSeq;
+        let count = 0;
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                if (event.seq > sinceSeq && count < limit) {
+                    items.push(event);
+                    count++;
+                }
+                lastSeq = Math.max(lastSeq, event.seq);
+            }
+            catch (err) {
+                // Skip malformed lines
+                continue;
+            }
+        }
+        return c.json({
+            items,
+            next_since_seq: lastSeq,
+            eof: count < limit,
+        });
+    }
+    catch (error) {
+        return c.json({
+            error: "Failed to fetch events",
+            message: error.message,
+        }, 500);
+    }
+}

package/dist/routes/api/v1/events/status/route.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Events status endpoint
+ */
+import { Context } from "hono";
+/**
+ * GET /api/v1/events/status
+ * Get logging system status and configuration
+ */
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    currentFile: string;
+    sizeBytes: number;
+    lastSeq: number;
+    rotateBytes: number;
+    logsDir: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+    message: any;
+}, 500, "json">)>;

package/dist/routes/api/v1/events/status/route.js

@@ -0,0 +1,53 @@
+/**
+ * Events status endpoint
+ */
+import { getLogger } from "@lovelybunch/core/logging";
+import { promises as fs } from "fs";
+import path from "path";
+import { findGaitDirectory } from "../../../../../lib/gait-path.js";
+/**
+ * Get the events directory path
+ */
+async function getEventsDir() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, "logs");
+}
+/**
+ * GET /api/v1/events/status
+ * Get logging system status and configuration
+ */
+export async function GET(c) {
+    try {
+        const eventsDir = await getEventsDir();
+        if (!eventsDir) {
+            return c.json({ error: "Events directory not found" }, 404);
+        }
+        const logger = getLogger();
+        const currentFile = path.join(eventsDir, "events-current.jsonl");
+        let sizeBytes = 0;
+        let exists = false;
+        try {
+            const stats = await fs.stat(currentFile);
+            sizeBytes = stats.size;
+            exists = true;
+        }
+        catch {
+            // File doesn't exist yet
+        }
+        return c.json({
+            currentFile: exists ? "events-current.jsonl" : null,
+            sizeBytes,
+            lastSeq: logger.getSeq(),
+            rotateBytes: 128 * 1024 * 1024, // 128MB default
+            logsDir: eventsDir,
+        });
+    }
+    catch (error) {
+        return c.json({
+            error: "Failed to get status",
+            message: error.message,
+        }, 500);
+    }
+}

package/dist/routes/api/v1/events/stream/route.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Events streaming endpoint for real-time tailing
+ */
+import { Context } from "hono";
+/**
+ * GET /api/v1/events/stream?since_seq=
+ * Server-Sent Events stream for near real-time tails
+ */
+export declare function GET(c: Context): Promise<Response>;