replicas-engine 0.1.6 → 0.1.7

package/dist/routes/codex.js

@@ -1,11 +1,10 @@
 import { Hono } from 'hono';
-import { stream } from 'hono/streaming';
 import { CodexManager } from '../services/codex-manager.js';
 const codex = new Hono();
 const codexManager = new CodexManager();
 /**
  * POST /codex/send
- * send a message to Codex and stream events back via Server-Sent Events (SSE)
+ * send a message to Codex (non-blocking, writes to JSONL automatically)
  */
 codex.post('/send', async (c) => {
     try {
@@ -14,27 +13,10 @@ codex.post('/send', async (c) => {
         if (!message || typeof message !== 'string') {
             return c.json({ error: 'Message is required and must be a string' }, 400);
         }
-        return stream(c, async (stream) => {
-            c.header('Content-Type', 'text/event-stream');
-            c.header('Cache-Control', 'no-cache');
-            c.header('Connection', 'keep-alive');
-            stream.onAbort(() => {
-                console.log('Client aborted SSE connection');
-            });
-            try {
-                for await (const event of codexManager.sendMessage(message)) {
-                    const sseData = `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
-                    await stream.write(sseData);
-                }
-                await stream.write('event: done\ndata: {}\n\n');
-            }
-            catch (error) {
-                console.error('Error during Codex streaming:', error);
-                const errorData = `event: error\ndata: ${JSON.stringify({
-                    message: error instanceof Error ? error.message : 'Unknown error occurred',
-                })}\n\n`;
-                await stream.write(errorData);
-            }
+        await codexManager.sendMessage(message);
+        return c.json({
+            success: true,
+            message: 'Message sent successfully',
         });
     }
     catch (error) {
@@ -69,6 +51,27 @@ codex.get('/history', async (c) => {
         }, 500);
     }
 });
+/**
+ * GET /codex/updates
+ * get new events since a given timestamp (for polling)
+ */
+codex.get('/updates', async (c) => {
+    try {
+        const since = c.req.query('since') || '';
+        if (!since) {
+            return c.json({ error: 'Missing "since" query parameter' }, 400);
+        }
+        const updates = await codexManager.getUpdates(since);
+        return c.json(updates);
+    }
+    catch (error) {
+        console.error('Error in /codex/updates:', error);
+        return c.json({
+            error: 'Failed to retrieve updates',
+            details: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
 /**
  * GET /codex/status
  * get current thread status and information

package/dist/services/codex-manager.js

@@ -22,7 +22,7 @@ export class CodexManager {
             }
         }
     }
-    async *sendMessage(message) {
+    async sendMessage(message) {
         if (!this.currentThread) {
             if (this.currentThreadId) {
                 console.log(`Resuming thread ${this.currentThreadId}`);
@@ -41,13 +41,10 @@ export class CodexManager {
                 });
             }
         }
-        const { events } = await this.currentThread.runStreamed(message);
-        for await (const event of events) {
-            if (event.type === 'thread.started') {
-                this.currentThreadId = event.thread_id;
-                console.log(`Thread started: ${this.currentThreadId}`);
-            }
-            yield event;
+        await this.currentThread.run(message);
+        if (!this.currentThreadId && this.currentThread.id) {
+            this.currentThreadId = this.currentThread.id;
+            console.log(`Thread started: ${this.currentThreadId}`);
         }
     }
     async getHistory() {
@@ -92,4 +89,32 @@ export class CodexManager {
     getThreadId() {
         return this.currentThreadId;
     }
+    async getUpdates(since) {
+        if (!this.currentThreadId) {
+            return {
+                events: [],
+                isComplete: true,
+            };
+        }
+        const sessionFile = await findSessionFile(this.currentThreadId);
+        if (!sessionFile) {
+            return {
+                events: [],
+                isComplete: true,
+            };
+        }
+        const allEvents = await readJSONL(sessionFile);
+        // Filter events that occurred after the 'since' timestamp
+        const filteredEvents = allEvents.filter((event) => {
+            return event.timestamp > since;
+        });
+        // Check if thread is complete by looking for turn.completed or error events
+        const isComplete = this.currentThread === null ||
+            allEvents.some((event) => event.type === 'event_msg' &&
+                (event.payload?.type === 'turn.completed' || event.payload?.type === 'error'));
+        return {
+            events: filteredEvents,
+            isComplete,
+        };
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/index.js",