@syntesseraai/opencode-feature-factory 0.2.14 → 0.2.15

package/dist/agent-management-tools.js

@@ -1,4 +1,4 @@
-import { tool } from '@opencode-ai/plugin';
+import { tool } from '@opencode-ai/plugin/tool';
 import { listActiveAgents, findAgentFiles, findAgentFilesById, findAllAgentFiles, readAgentContextById, } from './agent-context.js';
 /**
  * Create agent management tools for the plugin

package/dist/feature-factory-setup.js

@@ -18,6 +18,34 @@ async function log(client, level, message, extra) {
         // Logging failure should not affect plugin operation
     }
 }
+/**
+ * Execute a shell command with a timeout to prevent hangs
+ */
+async function executeWithTimeout(operation, timeoutMs = 5000, operationName = 'shell command') {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`${operationName} timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([operation(), timeoutPromise]);
+    }
+    catch (error) {
+        // Return null on timeout or error
+        return null;
+    }
+}
+/**
+ * Validate that a directory path is safe to use
+ */
+function isValidDirectory(directory) {
+    if (!directory || typeof directory !== 'string')
+        return false;
+    if (directory === '' || directory === '/')
+        return false;
+    // Check for common invalid patterns
+    if (directory.includes('\0') || directory.includes('..'))
+        return false;
+    return true;
+}
 /**
  * Initialize the Feature Factory directory structure.
  * Creates .feature-factory/ and .feature-factory/agents/ directories.
@@ -25,11 +53,24 @@ async function log(client, level, message, extra) {
  */
 export async function initializeFeatureFactory(input, $) {
     const { directory, client } = input;
+    // Validate directory before attempting any operations
+    if (!isValidDirectory(directory)) {
+        await log(client, 'debug', 'feature-factory-init-skipped-invalid-directory', {
+            directory: String(directory),
+        });
+        return;
+    }
     const featureFactoryDir = `${directory}/.feature-factory`;
     const agentsDir = `${featureFactoryDir}/agents`;
-    // Create directories if they don't exist
+    // Create directories if they don't exist (with timeout protection)
     try {
-        await $ `mkdir -p ${agentsDir}`.quiet();
+        const result = await executeWithTimeout(async () => await $ `mkdir -p ${agentsDir}`.quiet(), 3000, 'mkdir -p');
+        if (result === null) {
+            await log(client, 'warn', 'feature-factory-directory-creation-timeout', {
+                agentsDir,
+            });
+            return; // Exit early if we can't create directories
+        }
         await log(client, 'debug', 'feature-factory-directories-created', {
             featureFactoryDir,
             agentsDir,
@@ -41,44 +82,70 @@ export async function initializeFeatureFactory(input, $) {
         });
         // Continue even if directory creation fails - it might already exist
     }
-    // Check for CI script migration
+    // Check for CI script migration (with timeout protection)
     const oldCiPath = `${directory}/management/ci.sh`;
     const newCiPath = `${featureFactoryDir}/ci.sh`;
     try {
-        // Check if old CI exists
-        await $ `test -f ${oldCiPath}`.quiet();
-        // Old exists, check if new already exists
-        try {
+        // Check if old CI exists (with timeout)
+        const oldExists = await executeWithTimeout(async () => {
+            await $ `test -f ${oldCiPath}`.quiet();
+            return true;
+        }, 2000, 'test -f old-ci');
+        if (oldExists !== true) {
+            // Old doesn't exist, nothing to migrate
+            await log(client, 'debug', 'ci-sh-no-migration-needed', {
+                oldPath: oldCiPath,
+            });
+            return;
+        }
+        // Old exists, check if new already exists (with timeout)
+        const newExists = await executeWithTimeout(async () => {
             await $ `test -f ${newCiPath}`.quiet();
+            return true;
+        }, 2000, 'test -f new-ci');
+        if (newExists === true) {
             // Both exist - migration already done or user has both
             await log(client, 'debug', 'ci-sh-both-locations-exist', {
                 oldPath: oldCiPath,
                 newPath: newCiPath,
             });
+            return;
         }
-        catch {
-            // Old exists, new doesn't - migrate
-            try {
-                await $ `cp ${oldCiPath} ${newCiPath}`.quiet();
+        // Old exists, new doesn't - migrate (with timeout)
+        const copied = await executeWithTimeout(async () => {
+            await $ `cp ${oldCiPath} ${newCiPath}`.quiet();
+            return true;
+        }, 3000, 'cp ci.sh');
+        if (copied === true) {
+            const removed = await executeWithTimeout(async () => {
                 await $ `rm ${oldCiPath}`.quiet();
+                return true;
+            }, 2000, 'rm old-ci');
+            if (removed === true) {
                 await log(client, 'info', 'ci-sh-migrated', {
                     from: oldCiPath,
                     to: newCiPath,
                 });
             }
-            catch (migrateError) {
-                await log(client, 'error', 'ci-sh-migration-failed', {
+            else {
+                await log(client, 'warn', 'ci-sh-migration-partial', {
                     from: oldCiPath,
                     to: newCiPath,
-                    error: String(migrateError),
+                    reason: 'copied but failed to remove old file',
                 });
             }
         }
+        else {
+            await log(client, 'error', 'ci-sh-migration-failed', {
+                from: oldCiPath,
+                to: newCiPath,
+                reason: 'copy operation timed out or failed',
+            });
+        }
     }
-    catch {
-        // Old doesn't exist, nothing to migrate
-        await log(client, 'debug', 'ci-sh-no-migration-needed', {
-            oldPath: oldCiPath,
+    catch (error) {
+        await log(client, 'error', 'ci-sh-migration-error', {
+            error: String(error),
         });
     }
 }

package/dist/index.js

@@ -2,6 +2,21 @@ import { createQualityGateHooks } from './stop-quality-gate.js';
 import { initializeFeatureFactory } from './feature-factory-setup.js';
 import { createAgentManagementTools } from './agent-management-tools.js';
 const SERVICE_NAME = 'feature-factory';
+const PLUGIN_INIT_TIMEOUT_MS = 10000; // 10 seconds max for plugin initialization
+/**
+ * Wrap an async operation with a timeout to prevent hangs
+ */
+async function withTimeout(operation, timeoutMs, _context) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`timeout`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([operation(), timeoutPromise]);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Log a message using the OpenCode client's structured logging.
  * Silently fails if logging is unavailable.
@@ -56,26 +71,39 @@ export const StopQualityGatePlugin = async (input) => {
     if (!rootDir || rootDir === '' || rootDir === '/') {
         return {};
     }
-    // Initialize Feature Factory directory structure
+    // Initialize Feature Factory directory structure (with timeout protection)
     try {
-        await initializeFeatureFactory(input, $);
+        const initResult = await withTimeout(async () => await initializeFeatureFactory(input, $), PLUGIN_INIT_TIMEOUT_MS, 'feature-factory-init');
+        if (initResult === null) {
+            await log(client, 'warn', 'feature-factory-init-timeout', {
+                timeoutMs: PLUGIN_INIT_TIMEOUT_MS,
+            });
+        }
     }
     catch (error) {
         await log(client, 'error', 'feature-factory-init-error', {
             error: String(error),
         });
     }
-    // Create quality gate hooks
+    // Create quality gate hooks (with timeout protection)
     let qualityGateHooks = {};
     try {
-        qualityGateHooks = await createQualityGateHooks(input);
+        const hooksResult = await withTimeout(async () => await createQualityGateHooks(input), PLUGIN_INIT_TIMEOUT_MS, 'quality-gate-init');
+        if (hooksResult !== null) {
+            qualityGateHooks = hooksResult;
+        }
+        else {
+            await log(client, 'warn', 'quality-gate-init-timeout', {
+                timeoutMs: PLUGIN_INIT_TIMEOUT_MS,
+            });
+        }
     }
     catch (error) {
         await log(client, 'error', 'quality-gate.init-error', {
             error: String(error),
         });
     }
-    // Create agent management tools
+    // Create agent management tools (synchronous, minimal timeout for safety)
     let agentManagementHooks = {};
     try {
         agentManagementHooks = createAgentManagementTools(input);

package/dist/stop-quality-gate.js

@@ -154,12 +154,30 @@ async function log(client, level, message, extra) {
         return undefined;
     }
 }
+/**
+ * Execute a shell command with a timeout to prevent hangs
+ */
+async function executeWithTimeout(operation, timeoutMs = 5000, _operationName = 'shell command') {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([operation(), timeoutPromise]);
+    }
+    catch {
+        // Return null on timeout or error
+        return null;
+    }
+}
 export async function createQualityGateHooks(input) {
     const { client, $, directory } = input;
     async function ciShExists() {
         try {
-            await $ `test -f ${directory}/.feature-factory/ci.sh`.quiet();
-            return true;
+            const result = await executeWithTimeout(async () => {
+                await $ `test -f ${directory}/.feature-factory/ci.sh`.quiet();
+                return true;
+            }, 2000, 'test -f ci.sh');
+            return result === true;
         }
         catch {
             return false;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@syntesseraai/opencode-feature-factory",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "type": "module",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
   "license": "MIT",