rterm-backend 3.2.1 → 3.2.4

package/bin/gybackend.cjs

@@ -295047,7 +295047,7 @@ var normalizeTerminalResizeTarget = (cols, rows) => {
     rows: Math.max(1, Math.floor(rows))
   };
 };
-var TerminalService = class {
+var TerminalService = class _TerminalService {
   backends = /* @__PURE__ */ new Map();
   terminals = /* @__PURE__ */ new Map();
   terminalConfigs = /* @__PURE__ */ new Map();
@@ -295058,6 +295058,8 @@ var TerminalService = class {
   /** Buffered writes for terminals that aren't writable yet (prevents keystroke loss during reconnection). */
   pendingWrites = /* @__PURE__ */ new Map();
   pendingWriteTimers = /* @__PURE__ */ new Map();
+  pendingWriteRetries = /* @__PURE__ */ new Map();
+  static MAX_WRITE_RETRIES = 3;
   selectionByTerminal = /* @__PURE__ */ new Map();
   tasksByTerminal = /* @__PURE__ */ new Map();
   activeTaskByTerminal = /* @__PURE__ */ new Map();
@@ -295619,21 +295621,28 @@ var TerminalService = class {
   handleData(terminalId, data) {
     const sanitizedData = stripInternalControlMarkers(data);
     const tab = this.terminals.get(terminalId);
-    const recordingId = this.activeRecordings.get(terminalId);
-    if (recordingId && this.sessionRecorder && sanitizedData) {
-      try {
-        this.sessionRecorder.out(recordingId, sanitizedData);
-      } catch {
-      }
-    }
-    if (this.sessionLogger && tab) {
-      if (!this.sessionLogStarted.has(terminalId)) {
-        this.sessionLogStarted.add(terminalId);
-        const cfg = this.terminalConfigs.get(terminalId);
-        this.sessionLogger.start(terminalId, { title: tab.title || terminalId, type: tab.type });
-        void cfg;
+    if (sanitizedData) {
+      const recordingId = this.activeRecordings.get(terminalId);
+      if (recordingId || this.sessionLogger && tab) {
+        const captureData = sanitizedData;
+        const captureTab = tab;
+        const captureId = recordingId;
+        setImmediate(() => {
+          if (captureId && this.sessionRecorder) {
+            try {
+              this.sessionRecorder.out(captureId, captureData);
+            } catch {
+            }
+          }
+          if (this.sessionLogger && captureTab) {
+            if (!this.sessionLogStarted.has(terminalId)) {
+              this.sessionLogStarted.add(terminalId);
+              this.sessionLogger.start(terminalId, { title: captureTab.title || terminalId, type: captureTab.type });
+            }
+            this.sessionLogger.write(terminalId, captureData);
+          }
+        });
       }
-      this.sessionLogger.write(terminalId, sanitizedData);
     }
     if (tab) {
       let shouldPublishTabsChanged = false;
@@ -295952,7 +295961,24 @@ ${promptPrefix}`;
     if (terminal && this.canWriteToTerminal(terminal)) {
       const backend = this.getBackend(terminal.type);
       backend.write(terminal.ptyId, data);
+      this.pendingWriteRetries.delete(terminalId);
     } else if (terminal) {
+      if (terminal.runtimeState === "exited") {
+        this.pendingWrites.delete(terminalId);
+        this.pendingWriteRetries.delete(terminalId);
+        const timer = this.pendingWriteTimers.get(terminalId);
+        if (timer) {
+          clearTimeout(timer);
+          this.pendingWriteTimers.delete(terminalId);
+        }
+        return;
+      }
+      const retries = this.pendingWriteRetries.get(terminalId) ?? 0;
+      if (retries >= _TerminalService.MAX_WRITE_RETRIES) {
+        this.pendingWrites.delete(terminalId);
+        this.pendingWriteRetries.delete(terminalId);
+        return;
+      }
       const pending = this.pendingWrites.get(terminalId) ?? "";
       this.pendingWrites.set(terminalId, pending + data);
       if (!this.pendingWriteTimers.has(terminalId)) {
@@ -295962,8 +295988,11 @@ ${promptPrefix}`;
           const buffered = this.pendingWrites.get(terminalId);
           if (term && buffered && this.canWriteToTerminal(term)) {
             this.pendingWrites.delete(terminalId);
+            this.pendingWriteRetries.delete(terminalId);
             const b = this.getBackend(term.type);
             b.write(term.ptyId, buffered);
+          } else {
+            this.pendingWriteRetries.set(terminalId, retries + 1);
           }
         }, 500);
         this.pendingWriteTimers.set(terminalId, timer);
@@ -296023,6 +296052,7 @@ ${promptPrefix}`;
   kill(terminalId) {
     this.pendingResizeByTerminal.delete(terminalId);
     this.pendingWrites.delete(terminalId);
+    this.pendingWriteRetries.delete(terminalId);
     const writeTimer = this.pendingWriteTimers.get(terminalId);
     if (writeTimer) {
       clearTimeout(writeTimer);
@@ -367362,6 +367392,85 @@ var SINGLE_CALL_TOOL_BOUNDARY_NAMES = /* @__PURE__ */ new Set([
   "manage_template",
   "import_putty"
 ]);
+var PARALLEL_SAFE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "read_file",
+  "read_terminal_tab",
+  "read_command_output",
+  "list_session_logs",
+  "read_session_log",
+  "search_session_logs",
+  "get_metrics",
+  "get_live_dashboard",
+  "get_monitor_status",
+  "get_cloud_inventory",
+  "get_apm_summary",
+  "get_dem_summary",
+  "get_cost",
+  "get_run_ledger",
+  "list_gateway_methods",
+  "manage_secret",
+  // read operations (list/has) are safe; set/delete are rare
+  "manage_oncall",
+  // open_pages is read-only
+  "manage_gitops",
+  // export/drift/inSync are read-only
+  "manage_playbook_version",
+  // lint/history/diff are read-only
+  "collect_facts",
+  "run_fleet_command",
+  // runs on different terminals — parallel-safe
+  "synapse_health",
+  "synapse_discover",
+  "synapse_agents_summary",
+  "synapse_reputation",
+  "synapse_serve_status",
+  "numbat_health",
+  "numbat_findings_summary",
+  "agentspan_health",
+  "agentspan_list",
+  "agentspan_status",
+  "webintel_health",
+  "web_search",
+  "web_fetch",
+  "web_find_similar",
+  "web_watch_list",
+  "patch_status",
+  "list_requests",
+  "request_status",
+  "sop_search",
+  "sop_get",
+  "iam_user_info",
+  "iam_user_groups",
+  "iam_access_review",
+  "fraudops_pipeline_status",
+  "fraudops_str_status",
+  "fraudops_decision_summary",
+  "netdata_alert_summary",
+  "netdata_correlate"
+]);
+function canRunInParallel(toolCalls) {
+  if (toolCalls.length <= 1) return false;
+  for (const tc of toolCalls) {
+    if (SINGLE_CALL_TOOL_BOUNDARY_NAMES.has(tc?.name)) return false;
+    if (!PARALLEL_SAFE_TOOL_NAMES.has(tc?.name)) return false;
+  }
+  const terminalIds = /* @__PURE__ */ new Set();
+  for (const tc of toolCalls) {
+    const args = typeof tc?.args === "string" ? (() => {
+      try {
+        return JSON.parse(tc.args);
+      } catch {
+        return {};
+      }
+    })() : tc?.args || {};
+    const tid = args.terminalId || args.target;
+    if (tid) {
+      if (terminalIds.has(tid)) return false;
+      terminalIds.add(tid);
+    }
+  }
+  return true;
+}
 function clipTextMiddle(input, maxChars) {
   if (maxChars <= 0) return "";
   if (input.length <= maxChars) return input;
@@ -368363,6 +368472,31 @@ var AgentService_v2 = class {
       if (!sessionId) throw new Error("No session ID in state");
       const sessionBinding = this.getSessionModelBinding(sessionId);
       const queue2 = Array.isArray(state.pendingToolCalls) ? state.pendingToolCalls : [];
+      if (canRunInParallel(queue2)) {
+        const parallelResults = await Promise.all(
+          queue2.map(async (tc) => {
+            const tm = this.createToolMessage(tc);
+            const ec = this.createExecutionContext(
+              sessionId,
+              tm.additional_kwargs._gyshellMessageId,
+              config2
+            );
+            let res = "";
+            try {
+              res = await this.executeToolByName(tc, ec);
+            } catch (err) {
+              res = `Parallel execution error for ${tc.name}: ${err.message}`;
+            }
+            tm.content = res;
+            return tm;
+          })
+        );
+        return {
+          messages: [...state.messages, ...parallelResults],
+          sessionId,
+          pendingToolCalls: []
+        };
+      }
       const toolCall = queue2[0];
       if (!toolCall) return state;
       const toolMessage = this.createToolMessage(toolCall);
@@ -369215,6 +369349,71 @@ Actually, your intention might be different. Please re-read the description of t
       };
     });
   }
+  /** v3.2.4: Execute a single tool by name (used by the parallel execution path).
+   * This is a simplified dispatch that handles the common read-only/parallel-safe tools.
+   * Tools not handled here fall back to the sequential switch/case path. */
+  async executeToolByName(toolCall, executionContext) {
+    const name = toolCall.name;
+    const args = typeof toolCall.args === "string" ? (() => {
+      try {
+        return JSON.parse(toolCall.args);
+      } catch {
+        return {};
+      }
+    })() : toolCall.args || {};
+    const ti = toolImplementations;
+    switch (name) {
+      case "read_terminal_tab":
+        return ti.readTerminalTab(args, executionContext);
+      case "read_command_output":
+        return ti.readCommandOutput(args, executionContext);
+      case "list_session_logs":
+        return ti.listSessionLogs(args, executionContext);
+      case "read_session_log":
+        return ti.readSessionLog(args, executionContext);
+      case "search_session_logs":
+        return ti.searchSessionLogs(args, executionContext);
+      case "get_metrics":
+        return ti.getMetrics(args, executionContext);
+      case "get_live_dashboard":
+        return ti.getLiveDashboard(args, executionContext);
+      case "get_monitor_status":
+        return ti.getMonitorStatus(args, executionContext);
+      case "get_cloud_inventory":
+        return ti.getCloudInventory(args, executionContext);
+      case "get_apm_summary":
+        return ti.getApmSummary(args, executionContext);
+      case "get_dem_summary":
+        return ti.getDemSummary(args, executionContext);
+      case "get_cost":
+        return ti.getCost(args, executionContext);
+      case "get_run_ledger":
+        return ti.getRunLedger(args, executionContext);
+      case "list_gateway_methods":
+        return ti.listGatewayMethods(args, executionContext);
+      case "collect_facts":
+        return ti.collectFacts(args, executionContext);
+      case "run_fleet_command":
+        return ti.runFleetCommand(args, executionContext);
+      case "manage_secret":
+        return ti.manageSecret(args, executionContext);
+      case "manage_oncall":
+        return ti.manageOncall(args, executionContext);
+      case "manage_gitops":
+        return ti.manageGitops(args, executionContext);
+      case "manage_playbook_version":
+        return ti.managePlaybookVersion(args, executionContext);
+      // Plugin tools — delegate to the pluginTools map
+      default: {
+        const pluginHandler = this.pluginTools.get(name);
+        if (pluginHandler) {
+          const result = await pluginHandler(args);
+          return typeof result === "string" ? result : JSON.stringify(result);
+        }
+        return `Tool "${name}" is not supported in parallel execution mode.`;
+      }
+    }
+  }
   createReadFileNode() {
     return RunnableLambda.from(async (state, config2) => {
       const sessionId = state.sessionId;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rterm-backend",
-  "version": "3.2.1",
-  "description": "Headless AI-native backend for RTerm / neuralOS — v3.2.1: terminal freeze fix (pending-write buffer), chat re-trigger fix (isThinking guard), stop button freeze fix (async await). 11 plugins, 55 plugin tools wired. Transports (SSH/serial/local), SQLite, and NATS libs install automatically.",
+  "version": "3.2.4",
+  "description": "Headless AI-native backend for RTerm / neuralOS — v3.2.4: parallel tool execution for compatible tools + per-model requestParams. 11 plugins, 55 plugin tools wired. Transports (SSH/serial/local), SQLite, and NATS libs install automatically.",
   "main": "bin/gybackend.cjs",
   "bin": { "gybackend": "bin/gybackend.cjs" },
   "license": "MIT",