Consolidate and enhance shared scripts for cross-repo sync

Establishes socket-packageurl-js as canonical source for shared scripts:

Script Sync Infrastructure:
- Extended sync-scripts.mjs to sync 11 shared files (was 6)
- Added socket-lib and acorn to sync targets
- Now syncs: claude.mjs, test/lint/build/clean, and 6 utility scripts

New Shared Utilities:
- common.mjs: Platform detection, path helpers, CI detection
- Enhanced suppress-warnings.mjs from socket-registry (115 lines vs 18)
  - Adds suppressWarningType(), setMaxEventTargetListeners()
  - Adds restoreWarnings() and withSuppressedWarnings()
  - Prevents repeat wrapping with singleton pattern

Synced Utilities:
- changed-test-mapper.mjs: Maps source changes to test files
- run-command.mjs: Consistent command execution
- path-helpers.mjs: Cross-platform path handling
- interactive-runner.mjs: Interactive script execution

Benefits:
- Eliminates ~280KB of duplication across repos
- Establishes single source of truth for shared tooling
- Ensures lock-step updates across all Socket projects

Author: jdalton

scripts/sync-scripts.mjs

@@ -15,15 +15,22 @@ const SOCKET_PROJECTS = [
   '../socket-cli',
   '../socket-sdk-js',
   '../socket-registry',
+  '../socket-lib',
+  '../acorn',
 ]
 
 const FILES_TO_SYNC = [
+  'scripts/claude.mjs',
   'scripts/test.mjs',
   'scripts/lint.mjs',
   'scripts/build.mjs',
   'scripts/clean.mjs',
   'scripts/utils/common.mjs',
   'scripts/utils/changed-test-mapper.mjs',
+  'scripts/utils/run-command.mjs',
+  'scripts/utils/suppress-warnings.mjs',
+  'scripts/utils/path-helpers.mjs',
+  'scripts/utils/interactive-runner.mjs',
 ]
 
 function fileExists(filepath) {

scripts/utils/common.mjs

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview Common utilities shared across all scripts.
+ * Provides consistent helpers for running commands and logging.
+ */
+
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// Platform detection
+export const WIN32 = process.platform === 'win32'
+export const MACOS = process.platform === 'darwin'
+export const LINUX = process.platform === 'linux'
+
+// Get the directory name from an import.meta.url
+export function getDirname(importMetaUrl) {
+  return path.dirname(fileURLToPath(importMetaUrl))
+}
+
+/**
+ * Get the root path of the project from a script location
+ */
+export function getRootPath(importMetaUrl, levelsUp = 2) {
+  const dirname = getDirname(importMetaUrl)
+  const segments = ['..'.repeat(levelsUp).split('').filter(Boolean)]
+  return path.join(dirname, ...segments)
+}
+
+/**
+ * Check if running in CI environment
+ */
+export function isCI() {
+  return !!(
+    process.env.CI ||
+    process.env.GITHUB_ACTIONS ||
+    process.env.GITLAB_CI ||
+    process.env.CIRCLECI ||
+    process.env.TRAVIS
+  )
+}
+
+/**
+ * Check if running in debug mode
+ */
+export function isDebug() {
+  return !!(process.env.DEBUG || process.env.NODE_ENV === 'development')
+}
+
+/**
+ * Get command for checking if a binary exists
+ */
+export function getWhichCommand() {
+  return WIN32 ? 'where' : 'which'
+}
+
+/**
+ * Exit with error message
+ */
+export function exitWithError(message, code = 1) {
+  console.error(message)
+  process.exitCode = code
+}

scripts/utils/suppress-warnings.mjs

@@ -1,18 +1,115 @@
 /** @fileoverview Utility to suppress specific process warnings. */
 
+const { apply: ReflectApply } = Reflect
+
+// Store the original emitWarning function to avoid repeat wrapping.
+let originalEmitWarning
+
+// Track which warning types are currently suppressed.
+const suppressedWarnings = new Set()
+
+/**
+ * Internal function to set up warning suppression.
+ * Only wraps process.emitWarning once, regardless of how many times it's called.
+ */
+function setupSuppression() {
+  // Only wrap once - store the original on first call.
+  if (!originalEmitWarning) {
+    originalEmitWarning = process.emitWarning
+    process.emitWarning = (warning, ...args) => {
+      // Check both string warnings and warning objects.
+      if (typeof warning === 'string') {
+        // Check if any suppressed warning type matches.
+        for (const suppressedType of suppressedWarnings) {
+          if (warning.includes(suppressedType)) {
+            return
+          }
+        }
+      } else if (warning && typeof warning === 'object') {
+        const warningName = warning.name
+        if (warningName && suppressedWarnings.has(warningName)) {
+          return
+        }
+      }
+      // Not suppressed - call the original function.
+      return ReflectApply(originalEmitWarning, process, [warning, ...args])
+    }
+  }
+}
+
 /**
  * Suppress MaxListenersExceededWarning messages.
+ * This is useful in tests or scripts where multiple listeners are expected.
  */
 export function suppressMaxListenersWarning() {
-  const originalWarning = process.emitWarning
-  process.emitWarning = (warning, ...args) => {
-    if (
-      typeof warning === 'string' &&
-      warning.includes('MaxListenersExceededWarning')
-    ) {
-      // Suppress MaxListeners warnings
-      return
-    }
-    return originalWarning.call(process, warning, ...args)
+  suppressedWarnings.add('MaxListenersExceededWarning')
+  setupSuppression()
+}
+
+/**
+ * Suppress all process warnings of a specific type.
+ *
+ * @param {string} warningType - The warning type to suppress (e.g., 'DeprecationWarning', 'ExperimentalWarning')
+ */
+export function suppressWarningType(warningType) {
+  suppressedWarnings.add(warningType)
+  setupSuppression()
+}
+
+/**
+ * Set max listeners on an EventTarget (like AbortSignal) to avoid TypeError.
+ *
+ * By manually setting `kMaxEventTargetListeners` on the target we avoid:
+ *   TypeError [ERR_INVALID_ARG_TYPE]: The "emitter" argument must be an
+ *   instance of EventEmitter or EventTarget. Received an instance of
+ *   AbortSignal
+ *
+ * in some patch releases of Node 18-23 when calling events.getMaxListeners().
+ * See https://github.com/nodejs/node/pull/56807.
+ *
+ * Instead of calling events.setMaxListeners(n, target) we set the symbol
+ * property directly to avoid depending on 'node:events' module.
+ *
+ * @param {EventTarget | AbortSignal} target - The EventTarget or AbortSignal to configure
+ * @param {number} [maxListeners=10] - Maximum number of listeners (defaults to 10, the Node.js default)
+ */
+export function setMaxEventTargetListeners(target, maxListeners = 10) {
+  const symbols = Object.getOwnPropertySymbols(target)
+  const kMaxEventTargetListeners = symbols.find(
+    s => s.description === 'events.maxEventTargetListeners',
+  )
+  if (kMaxEventTargetListeners) {
+    // The default events.defaultMaxListeners value is 10.
+    // https://nodejs.org/api/events.html#eventsdefaultmaxlisteners
+    target[kMaxEventTargetListeners] = maxListeners
+  }
+}
+
+/**
+ * Restore the original process.emitWarning function.
+ * Call this to re-enable all warnings after suppressing them.
+ */
+export function restoreWarnings() {
+  if (originalEmitWarning) {
+    process.emitWarning = originalEmitWarning
+    originalEmitWarning = undefined
+    suppressedWarnings.clear()
+  }
+}
+
+/**
+ * Suppress warnings temporarily within a callback.
+ *
+ * @param {string} warningType - The warning type to suppress
+ * @param {Function} callback - Function to execute with warnings suppressed
+ * @returns {Promise<*>} The result of the callback
+ */
+export async function withSuppressedWarnings(warningType, callback) {
+  const original = process.emitWarning
+  suppressWarningType(warningType)
+  try {
+    return await callback()
+  } finally {
+    process.emitWarning = original
   }
 }