@syntesseraai/opencode-feature-factory 0.2.14 → 0.2.16

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

@@ -1,7 +1,24 @@
 import { createQualityGateHooks } from './stop-quality-gate.js';
 import { initializeFeatureFactory } from './feature-factory-setup.js';
-import { createAgentManagementTools } from './agent-management-tools.js';
+import { FFAgentsCurrentPlugin } from './plugins/ff-agents-current-plugin.js';
+import { FFAgentsClearPlugin } from './plugins/ff-agents-clear-plugin.js';
+import { FFAgentsShowPlugin } from './plugins/ff-agents-show-plugin.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,38 +73,71 @@ 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
-    let agentManagementHooks = {};
+    // Create agent management tool plugins
+    let agentsCurrentHooks = {};
+    let agentsClearHooks = {};
+    let agentsShowHooks = {};
+    try {
+        agentsCurrentHooks = await FFAgentsCurrentPlugin(input);
+    }
+    catch (error) {
+        await log(client, 'error', 'ff-agents-current.init-error', {
+            error: String(error),
+        });
+    }
+    try {
+        agentsClearHooks = await FFAgentsClearPlugin(input);
+    }
+    catch (error) {
+        await log(client, 'error', 'ff-agents-clear.init-error', {
+            error: String(error),
+        });
+    }
     try {
-        agentManagementHooks = createAgentManagementTools(input);
+        agentsShowHooks = await FFAgentsShowPlugin(input);
     }
     catch (error) {
-        await log(client, 'error', 'agent-management.init-error', {
+        await log(client, 'error', 'ff-agents-show.init-error', {
             error: String(error),
         });
     }
     return {
         ...qualityGateHooks,
-        ...agentManagementHooks,
+        ...agentsCurrentHooks,
+        ...agentsClearHooks,
+        ...agentsShowHooks,
     };
 };
 // Default export for OpenCode plugin discovery

package/dist/plugins/ff-agents-clear-plugin.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from '@opencode-ai/plugin';
+export declare const FFAgentsClearPlugin: Plugin;

package/dist/plugins/ff-agents-clear-plugin.js

@@ -0,0 +1,55 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { findAgentFiles, findAgentFilesById, findAllAgentFiles } from '../agent-context.js';
+export const FFAgentsClearPlugin = async (input) => {
+    const { $ } = input;
+    return {
+        tool: {
+            'ff-agents-clear': tool({
+                description: 'Clear agent context files. Can clear all, or filter by session, agent type, or specific UUID',
+                args: {
+                    sessionID: tool.schema
+                        .string()
+                        .optional()
+                        .describe('Clear only agents for specific session'),
+                    agent: tool.schema.string().optional().describe('Clear only specific agent type'),
+                    id: tool.schema.string().optional().describe('Clear specific agent by UUID'),
+                },
+                async execute(args) {
+                    try {
+                        let files = [];
+                        if (args.id) {
+                            files = await findAgentFilesById(input, args.id);
+                        }
+                        else if (args.agent && args.sessionID) {
+                            files = await findAgentFiles(input, args.agent, args.sessionID);
+                        }
+                        else if (args.sessionID) {
+                            files = await findAgentFiles(input, undefined, args.sessionID);
+                        }
+                        else if (args.agent) {
+                            files = await findAgentFiles(input, args.agent);
+                        }
+                        else {
+                            files = await findAllAgentFiles(input);
+                        }
+                        if (files.length === 0) {
+                            return 'No agent context files found to clear.';
+                        }
+                        for (const file of files) {
+                            try {
+                                await $ `rm ${file}`.quiet();
+                            }
+                            catch {
+                                // Continue even if one file fails
+                            }
+                        }
+                        return `Cleared ${files.length} agent context file(s)`;
+                    }
+                    catch (error) {
+                        return `Error clearing agents: ${error}`;
+                    }
+                },
+            }),
+        },
+    };
+};

package/dist/plugins/ff-agents-current-plugin.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from '@opencode-ai/plugin';
+export declare const FFAgentsCurrentPlugin: Plugin;

package/dist/plugins/ff-agents-current-plugin.js

@@ -0,0 +1,49 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { listActiveAgents } from '../agent-context.js';
+export const FFAgentsCurrentPlugin = async (input) => {
+    return {
+        tool: {
+            'ff-agents-current': tool({
+                description: 'List all currently active Feature Factory agents with their UUIDs and status',
+                args: {
+                    sessionID: tool.schema.string().optional().describe('Filter by specific session ID'),
+                    agent: tool.schema
+                        .string()
+                        .optional()
+                        .describe('Filter by agent type (e.g., planning, research)'),
+                },
+                async execute(args) {
+                    try {
+                        const agents = await listActiveAgents(input, args.sessionID, args.agent);
+                        if (agents.length === 0) {
+                            return JSON.stringify({
+                                count: 0,
+                                message: 'No active agents found',
+                                agents: [],
+                            }, null, 2);
+                        }
+                        return JSON.stringify({
+                            count: agents.length,
+                            agents: agents.map((a) => ({
+                                id: a.id,
+                                agent: a.agent,
+                                title: a.title,
+                                folder: a.folder,
+                                status: a.status,
+                                started: a.started,
+                                session: a.session,
+                                parent: a.parent || null,
+                                delegated_to: a.delegated_to || [],
+                            })),
+                        }, null, 2);
+                    }
+                    catch (error) {
+                        return JSON.stringify({
+                            error: `Failed to list agents: ${error}`,
+                        }, null, 2);
+                    }
+                },
+            }),
+        },
+    };
+};

package/dist/plugins/ff-agents-show-plugin.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from '@opencode-ai/plugin';
+export declare const FFAgentsShowPlugin: Plugin;

package/dist/plugins/ff-agents-show-plugin.js

@@ -0,0 +1,26 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { readAgentContextById } from '../agent-context.js';
+export const FFAgentsShowPlugin = async (input) => {
+    return {
+        tool: {
+            'ff-agents-show': tool({
+                description: 'Show detailed context for a specific agent by UUID',
+                args: {
+                    id: tool.schema.string().describe('Agent UUID to show details for'),
+                },
+                async execute(args) {
+                    try {
+                        const agentContext = await readAgentContextById(input, args.id);
+                        if (!agentContext) {
+                            return `Agent with ID "${args.id}" not found`;
+                        }
+                        return JSON.stringify(agentContext, null, 2);
+                    }
+                    catch (error) {
+                        return `Error reading agent: ${error}`;
+                    }
+                },
+            }),
+        },
+    };
+};

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.16",
   "type": "module",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
   "license": "MIT",

package/dist/agent-management-tools.d.ts

@@ -1,5 +0,0 @@
-import type { PluginInput, Hooks } from '@opencode-ai/plugin';
-/**
- * Create agent management tools for the plugin
- */
-export declare function createAgentManagementTools(input: PluginInput): Partial<Hooks>;

package/dist/agent-management-tools.js

@@ -1,117 +0,0 @@
-import { tool } from '@opencode-ai/plugin';
-import { listActiveAgents, findAgentFiles, findAgentFilesById, findAllAgentFiles, readAgentContextById, } from './agent-context.js';
-/**
- * Create agent management tools for the plugin
- */
-export function createAgentManagementTools(input) {
-    const { $ } = input;
-    return {
-        tool: {
-            'ff-agents-current': tool({
-                description: 'List all currently active Feature Factory agents with their UUIDs and status',
-                args: {
-                    sessionID: tool.schema.string().optional().describe('Filter by specific session ID'),
-                    agent: tool.schema
-                        .string()
-                        .optional()
-                        .describe('Filter by agent type (e.g., planning, research)'),
-                },
-                execute: async (args) => {
-                    try {
-                        const agents = await listActiveAgents(input, args.sessionID, args.agent);
-                        if (agents.length === 0) {
-                            return JSON.stringify({
-                                count: 0,
-                                message: 'No active agents found',
-                                agents: [],
-                            }, null, 2);
-                        }
-                        return JSON.stringify({
-                            count: agents.length,
-                            agents: agents.map((a) => ({
-                                id: a.id,
-                                agent: a.agent,
-                                title: a.title,
-                                folder: a.folder,
-                                status: a.status,
-                                started: a.started,
-                                session: a.session,
-                                parent: a.parent || null,
-                                delegated_to: a.delegated_to || [],
-                            })),
-                        }, null, 2);
-                    }
-                    catch (error) {
-                        return JSON.stringify({
-                            error: `Failed to list agents: ${error}`,
-                        }, null, 2);
-                    }
-                },
-            }),
-            'ff-agents-clear': tool({
-                description: 'Clear agent context files. Can clear all, or filter by session, agent type, or specific UUID',
-                args: {
-                    sessionID: tool.schema
-                        .string()
-                        .optional()
-                        .describe('Clear only agents for specific session'),
-                    agent: tool.schema.string().optional().describe('Clear only specific agent type'),
-                    id: tool.schema.string().optional().describe('Clear specific agent by UUID'),
-                },
-                execute: async (args) => {
-                    try {
-                        let files = [];
-                        if (args.id) {
-                            files = await findAgentFilesById(input, args.id);
-                        }
-                        else if (args.agent && args.sessionID) {
-                            files = await findAgentFiles(input, args.agent, args.sessionID);
-                        }
-                        else if (args.sessionID) {
-                            files = await findAgentFiles(input, undefined, args.sessionID);
-                        }
-                        else if (args.agent) {
-                            files = await findAgentFiles(input, args.agent);
-                        }
-                        else {
-                            files = await findAllAgentFiles(input);
-                        }
-                        if (files.length === 0) {
-                            return 'No agent context files found to clear.';
-                        }
-                        for (const file of files) {
-                            try {
-                                await $ `rm ${file}`.quiet();
-                            }
-                            catch {
-                                // Continue even if one file fails
-                            }
-                        }
-                        return `Cleared ${files.length} agent context file(s)`;
-                    }
-                    catch (error) {
-                        return `Error clearing agents: ${error}`;
-                    }
-                },
-            }),
-            'ff-agents-show': tool({
-                description: 'Show detailed context for a specific agent by UUID',
-                args: {
-                    id: tool.schema.string().describe('Agent UUID to show details for'),
-                },
-                execute: async (args) => {
-                    try {
-                        const agentContext = await readAgentContextById(input, args.id);
-                        if (!agentContext) {
-                            return `Agent with ID "${args.id}" not found`;
-                        }
-                        return JSON.stringify(agentContext, null, 2);
-                    }
-                    catch (error) {
-                        return `Error reading agent: ${error}`;
-                    }
-                },
-            }),
-        },
-    };
-}