@link-assistant/agent 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "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

@@ -5,10 +5,14 @@ import path from 'path';
 import { NamedError } from '../util/error';
 import { readableStreamToText } from 'bun';
 import { Flag } from '../flag/flag';
+import { Lock } from '../util/lock';
 
 export namespace BunProc {
   const log = Log.create({ service: 'bun' });
 
+  // Lock key for serializing package installations to prevent race conditions
+  const INSTALL_LOCK_KEY = 'bun-install';
+
   export async function run(
     cmd: string[],
     options?: Bun.SpawnOptions.OptionsObject<any, any, any>
@@ -65,8 +69,38 @@ export namespace BunProc {
     })
   );
 
+  // Maximum number of retry attempts for cache-related errors
+  const MAX_RETRIES = 3;
+  // Delay between retries in milliseconds
+  const RETRY_DELAY_MS = 500;
+
+  /**
+   * Check if an error is related to Bun cache issues
+   */
+  function isCacheRelatedError(errorMsg: string): boolean {
+    return (
+      errorMsg.includes('failed copying files from cache') ||
+      errorMsg.includes('FileNotFound') ||
+      errorMsg.includes('ENOENT') ||
+      errorMsg.includes('EACCES') ||
+      errorMsg.includes('EBUSY')
+    );
+  }
+
+  /**
+   * Wait for a specified duration
+   */
+  function delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
   export async function install(pkg: string, version = 'latest') {
     const mod = path.join(Global.Path.cache, 'node_modules', pkg);
+
+    // Use a write lock to serialize all package installations
+    // This prevents race conditions when multiple packages are installed concurrently
+    using _ = await Lock.write(INSTALL_LOCK_KEY);
+
     const pkgjson = Bun.file(path.join(Global.Path.cache, 'package.json'));
     const parsed = await pkgjson.json().catch(async () => {
       const result = { dependencies: {} };
@@ -108,25 +142,78 @@ export namespace BunProc {
       version,
     });
 
-    await BunProc.run(args, {
-      cwd: Global.Path.cache,
-    }).catch((e) => {
-      log.error('package installation failed', {
+    // Retry logic for cache-related errors
+    let lastError: Error | undefined;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        await BunProc.run(args, {
+          cwd: Global.Path.cache,
+        });
+
+        log.info('package installed successfully', { pkg, version, attempt });
+        parsed.dependencies[pkg] = version;
+        await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
+        return mod;
+      } catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        const isCacheError = isCacheRelatedError(errorMsg);
+
+        log.warn('package installation attempt failed', {
+          pkg,
+          version,
+          attempt,
+          maxRetries: MAX_RETRIES,
+          error: errorMsg,
+          isCacheError,
+        });
+
+        if (isCacheError && attempt < MAX_RETRIES) {
+          log.info('retrying installation after cache-related error', {
+            pkg,
+            version,
+            attempt,
+            nextAttempt: attempt + 1,
+            delayMs: RETRY_DELAY_MS,
+          });
+          await delay(RETRY_DELAY_MS);
+          lastError = e instanceof Error ? e : new Error(errorMsg);
+          continue;
+        }
+
+        // Non-cache error or final attempt - log and throw
+        log.error('package installation failed', {
+          pkg,
+          version,
+          error: errorMsg,
+          stack: e instanceof Error ? e.stack : undefined,
+          possibleCacheCorruption: isCacheError,
+          attempts: attempt,
+        });
+
+        // Provide helpful recovery instructions for cache-related errors
+        if (isCacheError) {
+          log.error(
+            'Bun package cache may be corrupted. Try clearing the cache with: bun pm cache rm'
+          );
+        }
+
+        throw new InstallFailedError(
+          { pkg, version, details: errorMsg },
+          {
+            cause: e,
+          }
+        );
+      }
+    }
+
+    // This should not be reached, but handle it just in case
+    throw new InstallFailedError(
+      {
         pkg,
         version,
-        error: e instanceof Error ? e.message : String(e),
-        stack: e instanceof Error ? e.stack : undefined,
-      });
-      throw new InstallFailedError(
-        { pkg, version, details: e instanceof Error ? e.message : String(e) },
-        {
-          cause: e,
-        }
-      );
-    });
-    log.info('package installed successfully', { pkg, version });
-    parsed.dependencies[pkg] = version;
-    await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
-    return mod;
+        details: lastError?.message ?? 'Installation failed after all retries',
+      },
+      { cause: lastError }
+    );
   }
 }

package/src/provider/provider.ts

@@ -905,6 +905,10 @@ export namespace Provider {
     if (opencodeProvider) {
       const [model] = sort(Object.values(opencodeProvider.info.models));
       if (model) {
+        log.info('using opencode provider as default', {
+          provider: opencodeProvider.info.id,
+          model: model.id,
+        });
         return {
           providerID: opencodeProvider.info.id,
           modelID: model.id,
@@ -912,7 +916,7 @@ export namespace Provider {
       }
     }
 
-    // Fall back to any available provider
+    // Fall back to any available provider if opencode is not available
     const provider = providers.find(
       (p) => !cfg.provider || Object.keys(cfg.provider).includes(p.info.id)
     );

package/src/session/prompt.ts

@@ -290,10 +290,27 @@ export namespace SessionPrompt {
           history: msgs,
         });
 
-      const model = await Provider.getModel(
-        lastUser.model.providerID,
-        lastUser.model.modelID
-      );
+      let model;
+      try {
+        model = await Provider.getModel(
+          lastUser.model.providerID,
+          lastUser.model.modelID
+        );
+      } catch (error) {
+        log.warn(
+          'Failed to initialize specified model, falling back to default model',
+          {
+            providerID: lastUser.model.providerID,
+            modelID: lastUser.model.modelID,
+            error: error instanceof Error ? error.message : String(error),
+          }
+        );
+        const defaultModel = await Provider.defaultModel();
+        model = await Provider.getModel(
+          defaultModel.providerID,
+          defaultModel.modelID
+        );
+      }
       const task = tasks.pop();
 
       // pending subtask