@link-assistant/hive-mind 0.50.4 → 0.50.6

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @link-assistant/hive-mind
 
+## 0.50.6
+
+### Patch Changes
+
+- 7733b32: Detect OpenCode permission prompts and recommend @link-assistant/agent for autonomous workflows
+  - Configure all OpenCode permissions to "allow" (edit, bash, webfetch, skill, doom_loop, external_directory)
+  - Detect interactive permission prompts that block automated execution
+  - Recommend @link-assistant/agent (100% unrestricted OpenCode fork) when prompts are detected
+
+## 0.50.5
+
+### Patch Changes
+
+- Test patch release
+
 ## 0.50.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "0.50.4",
+  "version": "0.50.6",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/opencode.lib.mjs

@@ -211,6 +211,34 @@ export const executeOpenCodeCommand = async params => {
       }
     }
 
+    // Create OpenCode configuration file with unrestricted permissions
+    // This allows OpenCode to access files outside the working directory without prompting
+    // Fixes issue #755: "Permission required to run: Access file outside working directory"
+    // Reference: https://opencode.ai/docs/config - see permissions documentation
+    const opencodeConfigPath = path.join(tempDir, 'opencode.json');
+    const opencodeConfig = {
+      $schema: 'https://opencode.ai/config.json',
+      permission: {
+        // All tool permissions set to 'allow' for unrestricted autonomous execution
+        // See: https://github.com/sst/opencode - permission options: "allow", "ask", "deny"
+        edit: 'allow', // File modification operations
+        bash: 'allow', // Command execution
+        webfetch: 'allow', // Web page retrieval
+        skill: 'allow', // Custom skills execution
+        doom_loop: 'allow', // Allow repeated identical tool calls (default: ask)
+        external_directory: 'allow', // File operations outside working directory (default: ask)
+      },
+    };
+    try {
+      await fs.writeFile(opencodeConfigPath, JSON.stringify(opencodeConfig, null, 2));
+      if (argv.verbose) {
+        await log(`   Created OpenCode config: ${opencodeConfigPath}`, { verbose: true });
+        await log('   Permissions set: edit=allow, bash=allow, webfetch=allow, skill=allow, doom_loop=allow, external_directory=allow', { verbose: true });
+      }
+    } catch (configError) {
+      await log(`⚠️  Warning: Could not create OpenCode config file: ${configError.message}`, { level: 'warning' });
+    }
+
     // Take resource snapshot before execution
     const resourcesBefore = await getResourceSnapshot();
     await log('📈 System resources before execution:', { verbose: true });
@@ -277,24 +305,76 @@ export const executeOpenCodeCommand = async params => {
       let limitReached = false;
       let limitResetTime = null;
       let lastMessage = '';
+      let allOutput = ''; // Collect all output for error detection
 
       for await (const chunk of execCommand.stream()) {
         if (chunk.type === 'stdout') {
           const output = chunk.data.toString();
           await log(output);
           lastMessage = output;
+          allOutput += output;
         }
 
         if (chunk.type === 'stderr') {
           const errorOutput = chunk.data.toString();
           if (errorOutput) {
             await log(errorOutput, { stream: 'stderr' });
+            allOutput += errorOutput;
           }
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
         }
       }
 
+      // Clean up the opencode.json config file to avoid polluting the repository
+      try {
+        await fs.unlink(opencodeConfigPath);
+        if (argv.verbose) {
+          await log(`   Cleaned up OpenCode config: ${opencodeConfigPath}`, { verbose: true });
+        }
+      } catch (cleanupError) {
+        // Ignore cleanup errors - file may already be deleted or not exist
+        if (argv.verbose) {
+          await log(`   Note: Could not clean up OpenCode config: ${cleanupError.message}`, { verbose: true });
+        }
+      }
+
+      // Check for permission prompt errors (these can hang the process)
+      // Pattern: "Permission required to run:" or "Access file outside working directory"
+      const hasPermissionPrompt = allOutput.includes('Permission required to run:') || allOutput.includes('Access file outside working directory') || allOutput.includes('● Allow once') || allOutput.includes('○ Always allow') || allOutput.includes('○ Reject');
+
+      if (hasPermissionPrompt) {
+        await log('\n\n❌ OpenCode encountered a permission prompt', { level: 'error' });
+        await log('', { level: 'error' });
+        await log('OpenCode CLI does not support autonomous agents in its full potential.', { level: 'error' });
+        await log('Interactive permission prompts block automated execution, even with', { level: 'error' });
+        await log('all permissions set to "allow" in opencode.json configuration.', { level: 'error' });
+        await log('', { level: 'error' });
+        await log('💡 Recommendation: Use @link-assistant/agent instead', { level: 'error' });
+        await log('', { level: 'error' });
+        await log('   @link-assistant/agent is a 100% unrestricted fork of OpenCode', { level: 'error' });
+        await log('   specifically designed for autonomous agents in isolated environments.', { level: 'error' });
+        await log('', { level: 'error' });
+        await log('   Install: bun install -g @link-assistant/agent', { level: 'error' });
+        await log('   Run with: --tool agent', { level: 'error' });
+        await log('', { level: 'error' });
+        await log('   More info: https://github.com/link-assistant/agent', { level: 'error' });
+        await log('', { level: 'error' });
+
+        const resourcesAfter = await getResourceSnapshot();
+        await log('\n📈 System resources after execution:', { verbose: true });
+        await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
+        await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
+
+        return {
+          success: false,
+          sessionId,
+          limitReached: false,
+          limitResetTime: null,
+          permissionPromptDetected: true,
+        };
+      }
+
       if (exitCode !== 0) {
         // Check for usage limit errors first (more specific)
         const limitInfo = detectUsageLimit(lastMessage);
@@ -339,6 +419,13 @@ export const executeOpenCodeCommand = async params => {
         limitResetTime,
       };
     } catch (error) {
+      // Clean up the opencode.json config file even on error
+      try {
+        await fs.unlink(opencodeConfigPath);
+      } catch {
+        // Ignore cleanup errors
+      }
+
       reportError(error, {
         context: 'execute_opencode',
         command: params.command,