@syntesseraai/opencode-feature-factory 0.1.7 → 0.1.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@syntesseraai/opencode-feature-factory",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "OpenCode plugin for Feature Factory agents - provides planning, implementation, review, testing, and validation agents",
   "type": "module",
   "license": "MIT",

package/src/stop-quality-gate.ts

@@ -41,6 +41,87 @@ function getSessionState(sessionId: string): ExtendedSessionState {
   return state;
 }
 
+// ============================================================================
+// Global Execution Lock
+// ============================================================================
+
+/**
+ * Global lock to prevent concurrent quality gate executions.
+ * This prevents multiple builds from running simultaneously when
+ * multiple session.idle events fire in quick succession.
+ */
+interface ExecutionLock {
+  /** Whether a quality gate is currently running */
+  isRunning: boolean;
+  /** Session ID that holds the lock */
+  heldBy: string | null;
+  /** Timestamp when the lock was acquired */
+  acquiredAt: number;
+  /** Queue of sessions waiting to run */
+  queue: string[];
+}
+
+const executionLock: ExecutionLock = {
+  isRunning: false,
+  heldBy: null,
+  acquiredAt: 0,
+  queue: [],
+};
+
+/** Maximum time a lock can be held before it's considered stale (5 minutes) */
+const LOCK_TIMEOUT_MS = 5 * 60 * 1000;
+
+/**
+ * Attempt to acquire the execution lock.
+ * Returns true if lock acquired, false if another execution is in progress.
+ */
+function tryAcquireLock(sessionId: string): boolean {
+  const now = Date.now();
+
+  // Check for stale lock (process crashed or hung)
+  if (executionLock.isRunning && now - executionLock.acquiredAt > LOCK_TIMEOUT_MS) {
+    // Force release stale lock
+    executionLock.isRunning = false;
+    executionLock.heldBy = null;
+  }
+
+  if (executionLock.isRunning) {
+    // Add to queue if not already queued
+    if (!executionLock.queue.includes(sessionId)) {
+      executionLock.queue.push(sessionId);
+    }
+    return false;
+  }
+
+  executionLock.isRunning = true;
+  executionLock.heldBy = sessionId;
+  executionLock.acquiredAt = now;
+  return true;
+}
+
+/**
+ * Release the execution lock and return the next session in queue (if any).
+ */
+function releaseLock(sessionId: string): string | null {
+  // Only release if we hold the lock
+  if (executionLock.heldBy !== sessionId) {
+    return null;
+  }
+
+  executionLock.isRunning = false;
+  executionLock.heldBy = null;
+
+  // Return next session in queue
+  return executionLock.queue.shift() ?? null;
+}
+
+/**
+ * Check if the lock is currently held (for logging/debugging)
+ */
+function _isLockHeld(): boolean {
+  return executionLock.isRunning;
+}
+
 // ============================================================================
 // Prompt Builders
 // ============================================================================
@@ -229,10 +310,18 @@ export async function createQualityGateHooks(input: PluginInput): Promise<Partia
   const cwd = qualityGate.cwd ? `${directory}/${qualityGate.cwd}` : directory;
 
   /**
-   * Run the quality gate checks for a session
+   * Run the quality gate checks for a session.
+   * Uses a global lock to prevent concurrent executions.
    */
   async function runQualityGate(sessionId: string): Promise<void> {
     const state = getSessionState(sessionId);
+
+    // Check if session was deleted while waiting
+    if (!sessions.has(sessionId)) {
+      await log(client, 'debug', 'quality-gate.skipped (session deleted)', { sessionId });
+      return;
+    }
+
     const now = Date.now();
     const cacheExpired = now - state.lastRunAt > cacheSeconds * 1000;
 
@@ -242,96 +331,126 @@ export async function createQualityGateHooks(input: PluginInput): Promise<Partia
       return;
     }
 
-    // Log start
-    await log(client, 'info', 'quality-gate.started', {
-      sessionId,
-      directory,
-      cwd,
-    });
-
-    // Resolve commands
-    const plan = await resolveCommands({ $, directory, config: qualityGate });
+    // Try to acquire the global execution lock
+    if (!tryAcquireLock(sessionId)) {
+      await log(client, 'debug', 'quality-gate.queued (another run in progress)', {
+        sessionId,
+        heldBy: executionLock.heldBy,
+        queuePosition: executionLock.queue.indexOf(sessionId) + 1,
+      });
+      return; // Will be triggered again when current run completes
+    }
 
-    // No commands found - log warning but don't block
-    if (plan.length === 0) {
-      await log(client, 'warn', 'quality-gate.no_commands', {
+    try {
+      // Log start
+      await log(client, 'info', 'quality-gate.started', {
         sessionId,
         directory,
+        cwd,
       });
 
-      // Only prompt once per session about missing config
-      if (!state.qualityGatePassed) {
-        await client.session.prompt({
-          path: { id: sessionId },
-          body: {
-            parts: [{ type: 'text', text: buildNoCommandsPrompt({ directory }) }],
-          },
+      // Resolve commands
+      const plan = await resolveCommands({ $, directory, config: qualityGate });
+
+      // No commands found - log warning but don't block
+      if (plan.length === 0) {
+        await log(client, 'warn', 'quality-gate.no_commands', {
+          sessionId,
+          directory,
         });
+
+        // Only prompt once per session about missing config
+        if (!state.qualityGatePassed) {
+          await client.session.prompt({
+            path: { id: sessionId },
+            body: {
+              parts: [{ type: 'text', text: buildNoCommandsPrompt({ directory }) }],
+            },
+          });
+        }
+        return;
       }
-      return;
-    }
 
-    // Run commands if dirty, cache expired, or no cached results
-    let results: StepResult[] = state.lastResults;
+      // Run commands if dirty, cache expired, or no cached results
+      let results: StepResult[] = state.lastResults;
+
+      if (state.dirty || cacheExpired || results.length === 0) {
+        const startTime = Date.now();
+        results = await runAllCommands($, plan, cwd);
+        const durationMs = Date.now() - startTime;
+
+        state.lastResults = results;
+        state.lastRunAt = Date.now(); // Use fresh timestamp after execution
+        state.dirty = false;
+
+        // Log execution details
+        await log(client, 'debug', 'quality-gate.executed', {
+          sessionId,
+          plan: plan.map((p) => p.step),
+          durationMs,
+          results: results.map((r) => ({
+            step: r.step,
+            exitCode: r.exitCode,
+          })),
+        });
+      }
 
-    if (state.dirty || cacheExpired || results.length === 0) {
-      const startTime = Date.now();
-      results = await runAllCommands($, plan, cwd);
-      const durationMs = Date.now() - startTime;
+      // Check for failures
+      const failed = results.find((r) => r.exitCode !== 0);
 
-      state.lastResults = results;
-      state.lastRunAt = now;
-      state.dirty = false;
+      if (failed) {
+        state.qualityGatePassed = false;
 
-      // Log execution details
-      await log(client, 'debug', 'quality-gate.executed', {
-        sessionId,
-        plan: plan.map((p) => p.step),
-        durationMs,
-        results: results.map((r) => ({
-          step: r.step,
-          exitCode: r.exitCode,
-        })),
-      });
-    }
+        // Log failure
+        await log(client, 'error', 'quality-gate.failed', {
+          sessionId,
+          step: failed.step,
+          cmd: failed.cmd,
+          exitCode: failed.exitCode,
+          outputTail: tailLines(failed.output, 50),
+        });
 
-    // Check for failures
-    const failed = results.find((r) => r.exitCode !== 0);
+        // Prompt agent with failure details to continue working
+        await client.session.prompt({
+          path: { id: sessionId },
+          body: {
+            parts: [
+              {
+                type: 'text',
+                text: buildFailurePrompt({ config: qualityGate, failed }),
+              },
+            ],
+          },
+        });
+        return;
+      }
 
-    if (failed) {
-      state.qualityGatePassed = false;
+      // All passed
+      state.qualityGatePassed = true;
 
-      // Log failure
-      await log(client, 'error', 'quality-gate.failed', {
+      await log(client, 'info', 'quality-gate.passed', {
         sessionId,
-        step: failed.step,
-        cmd: failed.cmd,
-        exitCode: failed.exitCode,
-        outputTail: tailLines(failed.output, 50),
-      });
-
-      // Prompt agent with failure details to continue working
-      await client.session.prompt({
-        path: { id: sessionId },
-        body: {
-          parts: [
-            {
-              type: 'text',
-              text: buildFailurePrompt({ config: qualityGate, failed }),
-            },
-          ],
-        },
+        steps: results.map((r) => r.step),
       });
-      return;
+    } finally {
+      // Always release the lock and trigger next queued session
+      const nextSession = releaseLock(sessionId);
+      if (nextSession) {
+        await log(client, 'debug', 'quality-gate.triggering-next', {
+          sessionId,
+          nextSession,
+        });
+        // Schedule the next session's run (don't await to avoid blocking)
+        setTimeout(() => {
+          runQualityGate(nextSession).catch((err) => {
+            log(client, 'error', 'quality-gate.queue-error', {
+              sessionId: nextSession,
+              error: String(err),
+            });
+          });
+        }, 100);
+      }
     }
-
-    // All passed
-    state.qualityGatePassed = true;
-
-    await log(client, 'info', 'quality-gate.passed', {
-      sessionId,
-      steps: results.map((r) => r.step),
-    });
   }
 
   return {
@@ -365,6 +484,12 @@ export async function createQualityGateHooks(input: PluginInput): Promise<Partia
       if (event.type === 'session.idle' && sessionId) {
         const state = getSessionState(sessionId);
 
+        // Skip if this session already holds the lock (already running)
+        if (executionLock.heldBy === sessionId) {
+          await log(client, 'debug', 'quality-gate.skipped (already running)', { sessionId });
+          return;
+        }
+
         // Debounce to avoid running multiple times
         if (state.idleDebounce) {
           clearTimeout(state.idleDebounce);
@@ -372,7 +497,17 @@ export async function createQualityGateHooks(input: PluginInput): Promise<Partia
 
         state.idleDebounce = setTimeout(async () => {
           state.idleDebounce = null;
-          await runQualityGate(sessionId);
+          // Double-check session still exists before running
+          if (sessions.has(sessionId)) {
+            try {
+              await runQualityGate(sessionId);
+            } catch (err) {
+              await log(client, 'error', 'quality-gate.unhandled-error', {
+                sessionId,
+                error: String(err),
+              });
+            }
+          }
         }, IDLE_DEBOUNCE_MS);
       }
     },