@swmansion/argent 0.14.1-next.5 → 0.14.1-next.6

package/dist/tool-server.cjs

@@ -15716,14 +15716,27 @@ var init_registry = __esm({
             effectiveParams = parsed.data;
           }
           const aliasToRef = definition.services(effectiveParams);
-          const resolvedServices = {};
-          for (const [alias, ref] of Object.entries(aliasToRef)) {
-            const urn = typeof ref === "string" ? ref : ref.urn;
-            const resolveOptions = typeof ref === "string" ? void 0 : ref.options;
-            resolvedServices[alias] = await this.resolveService(urn, resolveOptions);
-          }
+          const refs = Object.entries(aliasToRef).map(([alias, ref]) => ({
+            alias,
+            urn: typeof ref === "string" ? ref : ref.urn,
+            options: typeof ref === "string" ? void 0 : ref.options
+          }));
           const ctx = { ...options, artifacts: this.artifacts };
-          const result = await definition.execute(resolvedServices, effectiveParams, ctx);
+          const runOnce = async () => {
+            const resolvedServices = {};
+            for (const { alias, urn, options: resolveOptions } of refs) {
+              resolvedServices[alias] = await this.resolveService(urn, resolveOptions);
+            }
+            return definition.execute(resolvedServices, effectiveParams, ctx);
+          };
+          let result;
+          try {
+            result = await runOnce();
+          } catch (execError) {
+            const recovered = await this._recoverFailedServices(refs, execError);
+            if (!recovered) throw execError;
+            result = await runOnce();
+          }
           const duration3 = performance.now() - startTime;
           this.events.emit("toolCompleted", id, toolInvocationId, duration3);
           return result;
@@ -15763,6 +15776,30 @@ var init_registry = __esm({
           tools: [...this.tools.keys()]
         };
       }
+      /**
+       * After a tool failed, ask each service it resolved whether the error means
+       * that service's instance is dead (`blueprint.recoverable(error)`). Dispose
+       * every one that says yes so the next `resolveService` re-creates it, and
+       * report whether anything was disposed (i.e. whether a retry is worthwhile).
+       *
+       * Only currently-RUNNING nodes are considered: a service that already
+       * errored/torn down during resolution needs no recovery here, and a URN this
+       * tool never resolved must not be touched.
+       */
+      async _recoverFailedServices(refs, error52) {
+        let recoveredAny = false;
+        for (const { urn } of refs) {
+          const node = this.services.get(urn);
+          if (!node || node.state !== "RUNNING" /* RUNNING */) continue;
+          if (node.blueprint.recoverable?.(error52) !== true) continue;
+          try {
+            await this.disposeService(urn);
+            recoveredAny = true;
+          } catch {
+          }
+        }
+        return recoveredAny;
+      }
       /**
        * Tear down a single service by URN (and cascade to its dependents).
        * After disposal the service returns to IDLE and can be re-resolved.
@@ -109737,6 +109774,26 @@ var simulatorServerBlueprint = {
   getURN(device) {
     return `${SIMULATOR_SERVER_NAMESPACE}:${device.id}`;
   },
+  /**
+   * A cached simulator-server handle can outlive the thing it points at: when a
+   * simulator is un-booted (or the native server crashes) the child process may
+   * stay alive but stop listening on its API port, so every subsequent request
+   * fails with `ECONNREFUSED` against the now-dead port — the exact "worked once,
+   * then every call times out" symptom, unrecoverable until a human runs
+   * `stop-simulator-server`. The process never emitting `exit` means the
+   * registry's normal teardown (wired to `proc.on("exit")`) never fires.
+   *
+   * Treat a connection-refused failure as proof the instance is dead so the
+   * registry disposes it (killing the wedged process) and re-spawns a fresh
+   * simulator-server on the next call. Scoped to connection-refused only:
+   * ECONNREFUSED means the request never reached the server, so retrying can't
+   * double-apply a gesture. Timeouts and resets are deliberately excluded — the
+   * request there may have taken effect, and a hung-but-listening server is a
+   * different failure that respawning wouldn't fix.
+   */
+  recoverable(error52) {
+    return getFailureSignal(error52)?.network_failure === "connection_refused";
+  },
   async factory(_deps, _payload, options) {
     const opts = options;
     if (!opts?.device) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swmansion/argent",
-  "version": "0.14.1-next.5",
+  "version": "0.14.1-next.6",
   "description": "MCP server for iOS Simulator and Android Emulator control",
   "license": "Apache-2.0",
   "repository": {