replicas-engine 0.1.409 → 0.1.410

package/dist/src/index.js

@@ -479,7 +479,7 @@ var WORKSPACE_SIZES = ["small", "large"];
 var INVALID_WORKSPACE_SIZE_ERROR = `Invalid size: must be one of ${WORKSPACE_SIZES.join(", ")}`;
 
 // ../shared/src/e2b.ts
-var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-07-08-v4";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-07-08-v5";
 
 // ../shared/src/runtime-env.ts
 function parsePosixEnvFile(content) {
@@ -5533,27 +5533,81 @@ function linearThoughtToResponse(thought) {
 function summarizeInput(input) {
   if (!input) return "";
   if (typeof input === "string") return input;
-  if (typeof input === "object") {
-    const obj = input;
-    if (obj.file_path) return String(obj.file_path);
-    if (obj.command) return String(obj.command);
-    if (obj.pattern) return `pattern: ${String(obj.pattern)}`;
-    if (obj.query) return String(obj.query);
-    if (obj.url) return String(obj.url);
-    if (typeof obj.activeForm === "string" && obj.activeForm) return String(obj.activeForm);
-    if (typeof obj.subject === "string" && obj.subject) return String(obj.subject);
-    const keys = Object.keys(obj);
-    if (keys.length > 0) {
-      const firstKey = keys[0];
-      return `${firstKey}: ${String(obj[firstKey])}`;
+  if (isRecord(input)) {
+    if (input.file_path) return String(input.file_path);
+    if (input.command) return String(input.command);
+    if (input.pattern) return `pattern: ${String(input.pattern)}`;
+    if (input.query) return String(input.query);
+    if (input.url) return String(input.url);
+    if (typeof input.activeForm === "string" && input.activeForm) return String(input.activeForm);
+    if (typeof input.subject === "string" && input.subject) return String(input.subject);
+    for (const [key, value] of Object.entries(input)) {
+      return `${key}: ${String(value)}`;
     }
   }
   return "";
 }
+function summarizeResult(result) {
+  if (!result) return "";
+  if (typeof result === "string") return result;
+  if (isRecord(result)) {
+    if (typeof result.message === "string") return result.message;
+    if (typeof result.error === "string") return result.error;
+    if (typeof result.stdout === "string") return result.stdout;
+    if (typeof result.stderr === "string") return result.stderr;
+    if (typeof result.path === "string") return result.path;
+  }
+  try {
+    return JSON.stringify(result);
+  } catch {
+    return String(result);
+  }
+}
+function toolAction(toolName) {
+  switch (toolName) {
+    case "Bash":
+    case "bash":
+    case "shell":
+      return "Running command";
+    case "Edit":
+    case "edit":
+      return "Editing file";
+    case "Write":
+    case "write":
+      return "Writing file";
+    case "Read":
+    case "read":
+      return "Reading file";
+    case "Glob":
+    case "glob":
+      return "Searching files";
+    case "Grep":
+    case "grep":
+    case "semsearch":
+      return "Searching code";
+    case "WebSearch":
+      return "Web search";
+    case "WebFetch":
+      return "Fetching URL";
+    case "delete":
+      return "Deleting file";
+    case "Task":
+    case "task":
+      return "Spawning subagent";
+    case "TaskCreate":
+    case "TaskUpdate":
+    case "TaskList":
+    case "TaskGet":
+    case "update_todos":
+    case "create_plan":
+      return "Updating plan";
+    default:
+      return toolName;
+  }
+}
 function convertClaudeEvent(event, linearSessionId) {
   if (event.type === "assistant") {
-    const message = event;
-    const contentBlocks = normalizeContentBlocks(message.message?.content);
+    const contentBlocks = normalizeContentBlocks(event.message.content);
     for (const block of contentBlocks) {
       if (block.type === "text" && block.text) {
         return {
@@ -5576,47 +5630,11 @@ function convertClaudeEvent(event, linearSessionId) {
       if (block.type === "tool_use" && block.name) {
         const toolName = block.name;
         const parameter = summarizeInput(block.input);
-        let action = toolName;
-        switch (toolName) {
-          case "Bash":
-            action = "Running command";
-            break;
-          case "Edit":
-            action = "Editing file";
-            break;
-          case "Write":
-            action = "Writing file";
-            break;
-          case "Read":
-            action = "Reading file";
-            break;
-          case "Glob":
-            action = "Searching files";
-            break;
-          case "Grep":
-            action = "Searching code";
-            break;
-          case "WebSearch":
-            action = "Web search";
-            break;
-          case "WebFetch":
-            action = "Fetching URL";
-            break;
-          case "Task":
-            action = "Spawning subagent";
-            break;
-          case "TaskCreate":
-          case "TaskUpdate":
-          case "TaskList":
-          case "TaskGet":
-            action = "Updating plan";
-            break;
-        }
         return {
           linearSessionId,
           content: {
             type: "action",
-            action,
+            action: toolAction(toolName),
             parameter
           }
         };
@@ -5624,8 +5642,7 @@ function convertClaudeEvent(event, linearSessionId) {
     }
   }
   if (event.type === "user") {
-    const message = event;
-    const contentBlocks = normalizeContentBlocks(message.message?.content);
+    const contentBlocks = normalizeContentBlocks(event.message.content);
     for (const block of contentBlocks) {
       if (block.type === "tool_result") {
         const resultText = extractToolResultText(block.content);
@@ -5645,6 +5662,106 @@ function convertClaudeEvent(event, linearSessionId) {
   }
   return null;
 }
+function convertCursorEvent(event, linearSessionId) {
+  if (event.type === "assistant") {
+    for (const block of event.message.content) {
+      if (block.type === "text" && block.text) {
+        return {
+          linearSessionId,
+          content: {
+            type: "thought",
+            body: block.text
+          }
+        };
+      }
+      if (block.type === "tool_use" && block.name) {
+        return {
+          linearSessionId,
+          content: {
+            type: "action",
+            action: toolAction(block.name),
+            parameter: summarizeInput(block.input)
+          }
+        };
+      }
+    }
+  }
+  if (event.type === "thinking" && event.text) {
+    return {
+      linearSessionId,
+      content: {
+        type: "thought",
+        body: event.text
+      }
+    };
+  }
+  if (event.type === "tool_call") {
+    const result = event.status === "running" ? void 0 : event.status === "error" ? `Error: ${summarizeResult(event.result) || "Tool failed"}` : summarizeResult(event.result) || "Done";
+    return {
+      linearSessionId,
+      content: {
+        type: "action",
+        action: toolAction(event.name),
+        parameter: summarizeInput(event.args),
+        ...result ? { result } : {}
+      }
+    };
+  }
+  if (event.type === "task" && event.text) {
+    return {
+      linearSessionId,
+      content: {
+        type: "thought",
+        body: event.text
+      }
+    };
+  }
+  return null;
+}
+function isOpencodePartEnded(part) {
+  return "time" in part && isRecord(part.time) && part.time.end !== void 0;
+}
+function convertOpencodePart(part, linearSessionId) {
+  if ((part.type === "text" || part.type === "reasoning") && isOpencodePartEnded(part)) {
+    const body = typeof part.text === "string" ? part.text.trim() : "";
+    if (!body) return null;
+    return {
+      linearSessionId,
+      content: {
+        type: "thought",
+        body
+      }
+    };
+  }
+  if (part.type === "tool" && isRecord(part.state)) {
+    const state = part.state;
+    const status = typeof state.status === "string" ? state.status : void 0;
+    const result = status === "completed" ? summarizeResult(state.output) || "Done" : status === "error" ? `Error: ${summarizeResult(state.error) || "Tool failed"}` : void 0;
+    return {
+      linearSessionId,
+      content: {
+        type: "action",
+        action: toolAction(typeof part.tool === "string" ? part.tool : "Tool"),
+        parameter: summarizeInput(state.input),
+        ...result ? { result } : {}
+      }
+    };
+  }
+  if (part.type === "patch") {
+    const files = "files" in part && Array.isArray(part.files) ? part.files.filter((file) => typeof file === "string") : [];
+    if (files.length === 0) return null;
+    return {
+      linearSessionId,
+      content: {
+        type: "action",
+        action: "File change",
+        parameter: files.join(", "),
+        result: "Done"
+      }
+    };
+  }
+  return null;
+}
 function mapTodoStatus(status) {
   if (status === "in_progress") {
     return "inProgress";
@@ -8087,7 +8204,7 @@ var AspClient = class {
 // src/managers/codex-asp/app-server-process.ts
 var DEFAULT_CODEX_BINARY = "codex";
 var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
-var ENGINE_PACKAGE_VERSION = "0.1.409";
+var ENGINE_PACKAGE_VERSION = "0.1.410";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -10294,6 +10411,8 @@ var CursorManager = class extends CodingAgentManager {
     return this.agent;
   }
   async processMessageInternal(request) {
+    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
+    const linearForwarder = new LinearEventForwarder(linearSessionId);
     try {
       const agent = await this.ensureAgent(request);
       const message = await this.toCursorMessage(request);
@@ -10310,6 +10429,9 @@ var CursorManager = class extends CodingAgentManager {
       this.activeModel = model;
       for await (const event of run.stream()) {
         this.recordCursorEvent(event);
+        if (linearSessionId) {
+          linearForwarder.sendEvent(convertCursorEvent(event, linearSessionId));
+        }
       }
       const result = await run.wait();
       if (result.status === "error") {
@@ -10318,6 +10440,8 @@ var CursorManager = class extends CodingAgentManager {
           message: result.result || "Cursor run failed",
           runId: result.id
         }, this.historyFile);
+      } else {
+        linearForwarder.flushThoughtAsResponse();
       }
     } catch (error) {
       this.recordHistoryEvent("cursor-error", {
@@ -10572,6 +10696,8 @@ var OpencodeManager = class extends CodingAgentManager {
   textParts = /* @__PURE__ */ new Map();
   reasoningParts = /* @__PURE__ */ new Map();
   nonAssistantMessageIds = /* @__PURE__ */ new Set();
+  activeLinearForwarder = null;
+  forwardedLinearPartKeys = /* @__PURE__ */ new Set();
   modelVariants = /* @__PURE__ */ new Map();
   slashCommandsCache = null;
   slashCommandsRequest = null;
@@ -10738,7 +10864,11 @@ var OpencodeManager = class extends CodingAgentManager {
   async processMessageInternal(request) {
     const model = request.model ?? DEFAULT_OPENCODE_MODEL;
     const controller = new AbortController();
+    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
+    const linearForwarder = new LinearEventForwarder(linearSessionId);
     this.activeAbortController = controller;
+    this.activeLinearForwarder = linearForwarder;
+    this.forwardedLinearPartKeys.clear();
     try {
       const client = await this.ensureClient(model);
       const agent = request.planMode ? "plan" : "build";
@@ -10760,6 +10890,7 @@ var OpencodeManager = class extends CodingAgentManager {
       }, { signal: controller.signal, throwOnError: true });
       this.recordHistoryEvent("opencode-message.updated", { info: result.data.info }, this.historyFile);
       for (const part of result.data.parts) this.recordOpencodePart(part);
+      linearForwarder.flushThoughtAsResponse();
       this.recordHistoryEvent("opencode-session.idle", { sessionID: sessionId }, this.historyFile);
     } catch (error) {
       if (controller.signal.aborted) {
@@ -10770,6 +10901,8 @@ var OpencodeManager = class extends CodingAgentManager {
       }
     } finally {
       this.activeAbortController = null;
+      this.activeLinearForwarder = null;
+      this.forwardedLinearPartKeys.clear();
       await this.historyFile.flush();
       await this.onTurnComplete();
     }
@@ -10893,8 +11026,20 @@ var OpencodeManager = class extends CodingAgentManager {
     }
     return false;
   }
+  forwardOpencodePartToLinear(part) {
+    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
+    if (!linearSessionId || !this.activeLinearForwarder) return;
+    const event = convertOpencodePart(part, linearSessionId);
+    if (!event) return;
+    if (typeof part.id !== "string") return;
+    const key = `${part.type}:${part.id}:${JSON.stringify(event.content)}`;
+    if (this.forwardedLinearPartKeys.has(key)) return;
+    this.forwardedLinearPartKeys.add(key);
+    this.activeLinearForwarder.sendEvent(event);
+  }
   recordOpencodePart(part) {
     this.recordHistoryEvent(`opencode-part-${part.type}`, { part }, this.historyFile);
+    this.forwardOpencodePartToLinear(part);
   }
 };
 

package/package.json

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