@link-assistant/agent 0.16.16 → 0.16.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.16.16",
+  "version": "0.16.17",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",
@@ -9,7 +9,8 @@
   },
   "scripts": {
     "dev": "bun run src/index.js",
-    "test": "bun test",
+    "test": "bun test tests/*.test.js tests/*.test.ts",
+    "test:integration": "bun test tests/integration/basic.test.js",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write .",
@@ -117,6 +118,7 @@
     "eslint": "^9.38.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-promise": "^7.2.1",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.6",
     "prettier": "^3.6.2"

package/src/cli/continuous-mode.js

@@ -377,15 +377,24 @@ export async function runContinuousServerMode(
 
     // Wait for stdin to end (EOF or close)
     await new Promise((resolve) => {
+      let resolved = false;
+      const safeResolve = () => {
+        if (!resolved) {
+          resolved = true;
+          resolve();
+        }
+      };
+
       const checkRunning = setInterval(() => {
         if (!stdinReader.isRunning()) {
           clearInterval(checkRunning);
           // Wait for any pending messages to complete
           const waitForPending = () => {
             if (!isProcessing && pendingMessages.length === 0) {
-              resolve();
+              safeResolve();
             } else {
-              setTimeout(waitForPending, 100);
+              // Use .unref() to prevent keeping the event loop alive (#213)
+              setTimeout(waitForPending, 100).unref();
             }
           };
           waitForPending();
@@ -394,8 +403,8 @@ export async function runContinuousServerMode(
       // Allow process to exit naturally when no other work remains
       checkRunning.unref();
 
-      // Also handle SIGINT
-      process.on('SIGINT', () => {
+      // Handle SIGINT — use 'once' to avoid accumulating handlers (#213)
+      const sigintHandler = () => {
         outputStatus(
           {
             type: 'status',
@@ -404,8 +413,9 @@ export async function runContinuousServerMode(
           compactJson
         );
         clearInterval(checkRunning);
-        resolve();
-      });
+        safeResolve();
+      };
+      process.once('SIGINT', sigintHandler);
     });
   } finally {
     if (stdinReader) {
@@ -596,15 +606,24 @@ export async function runContinuousDirectMode(
 
     // Wait for stdin to end (EOF or close)
     await new Promise((resolve) => {
+      let resolved = false;
+      const safeResolve = () => {
+        if (!resolved) {
+          resolved = true;
+          resolve();
+        }
+      };
+
       const checkRunning = setInterval(() => {
         if (!stdinReader.isRunning()) {
           clearInterval(checkRunning);
           // Wait for any pending messages to complete
           const waitForPending = () => {
             if (!isProcessing && pendingMessages.length === 0) {
-              resolve();
+              safeResolve();
             } else {
-              setTimeout(waitForPending, 100);
+              // Use .unref() to prevent keeping the event loop alive (#213)
+              setTimeout(waitForPending, 100).unref();
             }
           };
           waitForPending();
@@ -613,8 +632,8 @@ export async function runContinuousDirectMode(
       // Allow process to exit naturally when no other work remains
       checkRunning.unref();
 
-      // Also handle SIGINT
-      process.on('SIGINT', () => {
+      // Handle SIGINT — use 'once' to avoid accumulating handlers (#213)
+      const sigintHandler = () => {
         outputStatus(
           {
             type: 'status',
@@ -623,8 +642,9 @@ export async function runContinuousDirectMode(
           compactJson
         );
         clearInterval(checkRunning);
-        resolve();
-      });
+        safeResolve();
+      };
+      process.once('SIGINT', sigintHandler);
     });
   } finally {
     if (stdinReader) {

package/src/cli/input-queue.js

@@ -178,11 +178,13 @@ export function createContinuousStdinReader(options = {}) {
     isRunning = false;
   };
 
+  const handleError = () => {
+    isRunning = false;
+  };
+
   process.stdin.on('data', handleData);
   process.stdin.on('end', handleEnd);
-  process.stdin.on('error', () => {
-    isRunning = false;
-  });
+  process.stdin.on('error', handleError);
 
   return {
     queue: inputQueue,
@@ -191,6 +193,7 @@ export function createContinuousStdinReader(options = {}) {
       inputQueue.flush();
       process.stdin.removeListener('data', handleData);
       process.stdin.removeListener('end', handleEnd);
+      process.stdin.removeListener('error', handleError);
     },
     isRunning: () => isRunning,
   };

package/src/flag/flag.ts

@@ -194,4 +194,13 @@ export namespace Flag {
   export function setCompactJson(value: boolean) {
     _compactJson = value;
   }
+
+  // Retry on rate limits - when disabled, 429 responses are returned immediately without retrying
+  // Enabled by default. Use --no-retry-on-rate-limits in integration tests to avoid waiting for rate limits.
+  export let RETRY_ON_RATE_LIMITS = true;
+
+  // Allow setting retry-on-rate-limits mode programmatically (e.g., from CLI --retry-on-rate-limits flag)
+  export function setRetryOnRateLimits(value: boolean) {
+    RETRY_ON_RATE_LIMITS = value;
+  }
 }

package/src/index.js

@@ -309,7 +309,12 @@ async function runAgentMode(argv, request) {
     },
   });
 
-  // Explicitly exit to ensure process terminates
+  // Explicitly exit to ensure process terminates (#213)
+  Log.Default.info(() => ({
+    message: 'Agent exiting',
+    hasError,
+    uptimeSeconds: Math.round(process.uptime()),
+  }));
   process.exit(hasError ? 1 : 0);
 }
 
@@ -387,7 +392,12 @@ async function runContinuousAgentMode(argv) {
     },
   });
 
-  // Explicitly exit to ensure process terminates
+  // Explicitly exit to ensure process terminates (#213)
+  Log.Default.info(() => ({
+    message: 'Agent exiting',
+    hasError,
+    uptimeSeconds: Math.round(process.uptime()),
+  }));
   process.exit(hasError ? 1 : 0);
 }
 
@@ -708,6 +718,12 @@ async function main() {
               description:
                 'Maximum total retry time in seconds for rate limit errors (default: 604800 = 7 days)',
             })
+            .option('retry-on-rate-limits', {
+              type: 'boolean',
+              description:
+                'Retry AI completions API requests when rate limited (HTTP 429). Use --no-retry-on-rate-limits in integration tests to fail fast instead of waiting.',
+              default: true,
+            })
             .option('output-response-model', {
               type: 'boolean',
               description: 'Include model info in step_finish output',
@@ -902,6 +918,10 @@ async function main() {
         if (argv['summarize-session'] === true) {
           Flag.setSummarizeSession(true);
         }
+        // retry-on-rate-limits is enabled by default, only set if explicitly disabled
+        if (argv['retry-on-rate-limits'] === false) {
+          Flag.setRetryOnRateLimits(false);
+        }
         await Log.init({
           print: Flag.OPENCODE_VERBOSE,
           level: Flag.OPENCODE_VERBOSE ? 'DEBUG' : 'INFO',

package/src/provider/retry-fetch.ts

@@ -166,6 +166,8 @@ export namespace RetryFetch {
       }
 
       const timeout = setTimeout(resolve, ms);
+      // Prevent sleep timer from keeping event loop alive (#213)
+      if (timeout.unref) timeout.unref();
 
       if (signal) {
         const abortHandler = () => {
@@ -224,6 +226,8 @@ export namespace RetryFetch {
         )
       );
     }, remainingTimeout);
+    // Prevent timer from keeping event loop alive after cleanup (#213)
+    if (globalTimeoutId.unref) globalTimeoutId.unref();
     timers.push(globalTimeoutId);
 
     // Periodically check if user canceled (every 10 seconds)
@@ -244,6 +248,8 @@ export namespace RetryFetch {
       // Check immediately and then every 10 seconds
       checkUserCancellation();
       const intervalId = setInterval(checkUserCancellation, 10_000);
+      // Prevent interval from keeping event loop alive after cleanup (#213)
+      if ((intervalId as any).unref) (intervalId as any).unref();
       timers.push(intervalId as unknown as NodeJS.Timeout);
     }
 
@@ -364,6 +370,16 @@ export namespace RetryFetch {
           return response;
         }
 
+        // If retry on rate limits is disabled, return 429 immediately
+        if (!Flag.RETRY_ON_RATE_LIMITS) {
+          log.info(() => ({
+            message:
+              'rate limit retry disabled (--no-retry-on-rate-limits), returning 429',
+            sessionID,
+          }));
+          return response;
+        }
+
         // Check if we're within the global retry timeout
         const elapsed = Date.now() - startTime;
         if (elapsed >= maxRetryTimeout) {

package/src/server/server.ts

@@ -246,7 +246,9 @@ export namespace Server {
     const server = Bun.serve({
       port: opts.port,
       hostname: opts.hostname,
-      idleTimeout: 0,
+      // Use default idle timeout (255s) instead of 0 (infinite) to prevent
+      // keeping the event loop alive after server.stop(). See #213.
+      idleTimeout: 255,
       fetch: App().fetch,
     });
     return server;

package/src/session/retry.ts

@@ -123,6 +123,8 @@ export namespace SessionRetry {
   export async function sleep(ms: number, signal: AbortSignal): Promise<void> {
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(resolve, ms);
+      // Prevent sleep timer from keeping event loop alive (#213)
+      if (timeout.unref) timeout.unref();
       signal.addEventListener(
         'abort',
         () => {

package/src/util/timeout.ts

@@ -9,6 +9,8 @@ export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
       timeout = setTimeout(() => {
         reject(new Error(`Operation timed out after ${ms}ms`));
       }, ms);
+      // Prevent timeout from keeping the event loop alive (#213)
+      timeout.unref();
     }),
   ]);
 }