replicas-engine 0.1.407 → 0.1.409

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-v2";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-07-08-v4";
 
 // ../shared/src/runtime-env.ts
 function parsePosixEnvFile(content) {
@@ -6802,6 +6802,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 +6954,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 +6999,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 +7434,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 +7464,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 +7476,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 +7491,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 +7521,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 +7859,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 +8087,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.407";
+var ENGINE_PACKAGE_VERSION = "0.1.409";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -10192,9 +10261,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;
@@ -10546,15 +10616,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) {

package/package.json

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