replicas-engine 0.1.11 → 0.1.12

package/dist/src/index.js

@@ -0,0 +1,699 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import "dotenv/config";
+import { serve } from "@hono/node-server";
+import { Hono as Hono3 } from "hono";
+import { readFile as readFile2 } from "fs/promises";
+
+// src/middleware/auth.ts
+var authMiddleware = async (c, next) => {
+  const secret = c.req.header("X-Replicas-Engine-Secret");
+  const expectedSecret = process.env.REPLICAS_ENGINE_SECRET;
+  if (!expectedSecret) {
+    return c.json(
+      { error: "Server configuration error: REPLICAS_ENGINE_SECRET not set" },
+      500
+    );
+  }
+  if (!secret) {
+    return c.json(
+      { error: "Unauthorized: X-Replicas-Engine-Secret header required" },
+      401
+    );
+  }
+  if (secret !== expectedSecret) {
+    return c.json({ error: "Unauthorized: Invalid secret" }, 401);
+  }
+  await next();
+};
+
+// src/routes/codex.ts
+import { Hono } from "hono";
+
+// src/services/codex-manager.ts
+import { Codex } from "@openai/codex-sdk";
+
+// src/utils/jsonl-reader.ts
+import { readFile } from "fs/promises";
+async function readJSONL(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.split("\n").filter((line) => line.trim());
+    const events = lines.map((line, index) => {
+      try {
+        return JSON.parse(line);
+      } catch (e) {
+        return null;
+      }
+    }).filter((event) => event !== null);
+    return events;
+  } catch (error) {
+    return [];
+  }
+}
+
+// src/services/codex-manager.ts
+import { readdir, stat } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+var CodexManager = class {
+  codex;
+  currentThreadId = null;
+  currentThread = null;
+  workingDirectory;
+  processing = false;
+  constructor(workingDirectory) {
+    this.codex = new Codex();
+    if (workingDirectory) {
+      this.workingDirectory = workingDirectory;
+    } else {
+      const repoName = process.env.REPLICAS_REPO_NAME;
+      const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir();
+      if (repoName) {
+        this.workingDirectory = join(workspaceHome, "workspaces", repoName);
+      } else {
+        this.workingDirectory = workspaceHome;
+      }
+    }
+  }
+  isProcessing() {
+    return this.processing;
+  }
+  async sendMessage(message, model, customInstructions) {
+    try {
+      this.processing = true;
+      if (!this.currentThread) {
+        if (this.currentThreadId) {
+          this.currentThread = this.codex.resumeThread(this.currentThreadId, {
+            workingDirectory: this.workingDirectory,
+            skipGitRepoCheck: true,
+            sandboxMode: "danger-full-access",
+            model: model || "gpt-5-codex"
+          });
+        } else {
+          this.currentThread = this.codex.startThread({
+            workingDirectory: this.workingDirectory,
+            skipGitRepoCheck: true,
+            sandboxMode: "danger-full-access",
+            model: model || "gpt-5-codex"
+          });
+          if (customInstructions) {
+            message = customInstructions + "\n" + message;
+          }
+        }
+      }
+      const { events } = await this.currentThread.runStreamed(message);
+      for await (const event of events) {
+        if (event.type === "thread.started") {
+          this.currentThreadId = event.thread_id;
+          break;
+        }
+      }
+      if (!this.currentThreadId && this.currentThread.id) {
+        this.currentThreadId = this.currentThread.id;
+      }
+    } finally {
+      this.processing = false;
+    }
+  }
+  async getHistory() {
+    if (!this.currentThreadId) {
+      return {
+        thread_id: null,
+        events: []
+      };
+    }
+    const sessionFile = await this.findSessionFile(this.currentThreadId);
+    if (!sessionFile) {
+      return {
+        thread_id: this.currentThreadId,
+        events: []
+      };
+    }
+    const events = await readJSONL(sessionFile);
+    return {
+      thread_id: this.currentThreadId,
+      events
+    };
+  }
+  async getStatus() {
+    let sessionFile = null;
+    if (this.currentThreadId) {
+      sessionFile = await this.findSessionFile(this.currentThreadId);
+    }
+    return {
+      has_active_thread: this.currentThreadId !== null,
+      thread_id: this.currentThreadId,
+      session_file: sessionFile,
+      working_directory: this.workingDirectory
+    };
+  }
+  async reset() {
+    this.currentThread = null;
+    this.currentThreadId = null;
+    this.processing = false;
+  }
+  getThreadId() {
+    return this.currentThreadId;
+  }
+  async getUpdates(since) {
+    if (!this.currentThreadId) {
+      return {
+        events: [],
+        isComplete: true
+      };
+    }
+    const sessionFile = await this.findSessionFile(this.currentThreadId);
+    if (!sessionFile) {
+      return {
+        events: [],
+        isComplete: true
+      };
+    }
+    const allEvents = await readJSONL(sessionFile);
+    const events = allEvents.filter((event) => event.timestamp > since);
+    const isComplete = allEvents.some((event) => event.type === "turn.completed");
+    return {
+      events,
+      isComplete
+    };
+  }
+  // Helper methods for finding session files
+  async findSessionFile(threadId) {
+    const sessionsDir = join(homedir(), ".codex", "sessions");
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const year = now.getFullYear();
+      const month = String(now.getMonth() + 1).padStart(2, "0");
+      const day = String(now.getDate()).padStart(2, "0");
+      const todayDir = join(sessionsDir, String(year), month, day);
+      const file = await this.findFileInDirectory(todayDir, threadId);
+      if (file) return file;
+      for (let daysAgo = 1; daysAgo <= 7; daysAgo++) {
+        const date = new Date(now);
+        date.setDate(date.getDate() - daysAgo);
+        const searchYear = date.getFullYear();
+        const searchMonth = String(date.getMonth() + 1).padStart(2, "0");
+        const searchDay = String(date.getDate()).padStart(2, "0");
+        const searchDir = join(sessionsDir, String(searchYear), searchMonth, searchDay);
+        const file2 = await this.findFileInDirectory(searchDir, threadId);
+        if (file2) return file2;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  async findFileInDirectory(directory, threadId) {
+    try {
+      const files = await readdir(directory);
+      for (const file of files) {
+        if (file.endsWith(".jsonl") && file.includes(threadId)) {
+          const fullPath = join(directory, file);
+          const stats = await stat(fullPath);
+          if (stats.isFile()) {
+            return fullPath;
+          }
+        }
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+};
+
+// src/routes/codex.ts
+var codex = new Hono();
+var codexManager = new CodexManager();
+codex.post("/send", async (c) => {
+  try {
+    const body = await c.req.json();
+    const { message, model, customInstructions } = body;
+    if (!message || typeof message !== "string") {
+      return c.json({ error: "Message is required and must be a string" }, 400);
+    }
+    if (codexManager.isProcessing()) {
+      return c.json(
+        {
+          error: "A turn is already in progress. Please wait."
+        },
+        400
+      );
+    }
+    codexManager.sendMessage(message, model, customInstructions).catch((error) => {
+      console.error("[Codex Route] Error in background message processing:", error);
+    });
+    return c.json({
+      success: true,
+      message: "Message sent successfully"
+    });
+  } catch (error) {
+    console.error("Error in /codex/send:", error);
+    return c.json(
+      {
+        error: "Failed to process message",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+codex.get("/history", async (c) => {
+  try {
+    const history = await codexManager.getHistory();
+    if (!history.thread_id) {
+      return c.json({
+        message: "No active thread",
+        thread_id: null,
+        events: []
+      });
+    }
+    return c.json(history);
+  } catch (error) {
+    console.error("Error in /codex/history:", error);
+    return c.json(
+      {
+        error: "Failed to retrieve history",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+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
+    );
+  }
+});
+codex.get("/status", async (c) => {
+  try {
+    const status = await codexManager.getStatus();
+    return c.json(status);
+  } catch (error) {
+    console.error("Error in /codex/status:", error);
+    return c.json(
+      {
+        error: "Failed to retrieve status",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+codex.post("/reset", async (c) => {
+  try {
+    await codexManager.reset();
+    return c.json({
+      message: "Thread reset successfully",
+      success: true
+    });
+  } catch (error) {
+    console.error("Error in /codex/reset:", error);
+    return c.json(
+      {
+        error: "Failed to reset thread",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+var codex_default = codex;
+
+// src/routes/claude.ts
+import { Hono as Hono2 } from "hono";
+
+// src/services/claude-manager.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+import { join as join2 } from "path";
+import { mkdir, appendFile, rm } from "fs/promises";
+import { homedir as homedir2 } from "os";
+var ClaudeManager = class {
+  workingDirectory;
+  historyFile;
+  sessionId = null;
+  initialized;
+  processing = false;
+  constructor(workingDirectory) {
+    if (workingDirectory) {
+      this.workingDirectory = workingDirectory;
+    } else {
+      const repoName = process.env.REPLICAS_REPO_NAME;
+      const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME || homedir2();
+      if (repoName) {
+        this.workingDirectory = join2(workspaceHome, "workspaces", repoName);
+      } else {
+        this.workingDirectory = workspaceHome;
+      }
+    }
+    this.historyFile = join2(homedir2(), ".replicas", "claude", "history.jsonl");
+    this.initialized = this.initialize();
+  }
+  isProcessing() {
+    return this.processing;
+  }
+  async sendMessage(message, model, customInstructions) {
+    if (!message || !message.trim()) {
+      throw new Error("Message cannot be empty");
+    }
+    await this.initialized;
+    this.processing = true;
+    try {
+      const userMessage = {
+        type: "user",
+        message: {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: message
+            }
+          ]
+        },
+        parent_tool_use_id: null,
+        session_id: this.sessionId ?? ""
+      };
+      await this.recordEvent(userMessage);
+      const promptIterable = (async function* () {
+        yield userMessage;
+      })();
+      const response = query({
+        prompt: promptIterable,
+        options: {
+          resume: this.sessionId || void 0,
+          cwd: this.workingDirectory,
+          permissionMode: "bypassPermissions",
+          allowDangerouslySkipPermissions: true,
+          settingSources: ["user", "project", "local"],
+          systemPrompt: {
+            type: "preset",
+            preset: "claude_code",
+            append: customInstructions
+          },
+          env: process.env,
+          model: model || "sonnet"
+        }
+      });
+      for await (const msg of response) {
+        await this.handleMessage(msg);
+      }
+    } finally {
+      this.processing = false;
+    }
+  }
+  async getHistory() {
+    await this.initialized;
+    const events = await readJSONL(this.historyFile);
+    return {
+      thread_id: this.sessionId,
+      events
+    };
+  }
+  async getStatus() {
+    await this.initialized;
+    const status = {
+      has_active_thread: this.processing,
+      thread_id: this.sessionId,
+      working_directory: this.workingDirectory
+    };
+    return status;
+  }
+  async getUpdates(since) {
+    await this.initialized;
+    const allEvents = await readJSONL(this.historyFile);
+    const events = allEvents.filter((event) => event.timestamp > since);
+    const isComplete = !this.processing;
+    return { events, isComplete };
+  }
+  async reset() {
+    await this.initialized;
+    this.sessionId = null;
+    this.processing = false;
+    try {
+      await rm(this.historyFile, { force: true });
+    } catch {
+    }
+  }
+  async initialize() {
+    const historyDir = join2(homedir2(), ".replicas", "claude");
+    await mkdir(historyDir, { recursive: true });
+  }
+  async handleMessage(message) {
+    if ("session_id" in message && message.session_id && !this.sessionId) {
+      this.sessionId = message.session_id;
+    }
+    await this.recordEvent(message);
+  }
+  async recordEvent(event) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const jsonEvent = {
+      timestamp,
+      type: `claude-${event.type}`,
+      payload: event
+    };
+    await appendFile(this.historyFile, JSON.stringify(jsonEvent) + "\n", "utf-8");
+  }
+};
+
+// src/routes/claude.ts
+var claude = new Hono2();
+var claudeManager = new ClaudeManager();
+claude.post("/send", async (c) => {
+  try {
+    const body = await c.req.json();
+    const { message, model, customInstructions } = body;
+    if (!message || typeof message !== "string") {
+      return c.json({ error: "Message is required and must be a string" }, 400);
+    }
+    if (claudeManager.isProcessing()) {
+      return c.json(
+        {
+          error: "A turn is already in progress. Please wait."
+        },
+        400
+      );
+    }
+    claudeManager.sendMessage(message, model, customInstructions).catch((error) => {
+      console.error("[Claude Route] Error in background message processing:", error);
+    });
+    return c.json({
+      success: true,
+      message: "Message sent successfully"
+    });
+  } catch (error) {
+    console.error("Error in /claude/send:", error);
+    return c.json(
+      {
+        error: "Failed to process message",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+claude.get("/history", async (c) => {
+  try {
+    const history = await claudeManager.getHistory();
+    if (!history.thread_id) {
+      return c.json({
+        message: "No active session",
+        thread_id: null,
+        events: []
+      });
+    }
+    return c.json(history);
+  } catch (error) {
+    console.error("Error in /claude/history:", error);
+    return c.json(
+      {
+        error: "Failed to retrieve history",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+claude.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 claudeManager.getUpdates(since);
+    return c.json(updates);
+  } catch (error) {
+    console.error("Error in /claude/updates:", error);
+    return c.json(
+      {
+        error: "Failed to retrieve updates",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+claude.get("/status", async (c) => {
+  try {
+    const status = await claudeManager.getStatus();
+    return c.json(status);
+  } catch (error) {
+    console.error("Error in /claude/status:", error);
+    return c.json(
+      {
+        error: "Failed to retrieve status",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+claude.post("/reset", async (c) => {
+  try {
+    await claudeManager.reset();
+    return c.json({
+      message: "Session reset successfully",
+      success: true
+    });
+  } catch (error) {
+    console.error("Error in /claude/reset:", error);
+    return c.json(
+      {
+        error: "Failed to reset session",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+var claude_default = claude;
+
+// src/utils/git.ts
+import { execSync } from "child_process";
+function getCurrentBranch(cwd) {
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return branch;
+  } catch (error) {
+    console.error("Error getting current branch:", error);
+    return null;
+  }
+}
+function getGitDiff(cwd) {
+  try {
+    const shortstat = execSync("git diff --shortstat -M", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    let added = 0;
+    let removed = 0;
+    const addedMatch = shortstat.match(/(\d+) insertion/);
+    const removedMatch = shortstat.match(/(\d+) deletion/);
+    if (addedMatch) {
+      added = parseInt(addedMatch[1], 10);
+    }
+    if (removedMatch) {
+      removed = parseInt(removedMatch[1], 10);
+    }
+    const fullDiff = execSync("git diff -M -C", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return {
+      added,
+      removed,
+      fullDiff
+    };
+  } catch (error) {
+    console.error("Error getting git diff:", error);
+    return null;
+  }
+}
+
+// src/index.ts
+var READY_MESSAGE = "========= REPLICAS WORKSPACE READY ==========";
+var COMPLETION_MESSAGE = "========= REPLICAS WORKSPACE INITIALIZATION COMPLETE ==========";
+var app = new Hono3();
+app.get("/health", async (c) => {
+  try {
+    const logContent = await readFile2("/var/log/cloud-init-output.log", "utf-8");
+    let status;
+    if (logContent.includes(COMPLETION_MESSAGE)) {
+      status = "active";
+    } else if (logContent.includes(READY_MESSAGE)) {
+      status = "ready";
+    } else {
+      status = "initializing";
+    }
+    return c.json({ status, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  } catch (error) {
+    return c.json({ status: "initializing", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+});
+app.get("/status", async (c) => {
+  try {
+    const isCodexProcessing = codexManager.isProcessing();
+    const isClaudeProcessing = claudeManager.isProcessing();
+    const codexHistory = await codexManager.getHistory();
+    const claudeHistory = await claudeManager.getHistory();
+    const isCodexUsed = codexHistory.thread_id !== null;
+    const isClaudeUsed = claudeHistory.thread_id !== null;
+    const claudeStatus = await claudeManager.getStatus();
+    const workingDirectory = claudeStatus.working_directory;
+    const branch = getCurrentBranch(workingDirectory);
+    const gitDiff = getGitDiff(workingDirectory);
+    return c.json({
+      isCodexProcessing,
+      isClaudeProcessing,
+      isCodexUsed,
+      isClaudeUsed,
+      branch,
+      gitDiff
+    });
+  } catch (error) {
+    console.error("Error getting workspace status:", error);
+    return c.json(
+      {
+        error: "Failed to get workspace status",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+app.use("*", authMiddleware);
+app.route("/codex", codex_default);
+app.route("/claude", claude_default);
+var port = Number(process.env.PORT) || 3737;
+serve(
+  {
+    fetch: app.fetch,
+    port
+  },
+  (info) => {
+    console.log(`Replicas Engine running on port ${info.port}`);
+  }
+);

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "dist/src/index.js",
   "bin": {
-    "replicas-engine": "./dist/index.js"
+    "replicas-engine": "./dist/src/index.js"
   },
   "files": [
     "dist"
   ],
   "scripts": {
     "dev": "tsx watch src/index.ts",
-    "build": "tsc && node scripts/postbuild.js",
-    "start": "node dist/index.js",
+    "build": "tsup",
+    "start": "node dist/src/index.js",
+    "dev-sync": "scripts/dev-sync.sh",
     "prepublishOnly": "yarn build"
   },
   "keywords": [
@@ -25,13 +26,16 @@
   "author": "Replicas",
   "license": "MIT",
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.1.30",
     "@hono/node-server": "^1.19.5",
     "@openai/codex-sdk": "^0.50.0",
     "dotenv": "^17.2.3",
-    "hono": "^4.10.3"
+    "hono": "^4.10.3",
+    "zod": "3.24.1"
   },
   "devDependencies": {
     "@types/node": "^20.11.17",
+    "tsup": "^8.5.0",
     "tsx": "^4.7.1",
     "typescript": "^5.8.3"
   }

package/dist/index.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-import 'dotenv/config';
-import { serve } from '@hono/node-server';
-import { Hono } from 'hono';
-import { readFile } from 'fs/promises';
-import { authMiddleware } from './middleware/auth.js';
-import codex from './routes/codex.js';
-// NOTE: These constants are duplicated in @replicas/shared/src/workspaces/WorkspaceInitializer.ts
-// If you change these values, you MUST update both locations to keep them in sync.
-const READY_MESSAGE = '========= REPLICAS WORKSPACE READY ==========';
-const COMPLETION_MESSAGE = '========= REPLICAS WORKSPACE INITIALIZATION COMPLETE ==========';
-const app = new Hono();
-app.get('/health', async (c) => {
-    try {
-        const logContent = await readFile('/var/log/cloud-init-output.log', 'utf-8');
-        let status;
-        if (logContent.includes(COMPLETION_MESSAGE)) {
-            status = 'active';
-        }
-        else if (logContent.includes(READY_MESSAGE)) {
-            status = 'ready';
-        }
-        else {
-            status = 'initializing';
-        }
-        return c.json({ status, timestamp: new Date().toISOString() });
-    }
-    catch (error) {
-        return c.json({ status: 'initializing', timestamp: new Date().toISOString() });
-    }
-});
-app.use('*', authMiddleware);
-app.route('/codex', codex);
-const port = Number(process.env.PORT) || 3737;
-serve({
-    fetch: app.fetch,
-    port,
-}, (info) => {
-    console.log(`Replicas Engine running on port ${info.port}`);
-});

package/dist/middleware/auth.js

@@ -1,14 +0,0 @@
-export const authMiddleware = async (c, next) => {
-    const secret = c.req.header('X-Replicas-Engine-Secret');
-    const expectedSecret = process.env.REPLICAS_ENGINE_SECRET;
-    if (!expectedSecret) {
-        return c.json({ error: 'Server configuration error: REPLICAS_ENGINE_SECRET not set' }, 500);
-    }
-    if (!secret) {
-        return c.json({ error: 'Unauthorized: X-Replicas-Engine-Secret header required' }, 401);
-    }
-    if (secret !== expectedSecret) {
-        return c.json({ error: 'Unauthorized: Invalid secret' }, 401);
-    }
-    await next();
-};

package/dist/routes/codex.js

@@ -1,112 +0,0 @@
-import { Hono } from 'hono';
-import { CodexManager } from '../services/codex-manager.js';
-const codex = new Hono();
-const codexManager = new CodexManager();
-/**
- * POST /codex/send
- * send a message to Codex (non-blocking, writes to JSONL automatically)
- */
-codex.post('/send', async (c) => {
-    try {
-        const body = await c.req.json();
-        const { message } = body;
-        if (!message || typeof message !== 'string') {
-            return c.json({ error: 'Message is required and must be a string' }, 400);
-        }
-        await codexManager.sendMessage(message);
-        return c.json({
-            success: true,
-            message: 'Message sent successfully',
-        });
-    }
-    catch (error) {
-        console.error('Error in /codex/send:', error);
-        return c.json({
-            error: 'Failed to process message',
-            details: error instanceof Error ? error.message : 'Unknown error',
-        }, 500);
-    }
-});
-/**
- * GET /codex/history
- * get the conversation history from the JSONL session file
- */
-codex.get('/history', async (c) => {
-    try {
-        const history = await codexManager.getHistory();
-        if (!history.thread_id) {
-            return c.json({
-                message: 'No active thread',
-                thread_id: null,
-                events: [],
-            });
-        }
-        return c.json(history);
-    }
-    catch (error) {
-        console.error('Error in /codex/history:', error);
-        return c.json({
-            error: 'Failed to retrieve history',
-            details: error instanceof Error ? error.message : 'Unknown error',
-        }, 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
- */
-codex.get('/status', async (c) => {
-    try {
-        const status = await codexManager.getStatus();
-        return c.json(status);
-    }
-    catch (error) {
-        console.error('Error in /codex/status:', error);
-        return c.json({
-            error: 'Failed to retrieve status',
-            details: error instanceof Error ? error.message : 'Unknown error',
-        }, 500);
-    }
-});
-/**
- * POST /codex/reset
- * reset the current thread and start fresh
- */
-codex.post('/reset', async (c) => {
-    try {
-        codexManager.reset();
-        return c.json({
-            message: 'Thread reset successfully',
-            success: true,
-        });
-    }
-    catch (error) {
-        console.error('Error in /codex/reset:', error);
-        return c.json({
-            error: 'Failed to reset thread',
-            details: error instanceof Error ? error.message : 'Unknown error',
-        }, 500);
-    }
-});
-export default codex;

package/dist/routes/ping.js

@@ -1,9 +0,0 @@
-import { Hono } from 'hono';
-const ping = new Hono();
-ping.get('/', (c) => {
-    return c.json({
-        message: 'pong',
-        timestamp: new Date().toISOString(),
-    });
-});
-export default ping;

package/dist/services/codex-manager.js

@@ -1,210 +0,0 @@
-import { Codex, Thread } from '@openai/codex-sdk';
-import { randomUUID } from 'crypto';
-import { findSessionFile, readJSONL } from '../utils/jsonl-reader.js';
-export class CodexManager {
-    codex;
-    currentThreadId = null;
-    currentThread = null;
-    workingDirectory;
-    constructor(workingDirectory) {
-        this.codex = new Codex();
-        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;
-            }
-        }
-    }
-    async sendMessage(message) {
-        console.log(`[CodexManager] sendMessage called with message length: ${message.length}`);
-        if (!this.currentThread) {
-            if (this.currentThreadId) {
-                console.log(`[CodexManager] Resuming existing thread: ${this.currentThreadId}`);
-                this.currentThread = this.codex.resumeThread(this.currentThreadId, {
-                    workingDirectory: this.workingDirectory,
-                    skipGitRepoCheck: true,
-                    sandboxMode: 'danger-full-access',
-                });
-                console.log(`[CodexManager] Thread resumed successfully`);
-            }
-            else {
-                console.log('[CodexManager] No existing thread, starting new thread');
-                console.log(`[CodexManager] Working directory: ${this.workingDirectory}`);
-                const thread = this.codex.startThread({
-                    workingDirectory: this.workingDirectory,
-                    skipGitRepoCheck: true,
-                    sandboxMode: 'danger-full-access',
-                });
-                this.currentThread = thread;
-                console.log(`[CodexManager] Thread object created, ID at creation: ${thread.id || 'null'}`);
-                // prime the thread with system instructions if thread is new
-                const workspaceName = process.env.WORKSPACE_NAME || 'workspace';
-                console.log(`[CodexManager] Workspace name from env: ${workspaceName}`);
-                const workspaceBranchSegment = workspaceName
-                    .trim()
-                    .toLowerCase()
-                    .replace(/[^a-z0-9]+/g, '-')
-                    .replace(/^-+|-+$/g, '') || 'workspace';
-                const uuid = randomUUID().slice(0, 8);
-                const branchName = `replicas/${workspaceBranchSegment}-${uuid}`;
-                console.log(`[CodexManager] Generated branch name: ${branchName}`);
-                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('[CodexManager] Starting thread priming with system instructions');
-                const primingStartTime = Date.now();
-                // Use runStreamed to capture thread.started event with thread_id
-                const streamedTurn = await this.currentThread.runStreamed(systemMessage);
-                console.log('[CodexManager] Processing priming stream events...');
-                for await (const event of streamedTurn.events) {
-                    console.log(`[CodexManager] Event: ${event.type}`);
-                    if (event.type === 'thread.started') {
-                        this.currentThreadId = event.thread_id;
-                        console.log(`[CodexManager] ✓ Thread ID captured from thread.started event: ${this.currentThreadId}`);
-                    }
-                }
-                const primingDuration = Date.now() - primingStartTime;
-                console.log(`[CodexManager] Thread priming completed in ${primingDuration}ms`);
-                // Double-check thread ID is available
-                if (!this.currentThreadId && this.currentThread.id) {
-                    this.currentThreadId = this.currentThread.id;
-                    console.log(`[CodexManager] Thread ID fallback from thread.id property: ${this.currentThreadId}`);
-                }
-                if (!this.currentThreadId) {
-                    console.error('[CodexManager] ERROR: Thread ID still not available after priming run');
-                    console.error(`[CodexManager] thread.id = ${this.currentThread.id}`);
-                }
-            }
-        }
-        else {
-            console.log(`[CodexManager] Using existing thread object for thread ID: ${this.currentThreadId}`);
-        }
-        console.log(`[CodexManager] Running user message on thread ${this.currentThreadId}`);
-        const messageStartTime = Date.now();
-        await this.currentThread.run(message);
-        const messageDuration = Date.now() - messageStartTime;
-        console.log(`[CodexManager] User message run completed in ${messageDuration}ms`);
-    }
-    async getHistory() {
-        console.log('[CodexManager] getHistory called');
-        if (!this.currentThreadId) {
-            console.log('[CodexManager] No active thread ID, returning empty history');
-            return {
-                thread_id: null,
-                events: [],
-            };
-        }
-        console.log(`[CodexManager] Looking for session file for thread: ${this.currentThreadId}`);
-        const sessionFile = await findSessionFile(this.currentThreadId);
-        if (!sessionFile) {
-            console.warn(`[CodexManager] WARNING: Session file not found for thread ${this.currentThreadId}`);
-            return {
-                thread_id: this.currentThreadId,
-                events: [],
-            };
-        }
-        console.log(`[CodexManager] Reading session file: ${sessionFile}`);
-        const events = await readJSONL(sessionFile);
-        console.log(`[CodexManager] Read ${events.length} events from session file`);
-        // Filter out priming instruction events
-        let filteredEvents = events.filter((event) => {
-            const eventStr = JSON.stringify(event);
-            return !eventStr.includes('<replicas_important_instructions>');
-        });
-        // Find the first real user message (after priming)
-        const firstUserMessageIndex = filteredEvents.findIndex((event) => {
-            return event.type === 'response_item' &&
-                event.payload?.type === 'message' &&
-                event.payload?.role === 'user';
-        });
-        // If we found a user message, remove all events before it (priming response)
-        if (firstUserMessageIndex > 0) {
-            const beforeCount = filteredEvents.length;
-            filteredEvents = filteredEvents.slice(firstUserMessageIndex);
-            console.log(`[CodexManager] Filtered out ${beforeCount - filteredEvents.length} events before first user message`);
-        }
-        const totalFilteredCount = events.length - filteredEvents.length;
-        if (totalFilteredCount > 0) {
-            console.log(`[CodexManager] Total filtered: ${totalFilteredCount} events (priming + response)`);
-        }
-        console.log(`[CodexManager] Returning ${filteredEvents.length} events`);
-        return {
-            thread_id: this.currentThreadId,
-            events: filteredEvents,
-        };
-    }
-    async getStatus() {
-        console.log('[CodexManager] getStatus called');
-        let sessionFile = null;
-        if (this.currentThreadId) {
-            console.log(`[CodexManager] Checking for session file for thread: ${this.currentThreadId}`);
-            sessionFile = await findSessionFile(this.currentThreadId);
-            if (sessionFile) {
-                console.log(`[CodexManager] Session file found: ${sessionFile}`);
-            }
-            else {
-                console.log('[CodexManager] Session file not found');
-            }
-        }
-        else {
-            console.log('[CodexManager] No active thread ID');
-        }
-        const status = {
-            has_active_thread: this.currentThreadId !== null,
-            thread_id: this.currentThreadId,
-            session_file: sessionFile,
-            working_directory: this.workingDirectory,
-        };
-        console.log(`[CodexManager] Status: ${JSON.stringify(status)}`);
-        return status;
-    }
-    reset() {
-        console.log(`[CodexManager] Resetting thread (was: ${this.currentThreadId})`);
-        this.currentThread = null;
-        this.currentThreadId = null;
-        console.log('[CodexManager] Thread reset complete');
-    }
-    getThreadId() {
-        return this.currentThreadId;
-    }
-    async getUpdates(since) {
-        console.log(`[CodexManager] getUpdates called with since: ${since}`);
-        if (!this.currentThreadId) {
-            console.log('[CodexManager] No active thread, returning empty updates');
-            return {
-                events: [],
-                isComplete: true,
-            };
-        }
-        const sessionFile = await findSessionFile(this.currentThreadId);
-        if (!sessionFile) {
-            console.log('[CodexManager] Session file not found, returning empty updates');
-            return {
-                events: [],
-                isComplete: true,
-            };
-        }
-        const allEvents = await readJSONL(sessionFile);
-        console.log(`[CodexManager] Read ${allEvents.length} total events`);
-        // Filter events that occurred after the 'since' timestamp
-        const filteredEvents = allEvents.filter((event) => {
-            return event.timestamp > since;
-        });
-        console.log(`[CodexManager] Found ${filteredEvents.length} events since ${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'));
-        console.log(`[CodexManager] Thread complete: ${isComplete}`);
-        return {
-            events: filteredEvents,
-            isComplete,
-        };
-    }
-}

package/dist/utils/jsonl-reader.js

@@ -1,135 +0,0 @@
-import { readFile, readdir, stat } from 'fs/promises';
-import { join } from 'path';
-import { homedir } from 'os';
-export async function readJSONL(filePath) {
-    console.log(`[jsonl-reader] readJSONL called for: ${filePath}`);
-    try {
-        const content = await readFile(filePath, 'utf-8');
-        console.log(`[jsonl-reader] File read successfully, content length: ${content.length} bytes`);
-        const lines = content.split('\n').filter((line) => line.trim());
-        console.log(`[jsonl-reader] Found ${lines.length} non-empty lines`);
-        const events = lines
-            .map((line, index) => {
-            try {
-                return JSON.parse(line);
-            }
-            catch (e) {
-                console.error(`[jsonl-reader] Failed to parse line ${index + 1}: ${line.substring(0, 100)}...`, e);
-                return null;
-            }
-        })
-            .filter((event) => event !== null);
-        console.log(`[jsonl-reader] Successfully parsed ${events.length} events`);
-        return events;
-    }
-    catch (error) {
-        console.error(`[jsonl-reader] ERROR: Failed to read JSONL file ${filePath}:`, error);
-        return [];
-    }
-}
-// Sessions are stored in ~/.codex/sessions/YYYY/MM/DD/rollout-*-{threadId}.jsonl
-export async function findSessionFile(threadId) {
-    console.log(`[jsonl-reader] findSessionFile called for threadId: ${threadId}`);
-    const sessionsDir = join(homedir(), '.codex', 'sessions');
-    console.log(`[jsonl-reader] Sessions directory: ${sessionsDir}`);
-    try {
-        // 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');
-        const todayDir = join(sessionsDir, String(year), month, day);
-        console.log(`[jsonl-reader] Searching today's directory: ${todayDir}`);
-        const file = await findFileInDirectory(todayDir, threadId);
-        if (file) {
-            console.log(`[jsonl-reader] Found file in today's directory: ${file}`);
-            return file;
-        }
-        console.log(`[jsonl-reader] Not found in today's directory, searching previous 7 days`);
-        for (let daysAgo = 1; daysAgo <= 7; daysAgo++) {
-            const date = new Date(now);
-            date.setDate(date.getDate() - daysAgo);
-            const searchYear = date.getFullYear();
-            const searchMonth = String(date.getMonth() + 1).padStart(2, '0');
-            const searchDay = String(date.getDate()).padStart(2, '0');
-            const searchDir = join(sessionsDir, String(searchYear), searchMonth, searchDay);
-            console.log(`[jsonl-reader] Searching ${daysAgo} day(s) ago: ${searchDir}`);
-            const file = await findFileInDirectory(searchDir, threadId);
-            if (file) {
-                console.log(`[jsonl-reader] Found file ${daysAgo} day(s) ago: ${file}`);
-                return file;
-            }
-        }
-        console.log(`[jsonl-reader] Session file not found after searching 8 days`);
-        return null;
-    }
-    catch (error) {
-        console.error('[jsonl-reader] ERROR finding session file:', error);
-        return null;
-    }
-}
-async function findFileInDirectory(directory, threadId) {
-    try {
-        console.log(`[jsonl-reader] Reading directory: ${directory}`);
-        const files = await readdir(directory);
-        console.log(`[jsonl-reader] Found ${files.length} files in directory`);
-        const jsonlFiles = files.filter(f => f.endsWith('.jsonl'));
-        console.log(`[jsonl-reader] ${jsonlFiles.length} JSONL files: ${jsonlFiles.join(', ')}`);
-        for (const file of files) {
-            if (file.endsWith('.jsonl') && file.includes(threadId)) {
-                const fullPath = join(directory, file);
-                console.log(`[jsonl-reader] Found matching file: ${file} -> ${fullPath}`);
-                const stats = await stat(fullPath);
-                if (stats.isFile()) {
-                    console.log(`[jsonl-reader] Confirmed as regular file, returning: ${fullPath}`);
-                    return fullPath;
-                }
-                else {
-                    console.log(`[jsonl-reader] WARNING: Path exists but is not a regular file`);
-                }
-            }
-        }
-        console.log(`[jsonl-reader] No matching file found in ${directory}`);
-        return null;
-    }
-    catch (error) {
-        console.log(`[jsonl-reader] Directory read failed for ${directory}:`, error instanceof Error ? error.message : error);
-        return null;
-    }
-}
-export async function getMostRecentSessionFile() {
-    const sessionsDir = join(homedir(), '.codex', 'sessions');
-    try {
-        const now = new Date();
-        for (let daysAgo = 0; daysAgo <= 7; daysAgo++) {
-            const date = new Date(now);
-            date.setDate(date.getDate() - daysAgo);
-            const year = date.getFullYear();
-            const month = String(date.getMonth() + 1).padStart(2, '0');
-            const day = String(date.getDate()).padStart(2, '0');
-            const searchDir = join(sessionsDir, String(year), month, day);
-            try {
-                const files = await readdir(searchDir);
-                const jsonlFiles = files
-                    .filter((f) => f.endsWith('.jsonl'))
-                    .map((f) => join(searchDir, f));
-                if (jsonlFiles.length > 0) {
-                    const stats = await Promise.all(jsonlFiles.map(async (f) => ({
-                        path: f,
-                        mtime: (await stat(f)).mtime,
-                    })));
-                    stats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-                    return stats[0].path;
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-        return null;
-    }
-    catch (error) {
-        console.error('Error finding most recent session file:', error);
-        return null;
-    }
-}