replicas-engine 0.1.408 → 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-v3";
+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";
@@ -6802,6 +6919,8 @@ var COMMAND_PROTECTION_SAFE_TOOLS = /* @__PURE__ */ new Set([
   "LS"
 ]);
 var CLAUDE_PARTIAL_MESSAGE_FLUSH_MS = 80;
+var CLAUDE_SLASH_COMMANDS_CACHE_MS = 6e4;
+var CLAUDE_SLASH_COMMANDS_DISCOVERY_TIMEOUT_MS = 3e4;
 function supportsClaudeThinkingDisplay(model) {
   const normalized = (normalizeClaudeModel(model) ?? model).toLowerCase();
   return AGENT_MODELS.claude.includes(normalized) || /^claude-(?:opus|sonnet|haiku)-[4-9]/.test(normalized);
@@ -6952,6 +7071,8 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   /** Active tool-input requests keyed by requestId; resolved when the user selects an option. */
   pendingToolInputs = /* @__PURE__ */ new Map();
   supportedSlashCommands = [];
+  slashCommandsDiscoveredAt = 0;
+  slashCommandsDiscovery = null;
   authRetrying = false;
   constructor(options) {
     super(options);
@@ -6995,16 +7116,70 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   }
   async listSlashCommands() {
     await this.initialized;
-    if (!this.activeQuery || this.isProcessing()) {
+    if (this.activeQuery) {
+      if (this.isProcessing()) {
+        return this.supportedSlashCommands;
+      }
+      try {
+        const commands = await this.activeQuery.supportedCommands();
+        if (commands) {
+          this.supportedSlashCommands = normalizeClaudeSlashCommands(commands);
+          this.slashCommandsDiscoveredAt = Date.now();
+        }
+      } catch (error) {
+        console.warn("[ClaudeManager] Failed to load slash commands:", error);
+      }
+      return this.supportedSlashCommands;
+    }
+    if (this.slashCommandsDiscoveredAt > 0 && Date.now() - this.slashCommandsDiscoveredAt < CLAUDE_SLASH_COMMANDS_CACHE_MS) {
       return this.supportedSlashCommands;
     }
+    this.slashCommandsDiscovery ??= this.discoverSlashCommands().finally(() => {
+      this.slashCommandsDiscovery = null;
+    });
+    return this.slashCommandsDiscovery;
+  }
+  /**
+   * Sessions are created lazily on the first message, but the dashboard needs
+   * the command list as soon as a chat opens — so with no session alive we
+   * spawn a throwaway query (no prompt is ever pushed, so no model call is
+   * made), read supportedCommands(), and terminate it.
+   */
+  async discoverSlashCommands() {
+    const promptStream = new PromptStream();
+    let discovery = null;
+    let timeoutHandle;
     try {
-      const commands = await this.activeQuery?.supportedCommands();
+      const shared = await this.buildSharedQueryOptions();
+      discovery = query({
+        prompt: promptStream,
+        options: {
+          cwd: this.workingDirectory,
+          additionalDirectories: shared.additionalDirectories,
+          settingSources: ["user", "project", "local"],
+          ...this.mcpServersConfig ? { mcpServers: this.mcpServersConfig } : {},
+          ...shared.plugins.length > 0 ? { plugins: shared.plugins } : {},
+          ...shared.enableAllSkills ? { skills: "all" } : {},
+          env: shared.env
+        }
+      });
+      const timeout = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(
+          () => reject(new Error("Slash command discovery timed out")),
+          CLAUDE_SLASH_COMMANDS_DISCOVERY_TIMEOUT_MS
+        );
+      });
+      const commands = await Promise.race([discovery.supportedCommands(), timeout]);
       if (commands) {
         this.supportedSlashCommands = normalizeClaudeSlashCommands(commands);
       }
     } catch (error) {
-      console.warn("[ClaudeManager] Failed to load slash commands:", error);
+      console.warn("[ClaudeManager] Failed to discover slash commands:", error);
+    } finally {
+      this.slashCommandsDiscoveredAt = Date.now();
+      clearTimeout(timeoutHandle);
+      promptStream.close();
+      discovery?.close();
     }
     return this.supportedSlashCommands;
   }
@@ -7376,6 +7551,21 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   sessionSignaturesMatch(a, b) {
     return a.combinedInstructions === b.combinedInstructions && a.thinkingLevel === b.thinkingLevel && a.enableInteractiveTools === b.enableInteractiveTools && a.fastMode === b.fastMode;
   }
+  /** Query inputs shared by real sessions and slash-command discovery. */
+  async buildSharedQueryOptions() {
+    const env = buildClaudeAgentEnv(this.envOverrides);
+    const additionalDirectories = await getAgentAdditionalDirectories();
+    let plugins = [];
+    let enableAllSkills = false;
+    try {
+      const registryConfig = await buildClaudeRegistryConfig(ENGINE_ENV.HOME_DIR);
+      plugins = registryConfig.plugins;
+      enableAllSkills = registryConfig.enableAllSkills;
+    } catch (error) {
+      console.warn("[ClaudeManager] Failed to load skill registry config:", error);
+    }
+    return { env, additionalDirectories, plugins, enableAllSkills };
+  }
   async startSession(args) {
     const {
       combinedInstructions,
@@ -7391,8 +7581,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       preset: "claude_code",
       append: combinedInstructions
     };
-    const queryEnv = buildClaudeAgentEnv(this.envOverrides);
-    const additionalDirectories = await getAgentAdditionalDirectories();
+    const shared = await this.buildSharedQueryOptions();
     const interactiveAllowed = enableInteractiveTools && resolvedPermissionMode === "plan";
     const useDefaultToolPolicy = !this.toolsOverride;
     const allowedTools = useDefaultToolPolicy ? [
@@ -7404,22 +7593,13 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       ...useDefaultToolPolicy ? ALWAYS_DISALLOWED_TOOLS : [],
       ...interactiveAllowed ? [] : INTERACTIVE_TOOL_NAMES
     ];
-    let registryPlugins = [];
-    let enableRegistrySkills = false;
-    try {
-      const registryConfig = await buildClaudeRegistryConfig(ENGINE_ENV.HOME_DIR);
-      registryPlugins = registryConfig.plugins;
-      enableRegistrySkills = registryConfig.enableAllSkills;
-    } catch (error) {
-      console.warn("[ClaudeManager] Failed to load skill registry config:", error);
-    }
     const promptStream = new PromptStream();
     const response = query({
       prompt: promptStream,
       options: {
         resume: this.sessionId || void 0,
         cwd: this.workingDirectory,
-        additionalDirectories,
+        additionalDirectories: shared.additionalDirectories,
         permissionMode: resolvedPermissionMode,
         allowDangerouslySkipPermissions: resolvedPermissionMode === "bypassPermissions",
         ...this.toolsOverride ? { tools: this.toolsOverride } : {},
@@ -7428,9 +7608,9 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
         settingSources: ["user", "project", "local"],
         systemPrompt,
         ...this.mcpServersConfig ? { mcpServers: this.mcpServersConfig } : {},
-        ...registryPlugins.length > 0 ? { plugins: registryPlugins } : {},
-        ...enableRegistrySkills ? { skills: "all" } : {},
-        env: queryEnv,
+        ...shared.plugins.length > 0 ? { plugins: shared.plugins } : {},
+        ...shared.enableAllSkills ? { skills: "all" } : {},
+        env: shared.env,
         model: claudeCodeModel,
         settings: { fastMode: signature.fastMode },
         includePartialMessages: true,
@@ -7458,6 +7638,11 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     this.sessionLoop = this.runSessionLoop(response).catch((err) => {
       console.error("[ClaudeManager] Session loop crashed:", err);
     });
+    void response.supportedCommands().then((commands) => {
+      this.supportedSlashCommands = normalizeClaudeSlashCommands(commands);
+      this.slashCommandsDiscoveredAt = Date.now();
+    }).catch(() => {
+    });
   }
   async runSessionLoop(response) {
     const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
@@ -7791,6 +7976,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     }
     if (message.type === "system" && message.subtype === "commands_changed") {
       this.supportedSlashCommands = normalizeClaudeSlashCommands(message.commands);
+      this.slashCommandsDiscoveredAt = Date.now();
     }
     this.trackNativeCompaction(message);
     await this.recordEvent(message);
@@ -8018,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.408";
+var ENGINE_PACKAGE_VERSION = "0.1.410";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -10192,9 +10378,10 @@ var CursorManager = class extends CodingAgentManager {
     }
     this.slashCommandsRequest ??= (async () => {
       try {
+        const repoDirectories = await getAgentAdditionalDirectories();
+        const commandDirectories = [this.workingDirectory, ...repoDirectories, ENGINE_ENV.HOME_DIR].map((directory) => join17(directory, ".cursor", "commands"));
         const commands = mergeSlashCommands(
-          await listCursorCommandsInDirectory(join17(this.workingDirectory, ".cursor", "commands")),
-          await listCursorCommandsInDirectory(join17(ENGINE_ENV.HOME_DIR, ".cursor", "commands"))
+          ...await Promise.all(commandDirectories.map(listCursorCommandsInDirectory))
         );
         this.slashCommandsCache = { commands, expiresAt: Date.now() + CURSOR_SLASH_COMMANDS_CACHE_MS };
         return commands;
@@ -10224,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);
@@ -10240,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") {
@@ -10248,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", {
@@ -10502,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;
@@ -10546,15 +10742,24 @@ var OpencodeManager = class extends CodingAgentManager {
     this.slashCommandsRequest ??= (async () => {
       try {
         const client = await this.ensureClient(DEFAULT_OPENCODE_MODEL);
-        const location = { directory: this.workingDirectory };
-        const [commandResponse, skillResponse] = await Promise.all([
-          client.v2.command.list({ location }, { throwOnError: true }),
-          client.v2.skill.list({ location }, { throwOnError: true })
-        ]);
-        const commands = mergeSlashCommands(
-          opencodeCommandListToSlashCommands(commandResponse.data),
-          opencodeSkillListToSlashCommands(skillResponse.data)
-        );
+        const directories = [this.workingDirectory, ...await getAgentAdditionalDirectories()];
+        const perDirectory = await Promise.all(directories.map(async (directory) => {
+          try {
+            const location = { directory };
+            const [commandResponse, skillResponse] = await Promise.all([
+              client.v2.command.list({ location }, { throwOnError: true }),
+              client.v2.skill.list({ location }, { throwOnError: true })
+            ]);
+            return mergeSlashCommands(
+              opencodeCommandListToSlashCommands(commandResponse.data),
+              opencodeSkillListToSlashCommands(skillResponse.data)
+            );
+          } catch (error) {
+            console.warn("[OpencodeManager] Failed to load slash commands for directory:", directory, error);
+            return [];
+          }
+        }));
+        const commands = mergeSlashCommands(...perDirectory);
         this.slashCommandsCache = { commands, expiresAt: Date.now() + OPENCODE_SLASH_COMMANDS_CACHE_MS };
         return commands;
       } catch (error) {
@@ -10659,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";
@@ -10681,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) {
@@ -10691,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();
     }
@@ -10814,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.408",
+  "version": "0.1.410",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",