claudecode-omc 4.5.7 → 4.8.0

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));

package/scripts/run-provider-advisor.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import { spawnSync } from 'child_process';
+import { mkdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import process from 'process';
+
+const PROVIDER_BINARIES = {
+  claude: 'claude',
+  codex: 'codex',
+  gemini: 'gemini',
+};
+
+/**
+ * Build CLI args for a given provider.
+ * - claude: `claude -p <prompt>`
+ * - codex: `codex exec --dangerously-bypass-approvals-and-sandbox <prompt>`
+ * - gemini: `gemini -p <prompt> --yolo`
+ */
+function buildProviderArgs(provider, prompt) {
+  if (provider === 'codex') {
+    return ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt];
+  }
+  if (provider === 'gemini') {
+    return ['-p', prompt, '--yolo'];
+  }
+  return ['-p', prompt];
+}
+
+const ASK_ORIGINAL_TASK_ENV = 'OMC_ASK_ORIGINAL_TASK';
+const ASK_ORIGINAL_TASK_ENV_ALIAS = 'OMX_ASK_ORIGINAL_TASK';
+
+function usage() {
+  console.error('Usage: omc ask <claude|codex|gemini> "<prompt>"');
+  console.error('Legacy direct usage: node scripts/run-provider-advisor.js <claude|codex|gemini> <prompt...>');
+  console.error('                 or: node scripts/run-provider-advisor.js claude --print "<prompt>"');
+  console.error('                 or: node scripts/run-provider-advisor.js gemini --prompt "<prompt>"');
+}
+
+function slugify(value) {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60) || 'task';
+}
+
+function timestampToken(date = new Date()) {
+  return date.toISOString().replace(/[:.]/g, '-');
+}
+
+function parseArgs(argv) {
+  const [providerRaw, ...rest] = argv;
+  const provider = (providerRaw || '').toLowerCase();
+
+  if (!provider || !(provider in PROVIDER_BINARIES)) {
+    usage();
+    process.exit(1);
+  }
+
+  if (rest.length === 0) {
+    usage();
+    process.exit(1);
+  }
+
+  if (rest[0] === '-p' || rest[0] === '--print' || rest[0] === '--prompt') {
+    const prompt = rest.slice(1).join(' ').trim();
+    if (!prompt) {
+      usage();
+      process.exit(1);
+    }
+    return { provider, prompt };
+  }
+
+  return { provider, prompt: rest.join(' ').trim() };
+}
+
+function ensureBinary(binary) {
+  const probe = spawnSync(binary, ['--version'], {
+    stdio: 'ignore',
+    encoding: 'utf8',
+  });
+
+  if (probe.error && probe.error.code === 'ENOENT') {
+    const verify = `${binary} --version`;
+    console.error(`[ask-${binary}] Missing required local CLI binary: ${binary}`);
+    console.error(`[ask-${binary}] Install/configure ${binary} CLI, then verify with: ${verify}`);
+    process.exit(1);
+  }
+}
+
+function buildSummary(exitCode, output) {
+  if (exitCode === 0) {
+    return 'Provider completed successfully. Review the raw output for details.';
+  }
+
+  const firstLine = output
+    .split('\n')
+    .map((line) => line.trim())
+    .find(Boolean);
+
+  return firstLine
+    ? `Provider command failed (exit ${exitCode}): ${firstLine}`
+    : `Provider command failed with exit code ${exitCode}.`;
+}
+
+function buildActionItems(exitCode) {
+  if (exitCode === 0) {
+    return [
+      'Review the response and extract decisions you want to apply.',
+      'Capture follow-up implementation tasks if needed.',
+    ];
+  }
+
+  return [
+    'Inspect the raw output error details.',
+    'Fix CLI/auth/environment issues and rerun the command.',
+  ];
+}
+
+function resolveOriginalTask(prompt) {
+  const canonical = process.env[ASK_ORIGINAL_TASK_ENV];
+  if (canonical && canonical.trim()) {
+    return canonical;
+  }
+
+  const alias = process.env[ASK_ORIGINAL_TASK_ENV_ALIAS];
+  if (alias && alias.trim()) {
+    console.error(`[ask] DEPRECATED: ${ASK_ORIGINAL_TASK_ENV_ALIAS} is deprecated; use ${ASK_ORIGINAL_TASK_ENV} instead.`);
+    return alias;
+  }
+
+  return prompt;
+}
+
+async function writeArtifact({ provider, originalTask, finalPrompt, rawOutput, exitCode }) {
+  const root = process.cwd();
+  const artifactDir = join(root, '.omc', 'artifacts', 'ask');
+  const slug = slugify(originalTask);
+  const timestamp = timestampToken();
+  const artifactPath = join(artifactDir, `${provider}-${slug}-${timestamp}.md`);
+
+  const summary = buildSummary(exitCode, rawOutput);
+  const actionItems = buildActionItems(exitCode);
+
+  const body = [
+    `# ${provider} advisor artifact`,
+    '',
+    `- Provider: ${provider}`,
+    `- Exit code: ${exitCode}`,
+    `- Created at: ${new Date().toISOString()}`,
+    '',
+    '## Original task',
+    '',
+    originalTask,
+    '',
+    '## Final prompt',
+    '',
+    finalPrompt,
+    '',
+    '## Raw output',
+    '',
+    '```text',
+    rawOutput || '(no output)',
+    '```',
+    '',
+    '## Concise summary',
+    '',
+    summary,
+    '',
+    '## Action items',
+    '',
+    ...actionItems.map((item) => `- ${item}`),
+    '',
+  ].join('\n');
+
+  await mkdir(artifactDir, { recursive: true });
+  await writeFile(artifactPath, body, 'utf8');
+  return artifactPath;
+}
+
+async function main() {
+  const { provider, prompt } = parseArgs(process.argv.slice(2));
+  const binary = PROVIDER_BINARIES[provider];
+
+  ensureBinary(binary);
+
+  const providerArgs = buildProviderArgs(provider, prompt);
+  const run = spawnSync(binary, providerArgs, {
+    encoding: 'utf8',
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  const stdout = run.stdout || '';
+  const stderr = run.stderr || '';
+  const rawOutput = [stdout, stderr].filter(Boolean).join(stdout && stderr ? '\n\n' : '');
+  const exitCode = typeof run.status === 'number' ? run.status : 1;
+
+  const artifactPath = await writeArtifact({
+    provider,
+    originalTask: resolveOriginalTask(prompt),
+    finalPrompt: prompt,
+    rawOutput,
+    exitCode,
+  });
+
+  console.log(artifactPath);
+
+  if (run.error) {
+    console.error(`[ask-${provider}] ${run.error.message}`);
+  }
+
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+
+main().catch((error) => {
+  console.error(`[run-provider-advisor] ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});