@stanco323/oh-my-claude-code 4.10.3

package/scripts/plugin-setup.mjs

@@ -0,0 +1,338 @@
+#!/usr/bin/env node
+/**
+ * Plugin Post-Install Setup
+ *
+ * Configures HUD statusline when plugin is installed.
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, chmodSync } from 'node:fs';
+import { execFileSync, execSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+const HUD_DIR = join(CLAUDE_DIR, 'hud');
+const SETTINGS_FILE = join(CLAUDE_DIR, 'settings.json');
+
+console.log('[OMC] Running post-install setup...');
+
+// 1. Create HUD directory
+if (!existsSync(HUD_DIR)) {
+  mkdirSync(HUD_DIR, { recursive: true });
+}
+
+// 2. Create HUD wrapper script
+const hudScriptPath = join(HUD_DIR, 'omc-hud.mjs').replace(/\\/g, '/');
+const hudScript = `#!/usr/bin/env node
+/**
+ * OMC HUD - Statusline Script
+ * Wrapper that imports from plugin cache or development paths
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// Semantic version comparison: returns negative if a < b, positive if a > b, 0 if equal
+function semverCompare(a, b) {
+  // Use parseInt to handle pre-release suffixes (e.g. "0-beta" -> 0)
+  const pa = a.replace(/^v/, "").split(".").map(s => parseInt(s, 10) || 0);
+  const pb = b.replace(/^v/, "").split(".").map(s => parseInt(s, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] || 0;
+    const nb = pb[i] || 0;
+    if (na !== nb) return na - nb;
+  }
+  // If numeric parts equal, non-pre-release > pre-release
+  const aHasPre = /-/.test(a);
+  const bHasPre = /-/.test(b);
+  if (aHasPre && !bHasPre) return -1;
+  if (!aHasPre && bHasPre) return 1;
+  return 0;
+}
+
+function uniquePaths(paths) {
+  return [...new Set(paths.filter(Boolean).map(candidate => resolve(candidate)))];
+}
+
+function getGlobalNodeModuleRoots() {
+  const roots = [];
+  const addPrefixRoots = (prefix) => {
+    if (!prefix) return;
+    if (process.platform === 'win32') {
+      roots.push(join(prefix, 'node_modules'));
+      return;
+    }
+    roots.push(join(prefix, 'lib', 'node_modules'));
+    roots.push(join(prefix, 'node_modules'));
+  };
+
+  addPrefixRoots(process.env.npm_config_prefix);
+  addPrefixRoots(process.env.PREFIX);
+
+  const nodeBinDir = dirname(process.execPath);
+  roots.push(join(nodeBinDir, 'node_modules'));
+  roots.push(join(nodeBinDir, '..', 'node_modules'));
+  roots.push(join(nodeBinDir, '..', 'lib', 'node_modules'));
+
+  if (process.platform === 'win32' && process.env.APPDATA) {
+    roots.push(join(process.env.APPDATA, 'npm', 'node_modules'));
+  }
+
+  try {
+    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const npmRoot = String(execFileSync(npmCommand, ['root', '-g'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 1500,
+    })).trim();
+    if (npmRoot) roots.unshift(npmRoot);
+  } catch { /* continue */ }
+
+  return uniquePaths(roots);
+}
+
+async function importHudPackage(hudPackage) {
+  try {
+    const wrapperRequire = createRequire(import.meta.url);
+    const resolvedHudPath = wrapperRequire.resolve(hudPackage);
+    await import(pathToFileURL(resolvedHudPath).href);
+    return true;
+  } catch { /* continue */ }
+
+  try {
+    const cwdRequire = createRequire(join(process.cwd(), '__omc_hud__.cjs'));
+    const resolvedHudPath = cwdRequire.resolve(hudPackage);
+    await import(pathToFileURL(resolvedHudPath).href);
+    return true;
+  } catch { /* continue */ }
+
+  for (const nodeModulesRoot of getGlobalNodeModuleRoots()) {
+    const resolvedHudPath = join(nodeModulesRoot, hudPackage);
+    if (!existsSync(resolvedHudPath)) continue;
+    try {
+      await import(pathToFileURL(resolvedHudPath).href);
+      return true;
+    } catch { /* continue */ }
+  }
+
+  return false;
+}
+
+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
+  const configDir = process.env.CLAUDE_CONFIG_DIR || join(home, ".claude");
+  const pluginCacheBase = join(configDir, "plugins", "cache", "omc", "oh-my-claudecode");
+  if (existsSync(pluginCacheBase)) {
+    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 = sortedVersions.filter(v => {
+          const hudPath = join(pluginCacheBase, v, "dist/hud/index.js");
+          return existsSync(hudPath);
+        });
+        if (builtVersions.length > 0) {
+          const latestBuilt = builtVersions[0];
+          pluginCacheDir = join(pluginCacheBase, latestBuilt);
+          const pluginPath = join(pluginCacheBase, latestBuilt, "dist/hud/index.js");
+          await import(pathToFileURL(pluginPath).href);
+          return;
+        }
+      }
+    } catch { /* continue */ }
+  }
+
+  // 2. Development paths
+  const devPaths = [
+    join(home, "Workspace/oh-my-claudecode/dist/hud/index.js"),
+    join(home, "workspace/oh-my-claudecode/dist/hud/index.js"),
+  ];
+
+  for (const devPath of devPaths) {
+    if (existsSync(devPath)) {
+      try {
+        await import(pathToFileURL(devPath).href);
+        return;
+      } catch { /* continue */ }
+    }
+  }
+
+  // 3. Marketplace clone (for marketplace installs without a populated cache)
+  const marketplaceHudPath = join(configDir, "plugins", "marketplaces", "omc", "dist/hud/index.js");
+  if (existsSync(marketplaceHudPath)) {
+    try {
+      await import(pathToFileURL(marketplaceHudPath).href);
+      return;
+    } catch { /* continue */ }
+  }
+
+  // 4. npm package (current project, global install, or branded fallback)
+  const npmHudPackages = [
+    "oh-my-claude-sisyphus/dist/hud/index.js",
+    "oh-my-claudecode/dist/hud/index.js",
+  ];
+  for (const hudPackage of npmHudPackages) {
+    if (await importHudPackage(hudPackage)) {
+      return;
+    }
+  }
+
+  // 5. 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();
+`;
+
+writeFileSync(hudScriptPath, hudScript);
+try {
+  chmodSync(hudScriptPath, 0o755);
+} catch { /* Windows doesn't need this */ }
+console.log('[OMC] Installed HUD wrapper script');
+
+// 3. Configure settings.json
+try {
+  let settings = {};
+  if (existsSync(SETTINGS_FILE)) {
+    settings = JSON.parse(readFileSync(SETTINGS_FILE, 'utf-8'));
+  }
+
+  // Use the absolute node binary path so nvm/fnm users don't get
+  // "node not found" errors in non-interactive shells (issue #892).
+  const nodeBin = process.execPath || 'node';
+  settings.statusLine = {
+    type: 'command',
+    command: `"${nodeBin}" "${hudScriptPath.replace(/\\/g, "/")}"`
+  };
+  writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+  console.log('[OMC] Configured HUD statusLine in settings.json');
+
+  // Persist the node binary path to .omc-config.json for use by find-node.sh
+  try {
+    const configPath = join(CLAUDE_DIR, '.omc-config.json');
+    let omcConfig = {};
+    if (existsSync(configPath)) {
+      omcConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+    if (nodeBin !== 'node') {
+      omcConfig.nodeBinary = nodeBin;
+      writeFileSync(configPath, JSON.stringify(omcConfig, null, 2));
+      console.log(`[OMC] Saved node binary path: ${nodeBin}`);
+    }
+  } catch (e) {
+    console.log('[OMC] Warning: Could not save node binary path (non-fatal):', e.message);
+  }
+} catch (e) {
+  console.log('[OMC] Warning: Could not configure settings.json:', e.message);
+}
+
+// Patch hooks.json to use the absolute node binary path so hooks work on all
+// platforms: Windows (no `sh`), nvm/fnm users (node not on PATH in hooks), etc.
+//
+// The source hooks.json uses shell-expanded `$CLAUDE_PLUGIN_ROOT` path segments
+// so bash preserves spaces in Windows profile paths; this step only substitutes
+// the real process.execPath so Claude Code always invokes the same Node binary
+// that ran this setup script.
+//
+// Two patterns are handled:
+//  1. New format  – node "$CLAUDE_PLUGIN_ROOT"/scripts/run.cjs ... (all platforms)
+//  2. Old format  – sh  "${CLAUDE_PLUGIN_ROOT}/scripts/find-node.sh" ... (Windows
+//     backward-compat: migrates old installs to the new run.cjs chain)
+//
+// Fixes issues #909, #899, #892, #869.
+try {
+  const hooksJsonPath = join(__dirname, '..', 'hooks', 'hooks.json');
+  if (existsSync(hooksJsonPath)) {
+    const data = JSON.parse(readFileSync(hooksJsonPath, 'utf-8'));
+    let patched = false;
+
+    // Pattern 2 (old, Windows backward-compat): sh find-node.sh <target> [args]
+    const findNodePattern =
+      /^sh "\$\{CLAUDE_PLUGIN_ROOT\}\/scripts\/find-node\.sh" "\$\{CLAUDE_PLUGIN_ROOT\}\/scripts\/([^"]+)"(.*)$/;
+
+    for (const groups of Object.values(data.hooks ?? {})) {
+      for (const group of groups) {
+        for (const hook of (group.hooks ?? [])) {
+          if (typeof hook.command !== 'string') continue;
+
+          // New run.cjs format — replace bare `node` with absolute path (all platforms)
+          if (hook.command.startsWith('node ') && hook.command.includes('/scripts/run.cjs')) {
+            hook.command = hook.command.replace(/^node\b/, `"${nodeBin}"`);
+            patched = true;
+            continue;
+          }
+
+          // Old find-node.sh format — migrate to run.cjs + absolute path (Windows only)
+          if (process.platform === 'win32') {
+            const m2 = hook.command.match(findNodePattern);
+            if (m2) {
+              hook.command = `"${nodeBin}" "$CLAUDE_PLUGIN_ROOT"/scripts/run.cjs "$CLAUDE_PLUGIN_ROOT"/scripts/${m2[1]}${m2[2]}`;
+              patched = true;
+            }
+          }
+        }
+      }
+    }
+
+    if (patched) {
+      writeFileSync(hooksJsonPath, JSON.stringify(data, null, 2) + '\n');
+      console.log(`[OMC] Patched hooks.json with absolute node path (${nodeBin}), fixes issues #909, #899, #892`);
+    }
+  }
+} catch (e) {
+  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/post-tool-use-failure.mjs

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+// OMC Post-Tool-Use-Failure Hook (Node.js)
+// Tracks tool failures for retry guidance in Stop hook
+// Writes last-tool-error.json with tool name, input preview, error, and retry count
+
+import { existsSync, readFileSync, mkdirSync } from 'fs';
+import { join, sep, resolve } from 'path';
+import { readStdin } from './lib/stdin.mjs';
+import { atomicWriteFileSync } from './lib/atomic-write.mjs';
+
+// Constants
+const RETRY_WINDOW_MS = 60000; // 60 seconds
+const MAX_ERROR_LENGTH = 500;
+const MAX_INPUT_PREVIEW_LENGTH = 200;
+
+// Validate that targetPath is contained within basePath (prevent path traversal)
+function isPathContained(targetPath, basePath) {
+  const normalizedTarget = resolve(targetPath);
+  const normalizedBase = resolve(basePath);
+  return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
+}
+
+// Initialize .omc directory if needed
+function initOmcDir(directory) {
+  const cwd = process.cwd();
+  // Validate directory is contained within cwd
+  if (!isPathContained(directory, cwd)) {
+    // Fallback to cwd if directory attempts traversal
+    directory = cwd;
+  }
+  const omcDir = join(directory, '.omc');
+  const stateDir = join(omcDir, 'state');
+
+  if (!existsSync(omcDir)) {
+    try { mkdirSync(omcDir, { recursive: true }); } catch {}
+  }
+  if (!existsSync(stateDir)) {
+    try { mkdirSync(stateDir, { recursive: true }); } catch {}
+  }
+
+  return stateDir;
+}
+
+// Truncate string to max length
+function truncate(str, maxLength) {
+  if (!str) return '';
+  const text = String(str);
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength) + '...';
+}
+
+// Create input preview from tool_input
+function createInputPreview(toolInput) {
+  if (!toolInput) return '';
+
+  try {
+    // If it's an object, stringify it
+    const inputStr = typeof toolInput === 'string' ? toolInput : JSON.stringify(toolInput);
+    return truncate(inputStr, MAX_INPUT_PREVIEW_LENGTH);
+  } catch {
+    return truncate(String(toolInput), MAX_INPUT_PREVIEW_LENGTH);
+  }
+}
+
+// Read existing error state
+function readErrorState(statePath) {
+  try {
+    if (!existsSync(statePath)) return null;
+    const content = readFileSync(statePath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// Calculate retry count
+function calculateRetryCount(existingState, toolName, currentTime) {
+  if (!existingState || existingState.tool_name !== toolName) {
+    return 1; // First failure for this tool
+  }
+
+  const lastErrorTime = new Date(existingState.timestamp).getTime();
+  // Guard against NaN from invalid timestamps
+  if (!Number.isFinite(lastErrorTime)) {
+    return 1; // Treat as first failure if timestamp is invalid
+  }
+  const timeDiff = currentTime - lastErrorTime;
+
+  if (timeDiff > RETRY_WINDOW_MS) {
+    return 1; // Outside retry window, reset count
+  }
+
+  return (existingState.retry_count || 1) + 1;
+}
+
+// Write error state
+function writeErrorState(stateDir, toolName, toolInputPreview, error, retryCount) {
+  const statePath = join(stateDir, 'last-tool-error.json');
+
+  const errorState = {
+    tool_name: toolName,
+    tool_input_preview: toolInputPreview,
+    error: truncate(error, MAX_ERROR_LENGTH),
+    timestamp: new Date().toISOString(),
+    retry_count: retryCount,
+  };
+
+  try {
+    atomicWriteFileSync(statePath, JSON.stringify(errorState, null, 2));
+  } catch {}
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    const data = JSON.parse(input);
+
+    // Official SDK fields (snake_case)
+    const toolName = data.tool_name || '';
+    const toolInput = data.tool_input;
+    const error = data.error || '';
+    const isInterrupt = data.is_interrupt || false;
+    const directory = data.cwd || data.directory || process.cwd();
+
+    // Ignore user interrupts
+    if (isInterrupt) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    // Skip if no tool name or error
+    if (!toolName || !error) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    // Initialize .omc/state directory
+    const stateDir = initOmcDir(directory);
+    const statePath = join(stateDir, 'last-tool-error.json');
+
+    // Read existing state and calculate retry count
+    const existingState = readErrorState(statePath);
+    const currentTime = Date.now();
+    const retryCount = calculateRetryCount(existingState, toolName, currentTime);
+
+    // Create input preview
+    const inputPreview = createInputPreview(toolInput);
+
+    // Write error state
+    writeErrorState(stateDir, toolName, inputPreview, error, retryCount);
+
+    // Inject continuation guidance so the model analyzes the error instead of stopping.
+    // Without this, PostToolUseFailure returns silently and the model may end its turn.
+    // The PostToolUse hook (post-tool-verifier.mjs) provides similar guidance for
+    // successful Bash calls with error patterns, but PostToolUseFailure is a separate
+    // event that needs its own guidance injection.
+    let guidance;
+    if (retryCount >= 5) {
+      guidance = `Tool "${toolName}" has failed ${retryCount} times. Stop retrying the same approach — try a different command, check dependencies, or ask the user for guidance.`;
+    } else {
+      guidance = `Tool "${toolName}" failed. Analyze the error, fix the issue, and continue working.`;
+    }
+
+    console.log(JSON.stringify({
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUseFailure',
+        additionalContext: guidance,
+      },
+    }));
+  } catch (error) {
+    // Never block on hook errors
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();