@soederpop/luca 0.0.6 → 0.0.8

package/src/node/features/helpers.ts

@@ -4,11 +4,15 @@ import { Feature } from '../feature.js'
 import { Feature as UniversalFeature } from '../../feature.js'
 import { Client, clients } from '../../client.js'
 import { Server, servers } from '../../server.js'
-import { commands } from '../../command.js'
+import { Command, commands } from '../../command.js'
+import { graftModule, isNativeHelperClass } from '../../graft.js'
 import { endpoints } from '../../endpoint.js'
+import { Selector, selectors } from '../../selector.js'
 import type { Registry } from '../../registry.js'
 import type { FileManager } from './file-manager.js'
+import type { VM } from './vm.js'
 import { resolve, parse } from 'path'
+import { existsSync } from 'fs'
 
 export const HelpersStateSchema = FeatureStateSchema.extend({
   discovered: z.record(z.string(), z.boolean()).default({}).describe('Which registry types have been discovered'),
@@ -35,7 +39,7 @@ export const HelpersEventsSchema = FeatureEventsSchema.extend({
   ]).describe('Emitted when a single helper is registered'),
 })
 
-type RegistryType = 'features' | 'clients' | 'servers' | 'commands' | 'endpoints'
+type RegistryType = 'features' | 'clients' | 'servers' | 'commands' | 'endpoints' | 'selectors'
 
 const CLASS_BASED: RegistryType[] = ['features', 'clients', 'servers']
 
@@ -43,11 +47,11 @@ const CLASS_BASED: RegistryType[] = ['features', 'clients', 'servers']
  * The Helpers feature is a unified gateway for discovering and registering
  * project-level helpers from conventional folder locations.
  *
- * It scans known folder names (features/, clients/, servers/, commands/, endpoints/)
+ * It scans known folder names (features/, clients/, servers/, commands/, endpoints/, selectors/)
  * and handles registration differently based on the helper type:
  *
  * - Class-based (features, clients, servers): Dynamic import, validate subclass, register
- * - Config-based (commands, endpoints): Delegate to existing discovery mechanisms
+ * - Config-based (commands, endpoints, selectors): Delegate to existing discovery mechanisms
  *
  * @example
  * ```typescript
@@ -71,6 +75,13 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
   static override eventsSchema = HelpersEventsSchema
   static { Feature.register(this, 'helpers') }
 
+  /** In-flight or completed discovery promises, keyed by registry type */
+  private _discoveryPromises: Map<string, Promise<string[]>> = new Map()
+  /** Cached results from completed discoveries */
+  private _discoveryResults: Map<string, string[]> = new Map()
+  /** In-flight or completed discoverAll promise */
+  private _discoverAllPromise: Promise<Record<string, string[]>> | null = null
+
   /**
    * Returns a mapping from registry type name to its registry singleton, base class, and conventional folder candidates.
    */
@@ -81,6 +92,7 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
       servers: { registry: servers, baseClass: Server, folders: ['servers'] },
       commands: { registry: commands, baseClass: null, folders: ['commands'] },
       endpoints: { registry: endpoints, baseClass: null, folders: ['endpoints'] },
+      selectors: { registry: selectors, baseClass: null, folders: ['selectors'] },
     }
   }
 
@@ -89,6 +101,118 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
     return this.options.rootDir || this.container.cwd
   }
 
+  /**
+   * Whether to use native `import()` for loading project helpers.
+   * True only if `@soederpop/luca` is actually resolvable in `node_modules`.
+   * Warns when `node_modules` exists but the package is missing.
+   */
+  get useNativeImport(): boolean {
+    const hasNodeModules = existsSync(resolve(this.rootDir, 'node_modules'))
+    const hasLuca = hasNodeModules && existsSync(resolve(this.rootDir, 'node_modules', '@soederpop', 'luca'))
+
+    if (hasNodeModules && !hasLuca && !this._warnedNativeImport) {
+      this._warnedNativeImport = true
+      console.warn(
+        `Helpers: node_modules exists but @soederpop/luca wasn't found. ` +
+        `Did you forget to \`bun install\` or add @soederpop/luca as a dependency? ` +
+        `Using the VM virtual module system instead until this is resolved.`
+      )
+    }
+
+    return hasLuca
+  }
+
+  /** Prevent repeated warnings about missing @soederpop/luca */
+  private _warnedNativeImport = false
+
+  /** Track whether we've seeded the VM with virtual modules */
+  private _vmSeeded = false
+
+  /**
+   * Seeds the VM feature with virtual modules so that project-level files
+   * can `import` / `require('@soederpop/luca')`, `zod`, etc. without
+   * needing them in `node_modules`.
+   *
+   * Called automatically when `useNativeImport` is false.
+   * Can also be called externally (e.g. from the CLI) to pre-seed before discovery.
+   */
+  seedVirtualModules(): void {
+    if (this._vmSeeded) return
+    this._vmSeeded = true
+
+    const vm = this.container.feature('vm') as unknown as VM
+
+    // Provide the full @soederpop/luca barrel — everything node.ts exports
+    // We build the exports object from the already-loaded modules in memory
+    const lucaExports: Record<string, any> = {
+      // Core classes
+      Feature: UniversalFeature,
+      Container: this.container.constructor,
+      Helper: Object.getPrototypeOf(UniversalFeature.prototype).constructor,
+      Client,
+      Server,
+      Command,
+      Registry: Object.getPrototypeOf(this.container.features).constructor,
+
+      // Utilities
+      graftModule,
+      isNativeHelperClass,
+
+      // Registries
+      features: this.container.features,
+      clients,
+      servers,
+      commands,
+      endpoints,
+      selectors,
+
+      // Registry classes
+      ClientsRegistry: clients.constructor,
+      CommandsRegistry: commands.constructor,
+      EndpointsRegistry: endpoints.constructor,
+      ServersRegistry: servers.constructor,
+      SelectorsRegistry: selectors.constructor,
+      FeaturesRegistry: this.container.features.constructor,
+
+      // Helper subclasses
+      Selector,
+
+      // The singleton container
+      default: this.container,
+
+      // Convenient feature instances
+      fs: this.container.feature('fs'),
+      ui: this.container.feature('ui'),
+      vm,
+      proc: this.container.feature('proc'),
+
+      // Zod re-export
+      z,
+    }
+
+    // Schemas
+    const schemasModule = { CommandOptionsSchema: commands.baseClass?.optionsSchema || z.object({}) }
+    try {
+      // Pull all base schemas from the already-loaded schemas/base module
+      const baseSchemas = require('../../schemas/base.js')
+      Object.assign(lucaExports, baseSchemas)
+      Object.assign(schemasModule, baseSchemas)
+    } catch {
+      // Fallback: provide the essentials
+      lucaExports.FeatureStateSchema = FeatureStateSchema
+      lucaExports.FeatureOptionsSchema = FeatureOptionsSchema
+      lucaExports.FeatureEventsSchema = FeatureEventsSchema
+      schemasModule.FeatureStateSchema = FeatureStateSchema
+      schemasModule.FeatureOptionsSchema = FeatureOptionsSchema
+      schemasModule.FeatureEventsSchema = FeatureEventsSchema
+    }
+
+    vm.defineModule('@soederpop/luca', lucaExports)
+    vm.defineModule('@soederpop/luca/schemas', schemasModule)
+    vm.defineModule('@soederpop/luca/node', lucaExports)
+    vm.defineModule('zod', { z, default: { z } })
+  }
+
   /**
    * Returns a unified view of all available helpers across all registries.
    * Each key is a registry type, each value is the list of helper names in that registry.
@@ -144,11 +268,9 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
   /**
    * Discover and register project-level helpers of the given type.
    *
-   * For class-based types (features, clients, servers), scans the matching
-   * directory for .ts files, dynamically imports each, validates the default
-   * export is a subclass of the registry's base class, and registers it.
-   *
-   * For config-based types (commands, endpoints), delegates to existing discovery mechanisms.
+   * Idempotent: the first caller triggers the actual scan. Subsequent callers
+   * receive the cached results. If discovery is in-flight, callers await the
+   * same promise — no duplicate work.
    *
    * @param type - Which type of helpers to discover
    * @param options - Optional overrides
@@ -162,16 +284,39 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
    * ```
    */
   async discover(type: RegistryType, options: { directory?: string } = {}): Promise<string[]> {
-    const discovered = this.state.get('discovered') || {}
+    // Key by type + resolved directory so that different directories
+    // (e.g. project commands/ vs ~/.luca/commands/) are discovered independently
+    // while concurrent calls to the same directory coalesce on one promise.
+    const dir = options.directory || this.resolveFolderPath(type)
+    const cacheKey = dir ? `${type}:${dir}` : type
 
-    if (discovered[type]) {
-      return []
+    // Return cached results if already completed
+    if (this._discoveryResults.has(cacheKey)) {
+      return this._discoveryResults.get(cacheKey)!
+    }
+
+    // If in-flight, await the same promise
+    if (this._discoveryPromises.has(cacheKey)) {
+      return this._discoveryPromises.get(cacheKey)!
     }
 
+    // First caller — start the work and store the promise
+    const promise = this._doDiscover(type, { directory: dir || undefined })
+    this._discoveryPromises.set(cacheKey, promise)
+
+    const names = await promise
+
+    // Cache the final results
+    this._discoveryResults.set(cacheKey, names)
+
+    return names
+  }
+
+  /** Internal: performs the actual discovery work for a single type. */
+  private async _doDiscover(type: RegistryType, options: { directory?: string } = {}): Promise<string[]> {
     const dir = options.directory || this.resolveFolderPath(type)
 
     if (!dir) {
-      this.state.set('discovered', { ...discovered, [type]: true })
       return []
     }
 
@@ -183,7 +328,9 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
       names = await this.discoverConfigBased(type, dir)
     }
 
-    this.state.set('discovered', { ...this.state.get('discovered'), [type]: true })
+    // Update state for observability
+    const discovered = this.state.get('discovered') || {}
+    this.state.set('discovered', { ...discovered, [type]: true })
 
     const existing = this.state.get('registered') || []
     this.state.set('registered', [...existing, ...names.map(n => `${type}.${n}`)])
@@ -196,6 +343,9 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
   /**
    * Discover all helper types from their conventional folder locations.
    *
+   * Idempotent: safe to call from multiple places (luca.cli.ts, commands, etc.).
+   * The first caller triggers discovery; all others receive the same results.
+   *
    * @returns Map of registry type to discovered helper names
    *
    * @example
@@ -205,9 +355,19 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
    * ```
    */
   async discoverAll(): Promise<Record<string, string[]>> {
+    if (this._discoverAllPromise) {
+      return this._discoverAllPromise
+    }
+
+    this._discoverAllPromise = this._doDiscoverAll()
+    return this._discoverAllPromise
+  }
+
+  /** Internal: performs the actual discoverAll work. */
+  private async _doDiscoverAll(): Promise<Record<string, string[]>> {
     const results: Record<string, string[]> = {}
 
-    for (const type of ['features', 'clients', 'servers', 'commands', 'endpoints'] as RegistryType[]) {
+    for (const type of ['features', 'clients', 'servers', 'commands', 'endpoints', 'selectors'] as RegistryType[]) {
       results[type] = await this.discover(type)
     }
 
@@ -243,59 +403,106 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
     return registry.describe(name)
   }
 
+  /**
+   * Load a module either via native `import()` or the VM's virtual module system.
+   * Uses the same `useNativeImport` check as discovery to decide the loading strategy.
+   *
+   * @param absPath - Absolute path to the module file
+   * @returns The module's exports
+   */
+  async loadModuleExports(absPath: string): Promise<Record<string, any>> {
+    if (this.useNativeImport) {
+      const mod = await import(absPath)
+      return mod
+    }
+
+    this.seedVirtualModules()
+    const vm = this.container.feature('vm') as unknown as VM
+    return vm.loadModule(absPath)
+  }
+
   /**
    * Discovers class-based helpers (features, clients, servers) from a directory.
-   * Uses fileManager for fast file matching.
+   * Uses fileManager when available (fast in git repos), falls back to Glob.
    */
   private async discoverClassBased(type: RegistryType, dir: string): Promise<string[]> {
     const { registry, baseClass } = this.registryMap[type]
-    const fm = await this.ensureFileManager()
     const discovered: string[] = []
 
     // Load build-time introspection data before importing helpers so that
     // interceptRegistration() can merge JSDoc descriptions from the generated file.
     const introspectionFile = resolve(dir, 'introspection.generated.ts')
     try {
-      const { existsSync } = await import('fs')
       if (existsSync(introspectionFile)) {
         await import(introspectionFile)
       }
     } catch {}
 
-    const tests = [`${type}/*/*.ts`, `${type}/*.ts`]
-    const files = fm.match(tests)
+    // Try fileManager first (faster in git repos), fall back to Glob
+    let files: string[] = []
+    try {
+      const fm = await this.ensureFileManager()
+      // fileManager may store absolute or relative keys — use absolute patterns
+      const absPatterns = [`${dir}/*.ts`, `${dir}/**/*.ts`]
+      const relPatterns = [`${type}/*.ts`, `${type}/**/*.ts`]
+      const matched = fm.match([...absPatterns, ...relPatterns])
+      files = matched.map((f: string) => f.startsWith('/') ? f : resolve(this.rootDir, f))
+    } catch {}
 
-    for (const file of files) {
-      const absPath = resolve(this.rootDir, file)
+    // Fall back to Glob if fileManager found nothing
+    if (files.length === 0) {
+      const { Glob } = globalThis.Bun || (await import('bun'))
+      const glob = new Glob('**/*.ts')
+      for await (const file of glob.scan({ cwd: dir })) {
+        files.push(resolve(dir, file))
+      }
+    }
+
+    for (const absPath of files) {
       const { name: fileName } = parse(absPath)
 
       if (fileName.includes('.test.') || fileName.includes('.spec.')) {
         continue
       }
-
       try {
-        const mod = await import(absPath)
+        const mod = await this.loadModuleExports(absPath)
         const ExportedClass = mod.default || mod
 
-        if (typeof ExportedClass !== 'function') {
-          continue
-        }
+        // Class-based: default export is a subclass of the base
+        if (typeof ExportedClass === 'function' && isNativeHelperClass(ExportedClass, baseClass)) {
+          const shortcut = ExportedClass.shortcut as string | undefined
+          const registryName = shortcut
+            ? shortcut.replace(`${type}.`, '')
+            : this.fileNameToRegistryName(fileName)
 
-        if (!this.isSubclassOf(ExportedClass, baseClass)) {
-          continue
-        }
+          discovered.push(registryName)
 
-        const shortcut = ExportedClass.shortcut as string | undefined
-        const registryName = shortcut
-          ? shortcut.replace(`${type}.`, '')
-          : this.fileNameToRegistryName(fileName)
-
-        discovered.push(registryName)
-
-        if (!registry.has(registryName)) {
-          registry.register(registryName, ExportedClass)
-          // this is only if they didn't export it by default
-          this.emit('registered' as any, type, registryName, ExportedClass)
+          if (!registry.has(registryName)) {
+            registry.register(registryName, ExportedClass)
+            this.emit('registered' as any, type, registryName, ExportedClass)
+          }
+        } else {
+          // Module-based: graft exports onto a generated subclass
+          const moduleExports = mod.default && typeof mod.default === 'object' ? mod.default : mod
+          const isGraftable = (
+            moduleExports.description !== undefined ||
+            moduleExports.stateSchema !== undefined ||
+            moduleExports.optionsSchema !== undefined ||
+            typeof moduleExports.run === 'function' ||
+            typeof moduleExports.handler === 'function'
+          )
+
+          if (isGraftable) {
+            const registryName = this.fileNameToRegistryName(fileName)
+            const GraftedClass = graftModule(baseClass, moduleExports, registryName, type as any)
+
+            discovered.push(registryName)
+
+            if (!registry.has(registryName)) {
+              registry.register(registryName, GraftedClass as any)
+              this.emit('registered' as any, type, registryName, GraftedClass)
+            }
+          }
         }
 
       } catch (err: any) {
@@ -318,15 +525,137 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
     const beforeNames = new Set(registry.available)
 
     if (type === 'commands') {
-      await commands.discover({ directory: dir })
+      if (this.useNativeImport) {
+        await commands.discover({ directory: dir })
+      } else {
+        await this.discoverCommandsViaVM(dir)
+      }
     } else if (type === 'endpoints') {
       await this.discoverEndpoints(dir)
+    } else if (type === 'selectors') {
+      if (this.useNativeImport) {
+        await selectors.discover({ directory: dir })
+      } else {
+        await this.discoverSelectorsViaVM(dir)
+      }
     }
 
     const afterNames = new Set(registry.available)
     return [...afterNames].filter(n => !beforeNames.has(n))
   }
 
+  /**
+   * Discovers commands using the VM's virtual module system.
+   * Mirrors CommandsRegistry.discover() but uses vm.loadModule() instead of import().
+   */
+  private async discoverCommandsViaVM(dir: string): Promise<void> {
+    this.seedVirtualModules()
+    const { Glob } = globalThis.Bun || (await import('bun'))
+    const glob = new Glob('*.ts')
+
+    for await (const file of glob.scan({ cwd: dir })) {
+      if (file === 'index.ts') continue
+
+      const absPath = resolve(dir, file)
+      const name = file.replace(/\.ts$/, '')
+
+      if (commands.has(name)) continue
+
+      try {
+        const mod = await this.loadModuleExports(absPath)
+
+        // 1. Class-based: default export extends Command
+        if (isNativeHelperClass(mod.default, Command)) {
+          const ExportedClass = mod.default
+          if (!ExportedClass.shortcut || ExportedClass.shortcut === 'commands.base') {
+            ExportedClass.shortcut = `commands.${name}`
+          }
+          if (!ExportedClass.commandDescription && ExportedClass.description) {
+            ExportedClass.commandDescription = ExportedClass.description
+          }
+          commands.register(name, ExportedClass)
+          continue
+        }
+
+        const commandModule = mod.default || mod
+
+        // 2. Module-based with `run` export (new SimpleCommand pattern)
+        if (typeof commandModule.run === 'function') {
+          const Grafted = graftModule(Command as any, commandModule, name, 'commands')
+          commands.register(name, Grafted as any)
+          continue
+        }
+
+        // 3. Legacy: `handler` export
+        if (typeof commandModule.handler === 'function') {
+          const Grafted = graftModule(Command as any, {
+            description: commandModule.description,
+            argsSchema: commandModule.argsSchema,
+            handler: commandModule.handler,
+          }, name, 'commands')
+          commands.register(name, Grafted as any)
+          continue
+        }
+
+        // 4. Plain default-exported function: export default async function name(options, context)
+        if (typeof mod.default === 'function' && !isNativeHelperClass(mod.default, Command)) {
+          const Grafted = graftModule(Command as any, {
+            description: mod.description || '',
+            argsSchema: mod.argsSchema,
+            positionals: mod.positionals,
+            handler: mod.default,
+          }, name, 'commands')
+          commands.register(name, Grafted as any)
+        }
+      } catch (err: any) {
+        console.warn(`Helpers gateway: failed to load command from ${absPath}: ${err.message}`)
+      }
+    }
+  }
+
+  /**
+   * Discovers selectors using the VM's virtual module system.
+   * Mirrors discoverCommandsViaVM but uses selectors registry and Selector base class.
+   */
+  private async discoverSelectorsViaVM(dir: string): Promise<void> {
+    this.seedVirtualModules()
+    const { Glob } = globalThis.Bun || (await import('bun'))
+    const glob = new Glob('*.ts')
+
+    for await (const file of glob.scan({ cwd: dir })) {
+      if (file === 'index.ts') continue
+
+      const absPath = resolve(dir, file)
+      const name = file.replace(/\.ts$/, '')
+
+      if (selectors.has(name)) continue
+
+      try {
+        const mod = await this.loadModuleExports(absPath)
+
+        // 1. Class-based: default export extends Selector
+        if (isNativeHelperClass(mod.default, Selector)) {
+          const ExportedClass = mod.default
+          if (!ExportedClass.shortcut || ExportedClass.shortcut === 'selectors.base') {
+            ExportedClass.shortcut = `selectors.${name}`
+          }
+          selectors.register(name, ExportedClass)
+          continue
+        }
+
+        const selectorModule = mod.default || mod
+
+        // 2. Module-based with `run` export
+        if (typeof selectorModule.run === 'function') {
+          const Grafted = graftModule(Selector as any, selectorModule, name, 'selectors')
+          selectors.register(name, Grafted as any)
+        }
+      } catch (err: any) {
+        console.warn(`Helpers gateway: failed to load selector from ${absPath}: ${err.message}`)
+      }
+    }
+  }
+
   /**
    * Discovers endpoints from a directory, registering them for discoverability.
    * Actual mounting to an express server is handled separately by ExpressServer.useEndpoints().
@@ -337,7 +666,7 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
 
     for await (const file of glob.scan({ cwd: dir, absolute: true })) {
       try {
-        const mod = await import(file)
+        const mod = await this.loadModuleExports(file)
         const endpointModule = mod.default || mod
 
         if (endpointModule.path && typeof endpointModule.path === 'string') {

package/src/node/features/networking.ts

@@ -2,7 +2,7 @@ import { z } from 'zod'
 import net from 'net'
 import detectPort from 'detect-port'
 import { Feature } from '../feature.js'
-import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 
 const MAX_CIDR_HOSTS = 65536
 
@@ -119,6 +119,27 @@ export const NetworkSnapshotSchema = z.object({
 })
 export type NetworkSnapshot = z.infer<typeof NetworkSnapshotSchema>
 
+export const NetworkingEventsSchema = FeatureEventsSchema.extend({
+  'host:discovered': z.tuple([DiscoverHostSchema.describe('The discovered host')]).describe('When a host is found during network scanning'),
+  'port:open': z.tuple([z.object({
+    host: z.string().describe('Host IP address'),
+    port: z.number().describe('Open port number'),
+    service: z.string().optional().describe('Best-effort service name'),
+    banner: z.string().optional().describe('Banner text when captured'),
+  }).describe('Open port details')]).describe('When an open port is detected on a host'),
+  'scan:start': z.tuple([z.object({
+    target: z.string().describe('Scan target identifier'),
+    type: z.string().describe('Scan type identifier'),
+  }).describe('Scan start details')]).describe('When a network scan begins'),
+  'scan:complete': z.tuple([z.object({
+    target: z.string().describe('Scan target identifier'),
+    type: z.string().describe('Scan type identifier'),
+    duration: z.number().describe('Scan duration in milliseconds'),
+    hostsFound: z.number().describe('Number of hosts discovered'),
+    portsFound: z.number().describe('Number of open ports discovered'),
+  }).describe('Scan completion details')]).describe('When a network scan finishes'),
+}).describe('Networking events')
+
 export const NetworkingStateSchema = FeatureStateSchema.extend({
   lastScan: z.object({
     timestamp: z.number().describe('Unix epoch timestamp in ms'),
@@ -204,6 +225,7 @@ export class Networking extends Feature<NetworkingState, NetworkingOptions> {
   static override shortcut = 'features.networking' as const
   static override stateSchema = NetworkingStateSchema
   static override optionsSchema = NetworkingOptionsSchema
+  static override eventsSchema = NetworkingEventsSchema
   static { Feature.register(this, 'networking') }
 
   override get initialState(): NetworkingState {
@@ -214,6 +236,19 @@ export class Networking extends Feature<NetworkingState, NetworkingOptions> {
     }
   }
 
+  private _binCache: Record<string, string> = {}
+
+  /** Resolve a binary path via `which`, caching the result. */
+  private resolveBin(name: string): string {
+    if (this._binCache[name]) return this._binCache[name]
+    try {
+      this._binCache[name] = this.proc.exec(`which ${name}`).trim()
+    } catch {
+      this._binCache[name] = name
+    }
+    return this._binCache[name]
+  }
+
   get proc() {
     return this.container.feature('proc')
   }
@@ -359,7 +394,7 @@ export class Networking extends Feature<NetworkingState, NetworkingOptions> {
    * Reads and parses the system ARP cache.
    */
   async getArpTable(): Promise<ArpEntry[]> {
-    const output = await this.proc.execAndCapture('arp -a')
+    const output = await this.proc.execAndCapture(`${this.resolveBin('arp')} -a`)
     if (output.exitCode !== 0) {
       return []
     }
@@ -605,7 +640,7 @@ export class Networking extends Feature<NetworkingState, NetworkingOptions> {
   }
 
   private async isNmapAvailable(): Promise<boolean> {
-    const result = await this.proc.spawnAndCapture('nmap', ['--version'])
+    const result = await this.proc.spawnAndCapture(this.resolveBin('nmap'), ['--version'])
     return result.exitCode === 0
   }
 
@@ -619,7 +654,7 @@ export class Networking extends Feature<NetworkingState, NetworkingOptions> {
     const startTime = Date.now()
 
     const cmdArgs = [...args, '-oG', '-', target]
-    const result = await this.proc.spawnAndCapture('nmap', cmdArgs)
+    const result = await this.proc.spawnAndCapture(this.resolveBin('nmap'), cmdArgs)
 
     if (result.exitCode !== 0) {
       throw new Error(result.stderr || 'nmap scan failed')