Add promise-fork util

Author: jdalton

src/utils/promise-fork.ts

@@ -0,0 +1,88 @@
+// An implementation of https://socket.dev/npm/package/@npmcli/promise-spawn/overview/8.0.2
+// that uses child_process.fork instead of child_process.spawn.
+// ISC License
+// Copyright (c) npm, Inc.
+import { fork as builtinFork } from 'node:child_process'
+
+import type { ForkOptions as BuiltinForkOptions } from 'node:child_process'
+
+type BuiltinForkResult = ReturnType<typeof builtinFork>
+
+export type ForkOptions = {
+  cwd?: string
+  encoding?: BufferEncoding
+  stdioString?: boolean
+} & BuiltinForkOptions
+
+export type ForkResult<Output, Extra> = Promise<
+  {
+    cmd: string
+    args: string[]
+    code: number
+    signal: NodeJS.Signals | null
+    stdout: Output
+    stderr: Output
+  } & Extra
+> & { process: BuiltinForkResult; stdio: BuiltinForkResult['stdio'] }
+
+export function fork<O extends ForkOptions>(
+  cmd: string,
+  args: string[],
+  opts?: O,
+  extra?: Record<any, any>
+): ForkResult<
+  O extends { stdioString: false } ? Buffer : string,
+  typeof extra
+> {
+  const { encoding = 'utf8', ...builtinForkOptions } = {
+    __proto__: null,
+    ...opts
+  }
+
+  let resolve: ((value: any) => void) | undefined
+  let reject: ((reason?: any) => void) | undefined
+  const promise = new Promise((res, rej) => {
+    resolve = res
+    reject = rej
+  }) as ForkResult<
+    O extends { stdioString: false } ? Buffer : string,
+    typeof extra
+  >
+
+  const closeError = new Error('command failed')
+  const stdout: Buffer[] = []
+  const stderr: Buffer[] = []
+
+  const getResult = (result: Record<string, any>) => ({
+    cmd,
+    args,
+    ...result,
+    stdout: Buffer.concat(stdout).toString(encoding),
+    stderr: Buffer.concat(stderr).toString(encoding),
+    ...extra
+  })
+
+  const rejectWithOpts = (er: Error, erOpts: Record<string, any>) => {
+    const resultError = getResult(erOpts)
+    reject?.(Object.assign(er, resultError))
+  }
+
+  const proc = builtinFork(cmd, args, builtinForkOptions)
+    .on('error', error => rejectWithOpts(error, {}))
+    .on('close', (code, signal) => {
+      if (code !== 0 || signal) {
+        rejectWithOpts(closeError, { code, signal })
+      } else {
+        resolve?.(getResult({ code, signal }))
+      }
+    })
+  proc.stdout
+    ?.on('data', chunk => stdout.push(chunk))
+    .on('error', error => rejectWithOpts(error, {}))
+  proc.stderr
+    ?.on('data', chunk => stderr.push(chunk))
+    .on('error', error => rejectWithOpts(error, {}))
+  ;(promise as any).stdin = proc.stdin
+  ;(promise as any).process = proc
+  return promise
+}

src/utils/shadow-npm.ts

@@ -1,25 +1,23 @@
 import path from 'node:path'
 
-import spawn from '@npmcli/promise-spawn'
-
+import { fork } from './promise-fork'
 import constants from '../constants'
 
+import type { ForkOptions, ForkResult } from './promise-fork'
+
 const { abortSignal } = constants
 
-type ShadowNpmInstallOptions = Exclude<
-  Parameters<typeof spawn>[2],
-  undefined
-> & {
+type ShadowNpmInstallOptions = ForkOptions & {
   flags?: string[]
 }
 
-export async function shadowNpmInstall(
+export function shadowNpmInstall<O extends ShadowNpmInstallOptions>(
   opts?: ShadowNpmInstallOptions
-): Promise<Awaited<ReturnType<typeof spawn>>> {
+) {
   const { flags = [], ...spawnOptions } = { __proto__: null, ...opts }
   // Lazily access constants.ENV.
   const { SOCKET_CLI_DEBUG } = constants.ENV
-  return await spawn(
+  return fork(
     // Lazily access constants.execPath.
     constants.execPath,
     [
@@ -44,5 +42,5 @@ export async function shadowNpmInstall(
         ...spawnOptions.env
       }
     }
-  )
+  ) as ForkResult<O extends { stdioString: false } ? Buffer : string, undefined>
 }