replicas-engine 0.1.2 → 0.1.4

package/dist/index.js

@@ -3,17 +3,12 @@ import 'dotenv/config';
 import { serve } from '@hono/node-server';
 import { Hono } from 'hono';
 import { authMiddleware } from './middleware/auth.js';
-import ping from './routes/ping.js';
 import codex from './routes/codex.js';
 const app = new Hono();
-// Health check endpoint (no auth required)
 app.get('/health', (c) => {
     return c.json({ status: 'ok', timestamp: new Date().toISOString() });
 });
-// Apply auth middleware to all routes below
 app.use('*', authMiddleware);
-// Protected routes
-app.route('/ping', ping);
 app.route('/codex', codex);
 const port = Number(process.env.PORT) || 3737;
 serve({

package/dist/routes/codex.js

@@ -2,11 +2,10 @@ import { Hono } from 'hono';
 import { stream } from 'hono/streaming';
 import { CodexManager } from '../services/codex-manager.js';
 const codex = new Hono();
-// Create a singleton instance of CodexManager
 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 and stream events back via Server-Sent Events (SSE)
  */
 codex.post('/send', async (c) => {
     try {
@@ -15,9 +14,7 @@ codex.post('/send', async (c) => {
         if (!message || typeof message !== 'string') {
             return c.json({ error: 'Message is required and must be a string' }, 400);
         }
-        // Stream events using SSE
         return stream(c, async (stream) => {
-            // Set SSE headers explicitly
             c.header('Content-Type', 'text/event-stream');
             c.header('Cache-Control', 'no-cache');
             c.header('Connection', 'keep-alive');
@@ -25,13 +22,10 @@ codex.post('/send', async (c) => {
                 console.log('Client aborted SSE connection');
             });
             try {
-                // Stream Codex events
                 for await (const event of codexManager.sendMessage(message)) {
-                    // Format as Server-Sent Event
                     const sseData = `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
                     await stream.write(sseData);
                 }
-                // Send a final 'done' event to signal completion
                 await stream.write('event: done\ndata: {}\n\n');
             }
             catch (error) {
@@ -53,7 +47,7 @@ codex.post('/send', async (c) => {
 });
 /**
  * GET /codex/history
- * Get the conversation history from the JSONL session file
+ * get the conversation history from the JSONL session file
  */
 codex.get('/history', async (c) => {
     try {
@@ -77,7 +71,7 @@ codex.get('/history', async (c) => {
 });
 /**
  * GET /codex/status
- * Get current thread status and information
+ * get current thread status and information
  */
 codex.get('/status', async (c) => {
     try {
@@ -94,7 +88,7 @@ codex.get('/status', async (c) => {
 });
 /**
  * POST /codex/reset
- * Reset the current thread and start fresh
+ * reset the current thread and start fresh
  */
 codex.post('/reset', async (c) => {
     try {

package/dist/services/codex-manager.js

@@ -1,9 +1,5 @@
 import { Codex, Thread } from '@openai/codex-sdk';
 import { findSessionFile, readJSONL } from '../utils/jsonl-reader.js';
-/**
- * Manages Codex thread lifecycle and session state
- * Currently supports a single active thread per engine instance
- */
 export class CodexManager {
     codex;
     currentThreadId = null;
@@ -11,14 +7,22 @@ export class CodexManager {
     workingDirectory;
     constructor(workingDirectory) {
         this.codex = new Codex();
-        this.workingDirectory = workingDirectory || process.env.WORKSPACE_HOME || process.env.HOME || '/home/ubuntu';
+        if (workingDirectory) {
+            this.workingDirectory = workingDirectory;
+        }
+        else {
+            const repoName = process.env.REPLICAS_REPO_NAME;
+            const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || '/home/ubuntu';
+            if (repoName) {
+                this.workingDirectory = `${workspaceHome}/workspaces/${repoName}`;
+                console.log(`Using repository working directory: ${this.workingDirectory}`);
+            }
+            else {
+                this.workingDirectory = workspaceHome;
+            }
+        }
     }
-    /**
-     * Send a message to Codex and stream events back
-     * Creates a new thread on first call, resumes existing thread on subsequent calls
-     */
     async *sendMessage(message) {
-        // Initialize or resume thread
         if (!this.currentThread) {
             if (this.currentThreadId) {
                 console.log(`Resuming thread ${this.currentThreadId}`);
@@ -37,10 +41,8 @@ export class CodexManager {
                 });
             }
         }
-        // Stream events from Codex
         const { events } = await this.currentThread.runStreamed(message);
         for await (const event of events) {
-            // Capture thread ID when thread starts
             if (event.type === 'thread.started') {
                 this.currentThreadId = event.thread_id;
                 console.log(`Thread started: ${this.currentThreadId}`);
@@ -48,9 +50,6 @@ export class CodexManager {
             yield event;
         }
     }
-    /**
-     * Get conversation history by reading the JSONL session file
-     */
     async getHistory() {
         if (!this.currentThreadId) {
             return {
@@ -73,9 +72,6 @@ export class CodexManager {
             events,
         };
     }
-    /**
-     * Get current thread status
-     */
     async getStatus() {
         let sessionFile = null;
         if (this.currentThreadId) {
@@ -88,17 +84,11 @@ export class CodexManager {
             working_directory: this.workingDirectory,
         };
     }
-    /**
-     * Reset the current thread (start fresh conversation)
-     */
     reset() {
         console.log('Resetting Codex thread');
         this.currentThread = null;
         this.currentThreadId = null;
     }
-    /**
-     * Get the current thread ID
-     */
     getThreadId() {
         return this.currentThreadId;
     }

package/dist/utils/jsonl-reader.js

@@ -1,9 +1,6 @@
 import { readFile, readdir, stat } from 'fs/promises';
 import { join } from 'path';
 import { homedir } from 'os';
-/**
- * Read and parse a JSONL file
- */
 export async function readJSONL(filePath) {
     try {
         const content = await readFile(filePath, 'utf-8');
@@ -26,24 +23,19 @@ export async function readJSONL(filePath) {
         return [];
     }
 }
-/**
- * Find the session file for a given thread ID
- * Sessions are stored in ~/.codex/sessions/YYYY/MM/DD/rollout-*-{threadId}.jsonl
- */
+// Sessions are stored in ~/.codex/sessions/YYYY/MM/DD/rollout-*-{threadId}.jsonl
 export async function findSessionFile(threadId) {
     const sessionsDir = join(homedir(), '.codex', 'sessions');
     try {
-        // Get current date for searching
+        // current date for searching
         const now = new Date();
         const year = now.getFullYear();
         const month = String(now.getMonth() + 1).padStart(2, '0');
         const day = String(now.getDate()).padStart(2, '0');
-        // Search in today's directory first
         const todayDir = join(sessionsDir, String(year), month, day);
         const file = await findFileInDirectory(todayDir, threadId);
         if (file)
             return file;
-        // If not found, search recent days (last 7 days)
         for (let daysAgo = 1; daysAgo <= 7; daysAgo++) {
             const date = new Date(now);
             date.setDate(date.getDate() - daysAgo);
@@ -62,9 +54,6 @@ export async function findSessionFile(threadId) {
         return null;
     }
 }
-/**
- * Search for a file containing the thread ID in a specific directory
- */
 async function findFileInDirectory(directory, threadId) {
     try {
         const files = await readdir(directory);
@@ -80,18 +69,13 @@ async function findFileInDirectory(directory, threadId) {
         return null;
     }
     catch (error) {
-        // Directory might not exist, which is fine
         return null;
     }
 }
-/**
- * Get the most recent session file path (for debugging/info)
- */
 export async function getMostRecentSessionFile() {
     const sessionsDir = join(homedir(), '.codex', 'sessions');
     try {
         const now = new Date();
-        // Search last 7 days for any session file
         for (let daysAgo = 0; daysAgo <= 7; daysAgo++) {
             const date = new Date(now);
             date.setDate(date.getDate() - daysAgo);
@@ -105,7 +89,6 @@ export async function getMostRecentSessionFile() {
                     .filter((f) => f.endsWith('.jsonl'))
                     .map((f) => join(searchDir, f));
                 if (jsonlFiles.length > 0) {
-                    // Return the most recent file based on modification time
                     const stats = await Promise.all(jsonlFiles.map(async (f) => ({
                         path: f,
                         mtime: (await stat(f)).mtime,

package/package.json

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

package/README.md

@@ -1,286 +0,0 @@
-# Replicas Engine
-
-A lightweight REST API server that runs on each Replicas workspace, providing programmatic access to workspace functionality without requiring SSH access.
-
-## Overview
-
-The Replicas Engine is automatically installed on every workspace and runs as a systemd service. It exposes a simple HTTP API protected by a secret key, allowing the Replicas backend to interact with workspaces for operations like reading logs, checking status, and more.
-
-## Features
-
-- **Lightweight**: Built with Hono for minimal overhead
-- **Secure**: All endpoints (except health check) require authentication via secret header
-- **Automatic**: Installed and configured automatically on workspace creation
-- **Reliable**: Runs as a systemd service with automatic restart
-
-## Installation
-
-The engine is automatically installed during workspace initialization. For manual installation:
-
-```bash
-npm install -g replicas-engine
-```
-
-## Configuration
-
-The engine requires the following environment variables:
-
-- `PORT` - Port to listen on (default: 3737)
-- `REPLICAS_ENGINE_SECRET` - Secret key for authentication (required)
-- `NODE_ENV` - Environment mode (production/development)
-- `WORKSPACE_HOME` - Working directory for Codex (default: `/home/ubuntu`)
-
-### Running as a Service
-
-The engine automatically runs as a systemd service named `replicas-engine`. You can manage it using:
-
-```bash
-# Check status
-systemctl status replicas-engine
-
-# View logs
-journalctl -u replicas-engine -f
-
-# Restart service
-sudo systemctl restart replicas-engine
-
-# Stop service
-sudo systemctl stop replicas-engine
-```
-
-## API Endpoints
-
-### Health Check
-
-**GET /health**
-
-Public endpoint for health checks (no authentication required).
-
-```bash
-curl http://localhost:3737/health
-```
-
-Response:
-```json
-{
-  "status": "ok",
-  "timestamp": "2025-10-26T04:00:00.000Z"
-}
-```
-
-### Ping
-
-**GET /ping**
-
-Authenticated endpoint for testing connectivity.
-
-```bash
-curl http://localhost:3737/ping \
-  -H "X-Replicas-Engine-Secret: your-secret-here"
-```
-
-Response:
-```json
-{
-  "message": "pong",
-  "timestamp": "2025-10-26T04:00:00.000Z"
-}
-```
-
----
-
-## Codex Integration
-
-The engine provides remote control of Codex coding agents running on the workspace.
-
-### Send Message (with Streaming)
-
-**POST /codex/send**
-
-Send a message to Codex and stream events back via Server-Sent Events (SSE).
-
-```bash
-curl -N http://localhost:3737/codex/send \
-  -H "X-Replicas-Engine-Secret: your-secret-here" \
-  -H "Content-Type: application/json" \
-  -d '{"message": "Add error handling to the login function"}'
-```
-
-**Request Body:**
-```json
-{
-  "message": "Your instruction to Codex"
-}
-```
-
-**Response (SSE Stream):**
-```
-event: thread.started
-data: {"thread_id":"019a1caa-bceb-7731-b607-e9d22c1933a5"}
-
-event: turn.started
-data: {}
-
-event: item.started
-data: {"item":{"id":"...","type":"agent_message","text":"..."}}
-
-event: item.completed
-data: {"item":{"id":"...","type":"agent_message","text":"I'll help add error handling..."}}
-
-event: turn.completed
-data: {"usage":{"input_tokens":100,"output_tokens":50,"cached_input_tokens":0}}
-
-event: done
-data: {}
-```
-
-**Event Types:**
-- `thread.started` - New thread created (includes thread_id)
-- `turn.started` - Turn begins
-- `item.started` - New item (message, command, file change, etc.)
-- `item.updated` - Item updated
-- `item.completed` - Item finished
-- `turn.completed` - Turn ends (includes token usage)
-- `error` - Error occurred
-- `done` - Stream completed
-
-### Get Conversation History
-
-**GET /codex/history**
-
-Retrieve the full conversation history from the JSONL session file.
-
-```bash
-curl http://localhost:3737/codex/history \
-  -H "X-Replicas-Engine-Secret: your-secret-here"
-```
-
-**Response:**
-```json
-{
-  "thread_id": "019a1caa-bceb-7731-b607-e9d22c1933a5",
-  "events": [
-    {
-      "timestamp": "2025-10-25T18:39:02.919Z",
-      "type": "session_meta",
-      "payload": {...}
-    },
-    {
-      "timestamp": "2025-10-25T18:52:11.923Z",
-      "type": "response_item",
-      "payload": {"type": "message", "role": "user", ...}
-    }
-  ]
-}
-```
-
-### Get Thread Status
-
-**GET /codex/status**
-
-Get information about the current Codex thread.
-
-```bash
-curl http://localhost:3737/codex/status \
-  -H "X-Replicas-Engine-Secret: your-secret-here"
-```
-
-**Response:**
-```json
-{
-  "has_active_thread": true,
-  "thread_id": "019a1caa-bceb-7731-b607-e9d22c1933a5",
-  "session_file": "/home/ubuntu/.codex/sessions/2025/10/25/rollout-2025-10-25T18:39:02.891Z-019a1caa.jsonl",
-  "working_directory": "/home/ubuntu"
-}
-```
-
-### Reset Thread
-
-**POST /codex/reset**
-
-Clear the current thread and start a fresh conversation.
-
-```bash
-curl -X POST http://localhost:3737/codex/reset \
-  -H "X-Replicas-Engine-Secret: your-secret-here"
-```
-
-**Response:**
-```json
-{
-  "message": "Thread reset successfully",
-  "success": true
-}
-```
-
-### Codex Usage Notes
-
-- **Single Session**: Currently supports one active thread per workspace
-- **Thread Continuity**: Subsequent calls to `/codex/send` continue the same conversation
-- **Persistence**: Threads are automatically saved to `~/.codex/sessions/`
-- **Working Directory**: Codex runs in `WORKSPACE_HOME` (default: `/home/ubuntu`)
-- **Git Repository**: Git check is skipped to allow running in any directory
-
----
-
-## Authentication
-
-All endpoints (except `/health`) require the `X-Replicas-Engine-Secret` header:
-
-```
-X-Replicas-Engine-Secret: <workspace-engine-secret>
-```
-
-Requests without this header or with an invalid secret will receive a 401 Unauthorized response.
-
-## Development
-
-```bash
-# Install dependencies
-yarn install
-
-# Run in development mode
-yarn dev
-
-# Build for production
-yarn build
-
-# Run built version
-yarn start
-```
-
-## Security
-
-- The engine only listens on port 3737
-- All requests require a secret key
-- The secret is generated uniquely per workspace
-- The service runs as the workspace user (no root access)
-
-## Troubleshooting
-
-### Engine not responding
-
-1. Check if the service is running:
-   ```bash
-   systemctl status replicas-engine
-   ```
-
-2. Check the logs:
-   ```bash
-   journalctl -u replicas-engine -n 50
-   ```
-
-3. Verify the port is listening:
-   ```bash
-   sudo netstat -tlnp | grep 3737
-   ```
-
-### Authentication errors
-
-- Ensure you're using the correct `engine_secret` from the workspace record
-- Verify the `X-Replicas-Engine-Secret` header is being sent
-
-## License
-
-MIT