@github/copilot-sdk 1.0.13 → 1.0.14-preview.0

package/dist/ffiRuntimeHost.js

@@ -4,6 +4,7 @@ import { resolve } from "node:path";
 import { PassThrough, Writable } from "node:stream";
 const SYMBOL_PREFIX = "copilot_runtime_";
 const KEEP_ALIVE_INTERVAL_MS = 1 << 30;
+const CLEANUP_RETRY_INTERVAL_MS = 100;
 let loadedLibraryPath;
 let loadedLibrary;
 function loadLibrary(libraryPath) {
@@ -96,12 +97,16 @@ class FfiRuntimeHost {
   cliEntrypoint;
   environment;
   args;
+  static quarantinedHosts = /* @__PURE__ */ new Set();
   lib;
   serverId = 0;
   connectionId = 0;
   disposed = false;
+  starting = false;
   outboundCallback;
   keepAliveTimer;
+  cleanupRetryTimer;
+  cleanupInProgress = false;
   /** The stream JSON-RPC reads server→client frames from. */
   receiveStream;
   /** The stream JSON-RPC writes client→server frames to. */
@@ -123,49 +128,65 @@ class FfiRuntimeHost {
   }
   /** Starts the in-process Rust runtime and opens the FFI JSON-RPC connection. */
   async start() {
+    if (this.disposed) {
+      throw new Error("The in-process runtime host is disposed.");
+    }
+    this.starting = true;
     const argvJson = buildArgvJson(this.cliEntrypoint, this.args);
     const envJson = buildEnvJson(this.environment);
-    this.serverId = await new Promise((resolvePromise, rejectPromise) => {
-      this.lib.hostStart.async(
-        argvJson,
-        argvJson.length,
-        envJson,
-        envJson ? envJson.length : 0,
-        (error, result) => {
-          if (error) {
-            rejectPromise(error);
-          } else {
-            resolvePromise(result);
+    try {
+      this.serverId = await new Promise((resolvePromise, rejectPromise) => {
+        this.lib.hostStart.async(
+          argvJson,
+          argvJson.length,
+          envJson,
+          envJson ? envJson.length : 0,
+          (error, result) => {
+            if (error) {
+              rejectPromise(error);
+            } else {
+              resolvePromise(result);
+            }
           }
-        }
+        );
+      });
+      if (!this.serverId) {
+        throw new Error(
+          `copilot_runtime_host_start failed (library '${this.libraryPath}').`
+        );
+      }
+      if (this.disposed) {
+        throw new Error("The in-process runtime host was disposed during startup.");
+      }
+      this.outboundCallback = koffi.register(
+        (_userData, bytesPtr, bytesLen) => this.feedInbound(bytesPtr, bytesLen),
+        this.lib.outboundCallbackType
       );
-    });
-    if (!this.serverId) {
-      throw new Error(`copilot_runtime_host_start failed (library '${this.libraryPath}').`);
-    }
-    this.outboundCallback = koffi.register(
-      (_userData, bytesPtr, bytesLen) => this.feedInbound(bytesPtr, bytesLen),
-      this.lib.outboundCallbackType
-    );
-    this.connectionId = this.lib.connectionOpen(
-      this.serverId,
-      this.outboundCallback,
-      null,
-      null,
-      0,
-      null,
-      0,
-      null,
-      0
-    );
-    if (!this.connectionId) {
-      this.unregisterCallback();
-      this.lib.hostShutdown(this.serverId);
-      this.serverId = 0;
-      throw new Error("copilot_runtime_connection_open failed.");
+      this.connectionId = this.lib.connectionOpen(
+        this.serverId,
+        this.outboundCallback,
+        null,
+        null,
+        0,
+        null,
+        0,
+        null,
+        0
+      );
+      if (!this.connectionId) {
+        this.unregisterCallback();
+        this.lib.hostShutdown(this.serverId);
+        this.serverId = 0;
+        throw new Error("copilot_runtime_connection_open failed.");
+      }
+      this.keepAliveTimer = setInterval(() => {
+      }, KEEP_ALIVE_INTERVAL_MS);
+    } finally {
+      this.starting = false;
+      if (this.disposed) {
+        void this.tryFinalizeCleanup();
+      }
     }
-    this.keepAliveTimer = setInterval(() => {
-    }, KEEP_ALIVE_INTERVAL_MS);
   }
   writeFrame(frame) {
     if (this.disposed || !this.connectionId) {
@@ -204,41 +225,105 @@ class FfiRuntimeHost {
   }
   unregisterCallback() {
     if (this.outboundCallback === void 0) {
-      return;
+      return true;
     }
     const callback = this.outboundCallback;
-    this.outboundCallback = void 0;
     try {
       koffi.unregister(callback);
-    } catch {
+      this.outboundCallback = void 0;
+      return true;
+    } catch (error) {
+      console.error(
+        `Failed to unregister in-process FFI callback: ${error instanceof Error ? error.stack ?? error.message : String(error)}`
+      );
+      FfiRuntimeHost.quarantinedHosts.add(this);
+      return false;
     }
   }
-  /** Closes the FFI connection, shuts down the native host, and releases resources. */
-  dispose() {
-    if (this.disposed) {
+  scheduleCleanupRetry() {
+    if (this.cleanupRetryTimer !== void 0) {
       return;
     }
-    this.disposed = true;
-    if (this.keepAliveTimer !== void 0) {
-      clearInterval(this.keepAliveTimer);
-      this.keepAliveTimer = void 0;
+    this.cleanupRetryTimer = setTimeout(() => {
+      this.cleanupRetryTimer = void 0;
+      void this.tryFinalizeCleanup();
+    }, CLEANUP_RETRY_INTERVAL_MS);
+  }
+  async tryFinalizeCleanup() {
+    if (this.cleanupInProgress) {
+      this.scheduleCleanupRetry();
+      return;
     }
+    this.cleanupInProgress = true;
     try {
       if (this.connectionId) {
-        this.lib.connectionClose(this.connectionId);
+        let closed = false;
+        try {
+          closed = await new Promise((resolvePromise, rejectPromise) => {
+            this.lib.connectionClose.async(
+              this.connectionId,
+              (error, result) => {
+                if (error) {
+                  rejectPromise(error);
+                } else {
+                  resolvePromise(result);
+                }
+              }
+            );
+          });
+        } catch (error) {
+          console.error(
+            `Failed to close in-process FFI connection: ${error instanceof Error ? error.stack ?? error.message : String(error)}`
+          );
+          FfiRuntimeHost.quarantinedHosts.add(this);
+          if (this.keepAliveTimer !== void 0) {
+            clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = void 0;
+          }
+          return;
+        }
+        if (!closed) {
+          this.scheduleCleanupRetry();
+          return;
+        }
         this.connectionId = 0;
       }
-    } catch {
-    }
-    try {
+      const callbackUnregistered = this.unregisterCallback();
+      if (this.keepAliveTimer !== void 0) {
+        clearInterval(this.keepAliveTimer);
+        this.keepAliveTimer = void 0;
+      }
       if (this.serverId) {
-        this.lib.hostShutdown(this.serverId);
+        try {
+          if (!this.lib.hostShutdown(this.serverId)) {
+            console.error(
+              `In-process FFI host shutdown did not recognize server ${this.serverId}.`
+            );
+          }
+        } catch (error) {
+          console.error(
+            `Failed to shut down in-process FFI host: ${error instanceof Error ? error.stack ?? error.message : String(error)}`
+          );
+        }
         this.serverId = 0;
       }
-    } catch {
+      if (callbackUnregistered) {
+        FfiRuntimeHost.quarantinedHosts.delete(this);
+      }
+    } finally {
+      this.cleanupInProgress = false;
+    }
+  }
+  /** Awaits the initial cleanup attempt; a non-quiescent close is retried in the background. */
+  async dispose() {
+    if (this.disposed) {
+      return;
     }
+    this.disposed = true;
     this.receiveStream.end();
-    this.unregisterCallback();
+    if (!this.starting) {
+      await this.tryFinalizeCleanup();
+    }
   }
 }
 export {