@link-assistant/agent 0.13.0 → 0.13.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/bun/index.ts

@@ -13,26 +13,69 @@ export namespace BunProc {
   // Lock key for serializing package installations to prevent race conditions
   const INSTALL_LOCK_KEY = 'bun-install';
 
+  // Default timeout for subprocess commands (2 minutes)
+  // This prevents indefinite hangs from known Bun issues:
+  // - HTTP 304 response handling (https://github.com/oven-sh/bun/issues/5831)
+  // - Failed dependency fetch (https://github.com/oven-sh/bun/issues/26341)
+  // - IPv6 configuration issues
+  const DEFAULT_TIMEOUT_MS = 120000;
+
+  // Timeout specifically for package installation (60 seconds)
+  // Package installations should complete within this time for typical packages
+  const INSTALL_TIMEOUT_MS = 60000;
+
+  export const TimeoutError = NamedError.create(
+    'BunTimeoutError',
+    z.object({
+      cmd: z.array(z.string()),
+      timeoutMs: z.number(),
+    })
+  );
+
   export async function run(
     cmd: string[],
-    options?: Bun.SpawnOptions.OptionsObject<any, any, any>
+    options?: Bun.SpawnOptions.OptionsObject<any, any, any> & {
+      timeout?: number;
+    }
   ) {
+    const timeout = options?.timeout ?? DEFAULT_TIMEOUT_MS;
+
     log.info(() => ({
       message: 'running',
       cmd: [which(), ...cmd],
-      ...options,
+      timeout,
+      cwd: options?.cwd,
     }));
+
     const result = Bun.spawn([which(), ...cmd], {
       ...options,
       stdout: 'pipe',
       stderr: 'pipe',
+      timeout, // Automatically kills process after timeout
+      killSignal: 'SIGTERM', // Graceful termination signal
       env: {
         ...process.env,
         ...options?.env,
         BUN_BE_BUN: '1',
       },
     });
+
     const code = await result.exited;
+
+    // Check if process was killed due to timeout
+    if (result.signalCode === 'SIGTERM' && code !== 0) {
+      log.error(() => ({
+        message: 'command timed out',
+        cmd: [which(), ...cmd],
+        timeout,
+        signalCode: result.signalCode,
+      }));
+      throw new TimeoutError({
+        cmd: [which(), ...cmd],
+        timeoutMs: timeout,
+      });
+    }
+
     const stdout = result.stdout
       ? typeof result.stdout === 'number'
         ? result.stdout
@@ -84,6 +127,13 @@ export namespace BunProc {
     );
   }
 
+  /**
+   * Check if an error is a timeout error
+   */
+  function isTimeoutError(error: unknown): boolean {
+    return error instanceof TimeoutError;
+  }
+
   /**
    * Wait for a specified duration
    */
@@ -139,12 +189,13 @@ export namespace BunProc {
       version,
     }));
 
-    // Retry logic for cache-related errors
+    // Retry logic for cache-related errors and timeout errors
     let lastError: Error | undefined;
     for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
       try {
         await BunProc.run(args, {
           cwd: Global.Path.cache,
+          timeout: INSTALL_TIMEOUT_MS, // Use specific timeout for package installation
         });
 
         log.info(() => ({
@@ -159,6 +210,7 @@ export namespace BunProc {
       } catch (e) {
         const errorMsg = e instanceof Error ? e.message : String(e);
         const isCacheError = isCacheRelatedError(errorMsg);
+        const isTimeout = isTimeoutError(e);
 
         log.warn(() => ({
           message: 'package installation attempt failed',
@@ -168,11 +220,15 @@ export namespace BunProc {
           maxRetries: MAX_RETRIES,
           error: errorMsg,
           isCacheError,
+          isTimeout,
         }));
 
-        if (isCacheError && attempt < MAX_RETRIES) {
+        // Retry on cache-related errors or timeout errors
+        if ((isCacheError || isTimeout) && attempt < MAX_RETRIES) {
           log.info(() => ({
-            message: 'retrying installation after cache-related error',
+            message: isTimeout
+              ? 'retrying installation after timeout (possible network issue)'
+              : 'retrying installation after cache-related error',
             pkg,
             version,
             attempt,
@@ -184,7 +240,7 @@ export namespace BunProc {
           continue;
         }
 
-        // Non-cache error or final attempt - log and throw
+        // Non-retriable error or final attempt - log and throw
         log.error(() => ({
           message: 'package installation failed',
           pkg,
@@ -192,10 +248,11 @@ export namespace BunProc {
           error: errorMsg,
           stack: e instanceof Error ? e.stack : undefined,
           possibleCacheCorruption: isCacheError,
+          timedOut: isTimeout,
           attempts: attempt,
         }));
 
-        // Provide helpful recovery instructions for cache-related errors
+        // Provide helpful recovery instructions
         if (isCacheError) {
           log.error(() => ({
             message:
@@ -203,6 +260,15 @@ export namespace BunProc {
           }));
         }
 
+        if (isTimeout) {
+          log.error(() => ({
+            message:
+              'Package installation timed out. This may be due to network issues or Bun hanging. ' +
+              'Try: 1) Check network connectivity, 2) Run "bun pm cache rm" to clear cache, ' +
+              '3) Check for IPv6 issues (try disabling IPv6)',
+          }));
+        }
+
         throw new InstallFailedError(
           { pkg, version, details: errorMsg },
           {

package/src/provider/models.ts

@@ -67,11 +67,74 @@ export namespace ModelsDev {
 
   export type Provider = z.infer<typeof Provider>;
 
+  /**
+   * Cache staleness threshold in milliseconds (1 hour).
+   * If the cache is older than this, we await the refresh before using the data.
+   */
+  const CACHE_STALE_THRESHOLD_MS = 60 * 60 * 1000;
+
+  /**
+   * Get the models database, refreshing from models.dev if needed.
+   *
+   * This function handles cache staleness properly:
+   * - If cache doesn't exist: await refresh to ensure fresh data
+   * - If cache is stale (> 1 hour old): await refresh to ensure up-to-date models
+   * - If cache is fresh: trigger background refresh but use cached data immediately
+   *
+   * This prevents ProviderModelNotFoundError when:
+   * - User runs agent for the first time (no cache)
+   * - User has outdated cache missing new models like kimi-k2.5-free
+   *
+   * @see https://github.com/link-assistant/agent/issues/175
+   */
   export async function get() {
-    refresh();
     const file = Bun.file(filepath);
+
+    // Check if cache exists and get its modification time
+    const exists = await file.exists();
+
+    if (!exists) {
+      // No cache - must await refresh to get initial data
+      log.info(() => ({
+        message: 'no cache found, awaiting refresh',
+        path: filepath,
+      }));
+      await refresh();
+    } else {
+      // Check if cache is stale
+      const stats = await file.stat().catch(() => null);
+      const mtime = stats?.mtime?.getTime() ?? 0;
+      const isStale = Date.now() - mtime > CACHE_STALE_THRESHOLD_MS;
+
+      if (isStale) {
+        // Stale cache - await refresh to get updated model list
+        log.info(() => ({
+          message: 'cache is stale, awaiting refresh',
+          path: filepath,
+          age: Date.now() - mtime,
+          threshold: CACHE_STALE_THRESHOLD_MS,
+        }));
+        await refresh();
+      } else {
+        // Fresh cache - trigger background refresh but don't wait
+        log.info(() => ({
+          message: 'cache is fresh, triggering background refresh',
+          path: filepath,
+          age: Date.now() - mtime,
+        }));
+        refresh();
+      }
+    }
+
+    // Now read the cache file
     const result = await file.json().catch(() => {});
     if (result) return result as Record<string, Provider>;
+
+    // Fallback to bundled data if cache read failed
+    log.warn(() => ({
+      message: 'cache read failed, using bundled data',
+      path: filepath,
+    }));
     const json = await data();
     return JSON.parse(json) as Record<string, Provider>;
   }