claudecode-omc 4.5.7 → 4.7.4

package/scripts/persistent-mode.cjs

@@ -150,6 +150,41 @@ function isStaleState(state) {
   return age > STALE_STATE_THRESHOLD_MS;
 }
 
+/**
+ * Check if a cancel signal is in progress for the session.
+ * Cancel signals are written by state_clear and expire after 30 seconds.
+ * @param {string} stateDir - The .omc/state directory path
+ * @param {string} sessionId - Optional session ID
+ * @returns {boolean} true if cancel is in progress
+ */
+function isSessionCancelInProgress(stateDir, sessionId) {
+  const CANCEL_SIGNAL_TTL_MS = 30000; // 30 seconds
+
+  // Try session-scoped path first
+  if (sessionId) {
+    const sessionSignalPath = join(stateDir, 'sessions', sessionId, 'cancel-signal-state.json');
+    const signal = readJsonFile(sessionSignalPath);
+    if (signal && signal.expires_at) {
+      const expiresAt = new Date(signal.expires_at).getTime();
+      if (Date.now() < expiresAt) {
+        return true;
+      }
+    }
+  }
+
+  // Fall back to legacy path
+  const legacySignalPath = join(stateDir, 'cancel-signal-state.json');
+  const signal = readJsonFile(legacySignalPath);
+  if (signal && signal.expires_at) {
+    const expiresAt = new Date(signal.expires_at).getTime();
+    if (Date.now() < expiresAt) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 /**
  * Normalize a path for comparison.
  */
@@ -373,6 +408,38 @@ function isUserAbort(data) {
   );
 }
 
+const AUTHENTICATION_ERROR_PATTERNS = [
+  "authentication_error",
+  "authentication_failed",
+  "auth_error",
+  "unauthorized",
+  "unauthorised",
+  "401",
+  "403",
+  "forbidden",
+  "invalid_token",
+  "token_invalid",
+  "token_expired",
+  "expired_token",
+  "oauth_expired",
+  "oauth_token_expired",
+  "invalid_grant",
+  "insufficient_scope",
+];
+
+function isAuthenticationError(data) {
+  const reason = (data.stop_reason || data.stopReason || "").toLowerCase();
+  const endTurnReason = (
+    data.end_turn_reason ||
+    data.endTurnReason ||
+    ""
+  ).toLowerCase();
+
+  return AUTHENTICATION_ERROR_PATTERNS.some(
+    (pattern) => reason.includes(pattern) || endTurnReason.includes(pattern),
+  );
+}
+
 async function main() {
   try {
     const input = await readStdin();
@@ -399,6 +466,12 @@ async function main() {
       return;
     }
 
+    // Never block auth failures (401/403/expired OAuth): allow re-auth flow.
+    if (isAuthenticationError(data)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
     // Read all mode states (session-scoped with legacy fallback)
     const ralph = readStateFileWithSession(stateDir, "ralph-state.json", sessionId);
     const autopilot = readStateFileWithSession(stateDir, "autopilot-state.json", sessionId);
@@ -407,6 +480,7 @@ async function main() {
     const ultraqa = readStateFileWithSession(stateDir, "ultraqa-state.json", sessionId);
     const pipeline = readStateFileWithSession(stateDir, "pipeline-state.json", sessionId);
     const team = readStateFileWithSession(stateDir, "team-state.json", sessionId);
+    const omcTeams = readStateFileWithSession(stateDir, "omc-teams-state.json", sessionId);
 
     // Swarm uses swarm-summary.json (not swarm-state.json) + marker file
     const swarmMarker = existsSync(join(stateDir, "swarm-active.marker"));
@@ -417,6 +491,12 @@ async function main() {
     const todoCount = countIncompleteTodos(sessionId, directory);
     const totalIncomplete = taskCount + todoCount;
 
+    // Check if cancel is in progress - if so, allow stop immediately
+    if (isSessionCancelInProgress(stateDir, sessionId)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
     // Priority 1: Ralph Loop (explicit persistence mode)
     // Skip if state is stale (older than 2 hours) - prevents blocking new sessions
     if (ralph.state?.active && !isStaleState(ralph.state) && isSessionMatch(ralph.state, sessionId)) {
@@ -542,7 +622,7 @@ async function main() {
       }
     }
 
-    // Priority 6: Team (omc-teams / staged pipeline)
+    // Priority 6: Team (native Claude Code teams)
     if (team.state?.active && !isStaleState(team.state) && isSessionMatch(team.state, sessionId)) {
       const phase = team.state.current_phase || "executing";
       const terminalPhases = ["completed", "complete", "failed", "cancelled"];
@@ -567,6 +647,31 @@ async function main() {
       }
     }
 
+    // Priority 6.5: OMC Teams (tmux CLI workers — independent of native team state)
+    if (omcTeams.state?.active && !isStaleState(omcTeams.state) && isSessionMatch(omcTeams.state, sessionId)) {
+      const phase = omcTeams.state.current_phase || "executing";
+      const terminalPhases = ["completed", "complete", "failed", "cancelled"];
+      if (!terminalPhases.includes(phase)) {
+        const newCount = (omcTeams.state.reinforcement_count || 0) + 1;
+        if (newCount <= 20) {
+          omcTeams.state.reinforcement_count = newCount;
+          omcTeams.state.last_checked_at = new Date().toISOString();
+          writeJsonFile(omcTeams.path, omcTeams.state);
+
+          // Fire-and-forget notification
+          sendStopNotification('omc-teams', omcTeams.state, sessionId, directory).catch(() => {});
+
+          console.log(
+            JSON.stringify({
+              decision: "block",
+              reason: `[OMC TEAMS - Phase: ${phase}] OMC Teams workers active. Continue working. When all workers complete, run /oh-my-claudecode:cancel to cleanly exit. If cancel fails, retry with /oh-my-claudecode:cancel --force.`,
+            }),
+          );
+          return;
+        }
+      }
+    }
+
     // Priority 7: UltraQA (QA cycling)
     if (ultraqa.state?.active && !isStaleState(ultraqa.state) && isSessionMatch(ultraqa.state, sessionId)) {
       const cycle = ultraqa.state.cycle || 1;

package/scripts/persistent-mode.mjs

@@ -378,6 +378,38 @@ function isUserAbort(data) {
   );
 }
 
+const AUTHENTICATION_ERROR_PATTERNS = [
+  "authentication_error",
+  "authentication_failed",
+  "auth_error",
+  "unauthorized",
+  "unauthorised",
+  "401",
+  "403",
+  "forbidden",
+  "invalid_token",
+  "token_invalid",
+  "token_expired",
+  "expired_token",
+  "oauth_expired",
+  "oauth_token_expired",
+  "invalid_grant",
+  "insufficient_scope",
+];
+
+function isAuthenticationError(data) {
+  const reason = (data.stop_reason || data.stopReason || "").toLowerCase();
+  const endTurnReason = (
+    data.end_turn_reason ||
+    data.endTurnReason ||
+    ""
+  ).toLowerCase();
+
+  return AUTHENTICATION_ERROR_PATTERNS.some(
+    (pattern) => reason.includes(pattern) || endTurnReason.includes(pattern),
+  );
+}
+
 async function main() {
   try {
     const input = await readStdin();
@@ -407,6 +439,12 @@ async function main() {
       return;
     }
 
+    // Never block auth failures (401/403/expired OAuth): allow re-auth flow.
+    if (isAuthenticationError(data)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
     // Read all mode states (session-scoped when sessionId provided)
     const ralph = readStateFileWithSession(
       stateDir,
@@ -450,6 +488,12 @@ async function main() {
       "team-state.json",
       sessionId,
     );
+    const omcTeams = readStateFileWithSession(
+      stateDir,
+      globalStateDir,
+      "omc-teams-state.json",
+      sessionId,
+    );
 
     // Swarm uses swarm-summary.json (not swarm-state.json) + marker file
     const swarmMarker = existsSync(join(stateDir, "swarm-active.marker"));
@@ -489,6 +533,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
+              continue: false,
               decision: "block",
               reason,
             }),
@@ -503,6 +548,7 @@ async function main() {
 
         console.log(
           JSON.stringify({
+            continue: false,
             decision: "block",
             reason: `[RALPH LOOP - EXTENDED] Max iterations reached; extending to ${ralph.state.max_iterations} and continuing. When FULLY complete (after Architect verification), run /oh-my-claudecode:cancel (or --force).`,
           }),
@@ -539,6 +585,7 @@ async function main() {
 
             console.log(
               JSON.stringify({
+                continue: false,
                 decision: "block",
                 reason,
               }),
@@ -579,6 +626,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
+              continue: false,
               decision: "block",
               reason,
             }),
@@ -614,6 +662,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
+              continue: false,
               decision: "block",
               reason,
             }),
@@ -651,6 +700,7 @@ async function main() {
 
           console.log(
             JSON.stringify({
+              continue: false,
               decision: "block",
               reason,
             }),
@@ -660,7 +710,7 @@ async function main() {
       }
     }
 
-    // Priority 6: Team (omc-teams / staged pipeline)
+    // Priority 6: Team (native Claude Code teams / staged pipeline)
     if (
       team.state?.active &&
       !isStaleState(team.state) &&
@@ -689,6 +739,7 @@ async function main() {
 
             console.log(
               JSON.stringify({
+                continue: false,
                 decision: "block",
                 reason,
               }),
@@ -699,6 +750,40 @@ async function main() {
       }
     }
 
+    // Priority 6.5: OMC Teams (tmux CLI workers — independent of native team state)
+    if (
+      omcTeams.state?.active &&
+      !isStaleState(omcTeams.state) &&
+      isStateForCurrentProject(omcTeams.state, directory, omcTeams.isGlobal)
+    ) {
+      const sessionMatches = hasValidSessionId
+        ? omcTeams.state.session_id === sessionId
+        : !omcTeams.state.session_id || omcTeams.state.session_id === sessionId;
+      if (sessionMatches) {
+        const phase = omcTeams.state.current_phase || "executing";
+        const terminalPhases = ["completed", "complete", "failed", "cancelled"];
+        if (!terminalPhases.includes(phase)) {
+          const newCount = (omcTeams.state.reinforcement_count || 0) + 1;
+          if (newCount <= 20) {
+            const toolError = readLastToolError(stateDir);
+            const errorGuidance = getToolErrorRetryGuidance(toolError);
+
+            omcTeams.state.reinforcement_count = newCount;
+            omcTeams.state.last_checked_at = new Date().toISOString();
+            writeJsonFile(omcTeams.path, omcTeams.state);
+
+            let reason = `[OMC TEAMS - Phase: ${phase}] OMC Teams workers active. Continue working. When all workers complete, run /oh-my-claudecode:cancel to cleanly exit. If cancel fails, retry with /oh-my-claudecode:cancel --force.`;
+            if (errorGuidance) {
+              reason = errorGuidance + reason;
+            }
+
+            console.log(JSON.stringify({ continue: false, decision: "block", reason }));
+            return;
+          }
+        }
+      }
+    }
+
     // Priority 7: UltraQA (QA cycling)
     if (
       ultraqa.state?.active &&
@@ -725,6 +810,7 @@ async function main() {
 
         console.log(
           JSON.stringify({
+            continue: false,
             decision: "block",
             reason,
           }),
@@ -783,7 +869,7 @@ async function main() {
         reason = errorGuidance + reason;
       }
 
-      console.log(JSON.stringify({ decision: "block", reason }));
+      console.log(JSON.stringify({ continue: false, decision: "block", reason }));
       return;
     }
 

package/scripts/plugin-setup.mjs

@@ -6,6 +6,7 @@
  */
 
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, chmodSync } from 'node:fs';
+import { execSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -57,6 +58,7 @@ function semverCompare(a, b) {
 
 async function main() {
   const home = homedir();
+  let pluginCacheDir = null;
 
   // 1. Try plugin cache first (marketplace: omc, plugin: oh-my-claudecode)
   // Respect CLAUDE_CONFIG_DIR so installs under a custom config dir are found
@@ -66,13 +68,17 @@ async function main() {
     try {
       const versions = readdirSync(pluginCacheBase);
       if (versions.length > 0) {
+        const sortedVersions = versions.sort(semverCompare).reverse();
+        pluginCacheDir = join(pluginCacheBase, sortedVersions[0]);
+
         // Filter to only versions with built dist/hud/index.js
-        const builtVersions = versions.filter(v => {
+        const builtVersions = sortedVersions.filter(v => {
           const hudPath = join(pluginCacheBase, v, "dist/hud/index.js");
           return existsSync(hudPath);
         });
         if (builtVersions.length > 0) {
-          const latestBuilt = builtVersions.sort(semverCompare).reverse()[0];
+          const latestBuilt = builtVersions[0];
+          pluginCacheDir = join(pluginCacheBase, latestBuilt);
           const pluginPath = join(pluginCacheBase, latestBuilt, "dist/hud/index.js");
           await import(pathToFileURL(pluginPath).href);
           return;
@@ -98,8 +104,19 @@ async function main() {
     }
   }
 
-  // 3. Fallback
-  console.log("[OMC] run /omc-setup to install properly");
+  // 3. Fallback: provide targeted repair guidance
+  if (pluginCacheDir && existsSync(pluginCacheDir)) {
+    const distDir = join(pluginCacheDir, "dist");
+    if (!existsSync(distDir)) {
+      console.log(\`[OMC HUD] Plugin installed but not built. Run: cd "\${pluginCacheDir}" && npm install && npm run build\`);
+    } else {
+      console.log(\`[OMC HUD] Plugin HUD load failed. Run: cd "\${pluginCacheDir}" && npm install && npm run build\`);
+    }
+  } else if (existsSync(pluginCacheBase)) {
+    console.log("[OMC HUD] Plugin cache found but no versions installed. Run: /oh-my-claudecode:omc-setup");
+  } else {
+    console.log("[OMC HUD] Plugin not installed. Run: /oh-my-claudecode:omc-setup");
+  }
 }
 
 main();
@@ -208,4 +225,29 @@ try {
   console.log('[OMC] Warning: Could not patch hooks.json:', e.message);
 }
 
+// 5. Ensure runtime dependencies are installed in the plugin cache directory.
+//    The npm-published tarball includes only the files listed in "files" (package.json),
+//    which does NOT include node_modules.  When Claude Code extracts the plugin into its
+//    cache the dependencies are therefore missing, causing ERR_MODULE_NOT_FOUND at runtime.
+//    We detect this by probing for a known production dependency (commander) and running a
+//    production-only install when it is absent.  --ignore-scripts avoids re-triggering this
+//    very setup script (and any other lifecycle hooks).  Fixes #1113.
+const packageDir = join(__dirname, '..');
+const commanderCheck = join(packageDir, 'node_modules', 'commander');
+if (!existsSync(commanderCheck)) {
+  console.log('[OMC] Installing runtime dependencies...');
+  try {
+    execSync('npm install --omit=dev --ignore-scripts', {
+      cwd: packageDir,
+      stdio: 'pipe',
+      timeout: 60000,
+    });
+    console.log('[OMC] Runtime dependencies installed successfully');
+  } catch (e) {
+    console.log('[OMC] Warning: Could not install dependencies:', e.message);
+  }
+} else {
+  console.log('[OMC] Runtime dependencies already present');
+}
+
 console.log('[OMC] Setup complete! Restart Claude Code to activate HUD.');

package/scripts/pre-tool-enforcer.mjs

@@ -20,6 +20,7 @@ const MODE_STATE_FILES = [
   'ultraqa-state.json',
   'pipeline-state.json',
   'team-state.json',
+  'omc-teams-state.json',
 ];
 
 // Simple JSON field extraction

package/scripts/qa-tests/test-custom-integration.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+/**
+ * QA Test: Custom Integration System
+ * 
+ * Run with: node scripts/qa-tests/test-custom-integration.mjs
+ * 
+ * Tests the actual dispatch code with real HTTP requests
+ * to verify webhook and CLI integrations work end-to-end.
+ */
+
+import http from 'http';
+import { sendCustomWebhook, sendCustomCli } from '../../dist/notifications/dispatcher.js';
+
+const PORT = 3458;
+let receivedRequest = null;
+
+// Create test server
+const server = http.createServer((req, res) => {
+  let body = '';
+  req.on('data', chunk => body += chunk);
+  req.on('end', () => {
+    receivedRequest = { method: req.method, headers: req.headers, body };
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: true }));
+  });
+});
+
+async function runTests() {
+  return new Promise((resolve) => {
+    server.listen(PORT, async () => {
+      console.log('🧪 QA Test: Custom Integration System\n');
+      let passed = 0;
+      let failed = 0;
+      
+      const testPayload = {
+        event: 'session-end',
+        sessionId: 'qa-test-session',
+        projectName: 'qa-test-project',
+        projectPath: '/home/test/project',
+        timestamp: new Date().toISOString(),
+        durationMs: 45000,
+        agentsSpawned: 3,
+        agentsCompleted: 3,
+        reason: 'completed',
+        message: 'QA test message'
+      };
+
+      // Test 1: Webhook dispatch with template interpolation
+      console.log('Test 1: Webhook dispatch with template interpolation');
+      receivedRequest = null;
+      const webhookIntegration = {
+        id: 'qa-webhook',
+        type: 'webhook',
+        enabled: true,
+        config: {
+          url: `http://localhost:${PORT}/webhook`,
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          bodyTemplate: JSON.stringify({
+            event: '{{event}}',
+            sessionId: '{{sessionId}}',
+            projectName: '{{projectName}}',
+            timestamp: '{{timestamp}}'
+          }),
+          timeout: 5000
+        },
+        events: ['session-end']
+      };
+
+      const webhookResult = await sendCustomWebhook(webhookIntegration, testPayload);
+      if (webhookResult.success && receivedRequest) {
+        try {
+          const body = JSON.parse(receivedRequest.body);
+          if (body.event === 'session-end' && body.sessionId === 'qa-test-session') {
+            console.log('  ✅ PASS - Template interpolation working');
+            passed++;
+          } else {
+            console.log('  ❌ FAIL - Template values incorrect');
+            failed++;
+          }
+        } catch {
+          console.log('  ❌ FAIL - Could not parse body');
+          failed++;
+        }
+      } else {
+        console.log('  ❌ FAIL - Request failed:', webhookResult.error);
+        failed++;
+      }
+
+      // Test 2: CLI dispatch with echo
+      console.log('\nTest 2: CLI command execution');
+      const cliIntegration = {
+        id: 'qa-cli',
+        type: 'cli',
+        enabled: true,
+        config: {
+          command: 'echo',
+          args: ['Event={{event}}', 'Project={{projectName}}'],
+          timeout: 5000
+        },
+        events: ['session-end']
+      };
+
+      const cliResult = await sendCustomCli(cliIntegration, testPayload);
+      if (cliResult.success) {
+        console.log('  ✅ PASS - CLI command executed');
+        passed++;
+      } else {
+        console.log('  ❌ FAIL - CLI error:', cliResult.error);
+        failed++;
+      }
+
+      // Test 3: Webhook with custom headers
+      console.log('\nTest 3: Webhook with custom headers');
+      receivedRequest = null;
+      const headerIntegration = {
+        ...webhookIntegration,
+        config: {
+          ...webhookIntegration.config,
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Custom-Header': 'test-value',
+            'Authorization': 'Bearer test-token'
+          }
+        }
+      };
+
+      const headerResult = await sendCustomWebhook(headerIntegration, testPayload);
+      if (headerResult.success && receivedRequest?.headers['x-custom-header'] === 'test-value') {
+        console.log('  ✅ PASS - Custom headers working');
+        passed++;
+      } else {
+        console.log('  ❌ FAIL - Headers not received correctly');
+        failed++;
+      }
+
+      console.log(`\n📊 Results: ${passed} passed, ${failed} failed`);
+      server.close();
+      resolve(failed === 0);
+    });
+  });
+}
+
+runTests().then((success) => process.exit(success ? 0 : 1));