test: add test to prevent rogue external stubs

Add comprehensive test suite to ensure external dependencies in dist/external
are properly bundled and not left as stub re-exports. This test:

- Recursively scans all .js files in dist/external
- Detects stub re-export patterns that indicate incomplete bundling
- Flags very small files (< 50 bytes) that are likely stubs
- Allows intentional stubs (like @npmcli/package-json) to be whitelisted
- Specifically verifies all @InQuirer modules are properly bundled

This prevents a repeat of the issue where @inquirer/input, @inquirer/password,
and @inquirer/search were left as stubs, causing socket-cli build failures.

Author: jdalton

test/build-externals.test.ts

@@ -0,0 +1,158 @@
+/**
+ * @fileoverview Tests to ensure external dependencies are properly bundled.
+ * This prevents accidental stub re-exports in dist/external.
+ */
+
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { describe, expect, it } from 'vitest'
+
+const rootDir = process.cwd()
+const distExternalDir = path.join(rootDir, 'dist', 'external')
+
+// Stub re-export patterns that indicate incomplete bundling
+const STUB_PATTERNS = [
+  /^\s*module\.exports\s*=\s*require\s*\(/,
+  /^\s*export\s+\{\s*\}\s*from\s+/,
+  /^\s*export\s+\*\s+from\s+/,
+]
+
+/**
+ * Check if a file content is a stub re-export
+ */
+function isStubReexport(content: string): boolean {
+  return STUB_PATTERNS.some(pattern => pattern.test(content.trim()))
+}
+
+/**
+ * Get all .js files in a directory recursively
+ */
+async function getAllJsFiles(dir: string): Promise<string[]> {
+  async function walk(currentDir: string): Promise<string[]> {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true })
+    const filePromises: Array<Promise<string[]>> = []
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name)
+
+      if (entry.isDirectory()) {
+        filePromises.push(walk(fullPath))
+      } else if (entry.isFile() && entry.name.endsWith('.js')) {
+        filePromises.push(Promise.resolve([fullPath]))
+      }
+    }
+
+    const results = await Promise.all(filePromises)
+    return results.flat()
+  }
+
+  return await walk(dir)
+}
+
+describe('build-externals', () => {
+  it('should have bundled dist/external directory', async () => {
+    try {
+      await fs.access(distExternalDir)
+    } catch {
+      expect.fail(`dist/external directory does not exist at ${distExternalDir}`)
+    }
+  })
+
+  it('should not have stub re-exports in bundled files', async () => {
+    const jsFiles = await getAllJsFiles(distExternalDir)
+
+    // Should have external files
+    expect(jsFiles.length).toBeGreaterThan(0)
+
+    // Intentional stubs that are copied from src/external as-is (not bundled)
+    // These are too complex or optional to bundle
+    const intentionalStubs = [
+      '@npmcli/package-json/index.js',
+      '@npmcli/package-json/lib/read-package.js',
+      '@npmcli/package-json/lib/sort.js',
+    ]
+
+    const checkPromises = jsFiles.map(async file => {
+      const [content, stat] = await Promise.all([
+        fs.readFile(file, 'utf8'),
+        fs.stat(file),
+      ])
+      const relativePath = path.relative(distExternalDir, file)
+      const issues: Array<{ file: string; reason: string }> = []
+
+      // Skip intentional stub files
+      if (intentionalStubs.some(stub => relativePath.endsWith(stub))) {
+        return issues
+      }
+
+      // Check for stub re-export patterns
+      if (isStubReexport(content)) {
+        issues.push({
+          file: relativePath,
+          reason: 'Contains stub re-export pattern',
+        })
+      }
+
+      // Check for very small files that are likely stubs (< 100 bytes of actual code)
+      // Exclude files that are intentionally small (like 1-2KB minified)
+      if (stat.size < 50 && isStubReexport(content)) {
+        issues.push({
+          file: relativePath,
+          reason: `Very small file (${stat.size} bytes) that appears to be a stub`,
+        })
+      }
+
+      return issues
+    })
+
+    const allIssues = (await Promise.all(checkPromises)).flat()
+
+    if (allIssues.length > 0) {
+      const errorMessage = [
+        'Found unexpected stub re-exports in dist/external:',
+        ...allIssues.map(
+          f => `  - ${f.file}: ${f.reason}`,
+        ),
+        '',
+        'Make sure these packages are added to the bundling configuration in scripts/build-externals.mjs',
+        'or add them to the intentionalStubs list if they should remain as stubs.',
+      ].join('\n')
+
+      expect.fail(errorMessage)
+    }
+  })
+
+  it('should have @inquirer modules properly bundled', async () => {
+    const requiredInquirerModules = ['input', 'password', 'search', 'confirm', 'select']
+    const inquirerDir = path.join(distExternalDir, '@inquirer')
+
+    try {
+      await fs.access(inquirerDir)
+    } catch {
+      expect.fail(`@inquirer directory not found at ${inquirerDir}`)
+    }
+
+    const checkPromises = requiredInquirerModules.map(async module => {
+      const modulePath = path.join(inquirerDir, `${module}.js`)
+
+      try {
+        const [stat, content] = await Promise.all([
+          fs.stat(modulePath),
+          fs.readFile(modulePath, 'utf8'),
+        ])
+
+        if (stat.size <= 1000) {
+          expect.fail(`@inquirer/${module} should be properly bundled (> 1KB), got ${stat.size} bytes`)
+        }
+
+        if (isStubReexport(content)) {
+          expect.fail(`@inquirer/${module} should not be a stub re-export`)
+        }
+      } catch (error) {
+        expect.fail(`@inquirer/${module} not found or not properly bundled at ${modulePath}: ${error instanceof Error ? error.message : String(error)}`)
+      }
+    })
+
+    await Promise.all(checkPromises)
+  })
+})