replicas-engine 0.1.6 → 0.1.8

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

@@ -1,4 +1,5 @@
 import { Codex, Thread } from '@openai/codex-sdk';
+import { randomUUID } from 'crypto';
 import { findSessionFile, readJSONL } from '../utils/jsonl-reader.js';
 export class CodexManager {
     codex;
@@ -22,7 +23,7 @@ export class CodexManager {
             }
         }
     }
-    async *sendMessage(message) {
+    async sendMessage(message) {
         if (!this.currentThread) {
             if (this.currentThreadId) {
                 console.log(`Resuming thread ${this.currentThreadId}`);
@@ -39,16 +40,26 @@ export class CodexManager {
                     skipGitRepoCheck: true,
                     sandboxMode: 'danger-full-access',
                 });
+                if (this.currentThread.id) {
+                    this.currentThreadId = this.currentThread.id;
+                    console.log(`Thread started: ${this.currentThreadId}`);
+                }
+                // prime the thread with system instructions if thread is new
+                const workspaceName = process.env.WORKSPACE_NAME || 'workspace';
+                const workspaceBranchSegment = workspaceName
+                    .trim()
+                    .toLowerCase()
+                    .replace(/[^a-z0-9]+/g, '-')
+                    .replace(/^-+|-+$/g, '') || 'workspace';
+                const uuid = randomUUID().slice(0, 8);
+                const branchName = `replicas/${workspaceBranchSegment}-${uuid}`;
+                const systemMessage = `<replicas_important_instructions>When completing solutions, push your changes to branch ${branchName} and to origin. Greet the user.</replicas_important_instructions>`;
+                console.log('Priming thread with system instructions');
+                await this.currentThread.run(systemMessage);
+                console.log('Thread primed successfully');
             }
         }
-        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);
     }
     async getHistory() {
         if (!this.currentThreadId) {
@@ -67,9 +78,13 @@ export class CodexManager {
         }
         console.log(`Reading session file: ${sessionFile}`);
         const events = await readJSONL(sessionFile);
+        const filteredEvents = events.filter((event) => {
+            const eventStr = JSON.stringify(event);
+            return !eventStr.includes('<replicas_important_instructions>');
+        });
         return {
             thread_id: this.currentThreadId,
-            events,
+            events: filteredEvents,
         };
     }
     async getStatus() {
@@ -92,4 +107,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.8",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/index.js",