@sprucelabs/spruce-cli 20.0.6 → 21.0.0

package/src/services/CommandService.ts

@@ -10,188 +10,201 @@ import SpruceError from '../errors/SpruceError'
 process.setMaxListeners(100)
 
 export default class CommandService {
-	public cwd: string
-	private activeChildProcess: ChildProcess | undefined
-	private ignoreCloseErrors = false
-	private static fakeResponses: {
-		command: string | RegExp
-		response: MockResponse
-	}[] = []
-	private static commandsRunCapturedByMockResponses: string[] = []
-
-	public constructor(cwd: string) {
-		this.cwd = cwd
-	}
-
-	public async execute(
-		cmd: string,
-		options?: {
-			ignoreErrors?: boolean
-			args?: string[]
-			shouldStream?: boolean
-			outStream?: Writable
-			onError?: (error: string) => void
-			onData?: (data: string) => void
-			spawnOptions?: SpawnOptions
-			forceColor?: boolean
-			env?: Record<string, any>
-		}
-	): Promise<{
-		stdout: string
-	}> {
-		const cwd = this.cwd
-		const args = options?.args || stringArgv(cmd)
-		const executable = options?.args ? cmd : args.shift()
-		const boundKill = this.kill.bind(this)
-
-		if (!executable) {
-			throw new Error('Bad params sent to command service')
-		}
-
-		const { mockResponse, mockKey } = this.getMockResponse(executable, args)
-
-		if (mockResponse) {
-			CommandService.commandsRunCapturedByMockResponses.push(mockKey)
-			mockResponse.callback?.(executable, args)
-
-			if (mockResponse.code !== 0) {
-				throw new SpruceError({
-					code: 'EXECUTING_COMMAND_FAILED',
-					cmd: `${executable} ${args.join(' ')}`,
-					cwd,
-					stdout: mockResponse.stdout,
-					stderr: mockResponse.stderr,
-				})
-			}
-
-			return { stdout: mockResponse.stdout ?? '' }
-		}
-
-		process.on('exit', boundKill)
-
-		return new Promise((resolve, reject) => {
-			let stdout = ''
-			let stderr = ''
-			const spawnOptions: SpawnOptions = options?.shouldStream
-				? {
-						stdio: 'inherit',
-						cwd,
-						env: {
-							PATH: process.env.PATH,
-							IS_CLI: 'true',
-							FORCE_COLOR: options?.forceColor ? '1' : '0',
-							...options?.env,
-						},
-					}
-				: {
-						cwd,
-						env: {
-							PATH: process.env.PATH,
-							IS_CLI: 'true',
-							FORCE_COLOR: options?.forceColor ? '1' : '0',
-							...options?.env,
-						},
-						shell: true,
-						...options?.spawnOptions,
-					}
-
-			const child = spawn(executable, args, spawnOptions)
-			this.activeChildProcess = child
-
-			if (options?.outStream) {
-				child.stdout?.pipe(options.outStream)
-			}
-
-			child.stdout?.addListener('data', (data) => {
-				options?.onData?.(data.toString())
-				stdout += data
-			})
-
-			child.stderr?.addListener('data', (data) => {
-				options?.onError?.(data.toString())
-				stderr += data
-			})
-
-			const closeHandler = (code: number) => {
-				process.off('exit', boundKill)
-
-				if (!this.activeChildProcess) {
-					return
-				}
-				this.activeChildProcess = undefined
-
-				setTimeout(() => {
-					child.stdout?.removeAllListeners()
-					child.stderr?.removeAllListeners()
-					child.removeAllListeners()
-
-					if (code === 0 || this.ignoreCloseErrors || options?.ignoreErrors) {
-						resolve({ stdout })
-						this.ignoreCloseErrors = false
-					} else {
-						if (stderr.search(escapeRegExp(ERROR_DIVIDER)) > -1) {
-							const stderrParts = stderr.split(ERROR_DIVIDER)
-							const err = AbstractSpruceError.parse(stderrParts[1], SpruceError)
-							reject(err)
-							return
-						}
-
-						reject(
-							new SpruceError({
-								code: 'EXECUTING_COMMAND_FAILED',
-								cmd: `${executable} ${args.join(' ')}`,
-								cwd,
-								stdout,
-								stderr,
-							})
-						)
-					}
-				}, 0)
-			}
-
-			child.addListener('close', closeHandler)
-			child.addListener('exit', closeHandler)
-		})
-	}
-
-	public kill = () => {
-		if (this.activeChildProcess?.pid) {
-			this.ignoreCloseErrors = true
-			treeKill(this.activeChildProcess.pid, 'SIGTERM')
-		}
-	}
-
-	public pid = () => {
-		return this.activeChildProcess?.pid
-	}
-
-	private getMockResponse(executable: string, args: string[]) {
-		const mockKey = `${executable} ${args.join(' ')}`.trim()
-		const commands = CommandService.fakeResponses
-		const match = commands.find((r) =>
-			r.command instanceof RegExp
-				? mockKey.search(r.command) > -1
-				: r.command.replace(/ +/gis, '') === mockKey.replace(/ +/gis, '')
-		)
-
-		return { mockResponse: match?.response, mockKey }
-	}
-
-	public static fakeCommand(command: string | RegExp, response: MockResponse) {
-		this.fakeResponses.unshift({
-			command,
-			response,
-		})
-	}
-
-	public static clearFakedResponses() {
-		this.fakeResponses = []
-	}
+    public cwd: string
+    private activeChildProcess: ChildProcess | undefined
+    private ignoreCloseErrors = false
+    private static fakeResponses: {
+        command: string | RegExp
+        response: FakedCommandResponse
+    }[] = []
+    private static commandsRunCapturedByMockResponses: string[] = []
+
+    public constructor(cwd: string) {
+        this.cwd = cwd
+    }
+
+    public async execute(
+        cmd: string,
+        options?: {
+            ignoreErrors?: boolean
+            args?: string[]
+            shouldStream?: boolean
+            outStream?: Writable
+            onError?: (error: string) => void
+            onData?: (data: string) => void
+            spawnOptions?: SpawnOptions
+            forceColor?: boolean
+            env?: Record<string, any>
+        }
+    ): Promise<{
+        stdout: string
+    }> {
+        const cwd = this.cwd
+        const args = options?.args || stringArgv(cmd)
+        const executable = options?.args ? cmd : args.shift()
+        const boundKill = this.kill.bind(this)
+
+        if (!executable) {
+            throw new Error('Bad params sent to command service')
+        }
+
+        const { mockResponse, mockKey } = this.getMockResponse(executable, args)
+
+        if (mockResponse) {
+            CommandService.commandsRunCapturedByMockResponses.push(mockKey)
+            mockResponse.callback?.(executable, args)
+
+            if (mockResponse.code !== 0) {
+                throw new SpruceError({
+                    code: 'EXECUTING_COMMAND_FAILED',
+                    cmd: `${executable} ${args.join(' ')}`,
+                    cwd,
+                    stdout: mockResponse.stdout,
+                    stderr: mockResponse.stderr,
+                })
+            }
+
+            return { stdout: mockResponse.stdout ?? '' }
+        }
+
+        process.on('exit', boundKill)
+
+        return new Promise((resolve, reject) => {
+            let stdout = ''
+            let stderr = ''
+            const spawnOptions: SpawnOptions = options?.shouldStream
+                ? {
+                      stdio: 'inherit',
+                      cwd,
+                      env: {
+                          PATH: process.env.PATH,
+                          IS_CLI: 'true',
+                          FORCE_COLOR: options?.forceColor ? '1' : '0',
+                          ...options?.env,
+                      },
+                  }
+                : {
+                      cwd,
+                      env: {
+                          PATH: process.env.PATH,
+                          IS_CLI: 'true',
+                          FORCE_COLOR: options?.forceColor ? '1' : '0',
+                          ...options?.env,
+                      },
+                      shell: true,
+                      ...options?.spawnOptions,
+                  }
+
+            const child = spawn(executable, args, spawnOptions)
+            this.activeChildProcess = child
+
+            if (options?.outStream) {
+                child.stdout?.pipe(options.outStream)
+            }
+
+            child.stdout?.addListener('data', (data) => {
+                options?.onData?.(data.toString())
+                stdout += data
+            })
+
+            child.stderr?.addListener('data', (data) => {
+                options?.onError?.(data.toString())
+                stderr += data
+            })
+
+            const closeHandler = (code: number) => {
+                process.off('exit', boundKill)
+
+                if (!this.activeChildProcess) {
+                    return
+                }
+                this.activeChildProcess = undefined
+
+                setTimeout(() => {
+                    child.stdout?.removeAllListeners()
+                    child.stderr?.removeAllListeners()
+                    child.removeAllListeners()
+
+                    if (
+                        code === 0 ||
+                        this.ignoreCloseErrors ||
+                        options?.ignoreErrors
+                    ) {
+                        resolve({ stdout })
+                        this.ignoreCloseErrors = false
+                    } else {
+                        if (stderr.search(escapeRegExp(ERROR_DIVIDER)) > -1) {
+                            const stderrParts = stderr.split(ERROR_DIVIDER)
+                            const err = AbstractSpruceError.parse(
+                                stderrParts[1],
+                                SpruceError
+                            )
+                            reject(err)
+                            return
+                        }
+
+                        reject(
+                            new SpruceError({
+                                code: 'EXECUTING_COMMAND_FAILED',
+                                cmd: `${executable} ${args.join(' ')}`,
+                                cwd,
+                                stdout,
+                                stderr,
+                            })
+                        )
+                    }
+                }, 0)
+            }
+
+            child.addListener('close', closeHandler)
+            child.addListener('exit', closeHandler)
+        })
+    }
+
+    public kill = () => {
+        if (this.activeChildProcess?.pid) {
+            this.ignoreCloseErrors = true
+            treeKill(this.activeChildProcess.pid, 'SIGTERM')
+        }
+    }
+
+    public pid = () => {
+        return this.activeChildProcess?.pid
+    }
+
+    private getMockResponse(executable: string, args: string[]) {
+        const mockKey = `${executable} ${args.join(' ')}`.trim()
+        const commands = CommandService.fakeResponses
+        const match = commands.find((r) =>
+            r.command instanceof RegExp
+                ? mockKey.search(r.command) > -1
+                : r.command.replace(/ +/gis, '') ===
+                  mockKey.replace(/ +/gis, '')
+        )
+
+        return { mockResponse: match?.response, mockKey }
+    }
+
+    public static fakeCommand(
+        command: string | RegExp,
+        response: FakedCommandResponse
+    ) {
+        this.fakeResponses.unshift({
+            command,
+            response,
+        })
+    }
+
+    public static clearFakedResponses() {
+        this.fakeResponses = []
+    }
 }
 
-interface MockResponse {
-	code: number
-	stdout?: string
-	stderr?: string
-	callback?: (executable: string, args: any[]) => void
+export type FakedCommandCallback = (executable: string, args: any[]) => void
+
+interface FakedCommandResponse {
+    code: number
+    stdout?: string
+    stderr?: string
+    callback?: FakedCommandCallback
 }

package/src/services/DependencyService.ts

@@ -2,40 +2,40 @@ import { SettingsService } from '@sprucelabs/spruce-skill-utils'
 import SpruceError from '../errors/SpruceError'
 
 interface Dependency {
-	id: string
-	namespace: string
+    id: string
+    namespace: string
 }
 
 export default class DependencyService {
-	private settings: SettingsService<string>
-	public constructor(settings: SettingsService) {
-		this.settings = settings
-	}
+    private settings: SettingsService<string>
+    public constructor(settings: SettingsService) {
+        this.settings = settings
+    }
 
-	public set(dependencies: Dependency[]) {
-		this.settings.set('dependencies', dependencies)
-	}
+    public set(dependencies: Dependency[]) {
+        this.settings.set('dependencies', dependencies)
+    }
 
-	public add(dependency: Dependency) {
-		this.assertDependencyDoesNotExist(dependency.namespace)
+    public add(dependency: Dependency) {
+        this.assertDependencyDoesNotExist(dependency.namespace)
 
-		const dependencies = this.settings.get('dependencies') ?? []
-		dependencies.push(dependency)
-		this.settings.set('dependencies', dependencies)
-	}
-	private assertDependencyDoesNotExist(namespace: string) {
-		const dependencies = this.get()
-		const match = dependencies.find((d) => d.namespace === namespace)
+        const dependencies = this.settings.get('dependencies') ?? []
+        dependencies.push(dependency)
+        this.settings.set('dependencies', dependencies)
+    }
+    private assertDependencyDoesNotExist(namespace: string) {
+        const dependencies = this.get()
+        const match = dependencies.find((d) => d.namespace === namespace)
 
-		if (match) {
-			throw new SpruceError({
-				code: 'DEPENDENCY_EXISTS',
-				namespace,
-			})
-		}
-	}
+        if (match) {
+            throw new SpruceError({
+                code: 'DEPENDENCY_EXISTS',
+                namespace,
+            })
+        }
+    }
 
-	public get(): Dependency[] {
-		return this.settings.get('dependencies') ?? []
-	}
+    public get(): Dependency[] {
+        return this.settings.get('dependencies') ?? []
+    }
 }

package/src/services/GameService.ts

@@ -3,57 +3,57 @@ import TerminalInterface from '../interfaces/TerminalInterface'
 import CommandService from './CommandService'
 
 export default class GameService {
-	private command: CommandService
-	private ui: TerminalInterface
-	private statusMessage?: string
-	private killed = false
+    private command: CommandService
+    private ui: TerminalInterface
+    private statusMessage?: string
+    private killed = false
 
-	public constructor(command: CommandService, ui: TerminalInterface) {
-		this.command = command
-		this.ui = ui
-		this.command.cwd = diskUtil.resolvePath(__dirname, '../../')
-	}
+    public constructor(command: CommandService, ui: TerminalInterface) {
+        this.command = command
+        this.ui = ui
+        this.command.cwd = diskUtil.resolvePath(__dirname, '../../')
+    }
 
-	public setStatusMessage(message: string) {
-		this.statusMessage = message
-	}
+    public setStatusMessage(message: string) {
+        this.statusMessage = message
+    }
 
-	public async play(introductionSentences: string[] = []) {
-		const sentencesToPlay = [...introductionSentences]
-		await this.ui.stopLoading()
-		this.killed = false
+    public async play(introductionSentences: string[] = []) {
+        const sentencesToPlay = [...introductionSentences]
+        await this.ui.stopLoading()
+        this.killed = false
 
-		while (sentencesToPlay.length > 0) {
-			const next = sentencesToPlay.shift() as string
-			this.ui.renderLine(next)
-			await new Promise((r) => setTimeout(r, 2000))
-			if (this.killed) {
-				return
-			}
-		}
+        while (sentencesToPlay.length > 0) {
+            const next = sentencesToPlay.shift() as string
+            this.ui.renderLine(next)
+            await new Promise((r) => setTimeout(r, 2000))
+            if (this.killed) {
+                return
+            }
+        }
 
-		await this.command.execute('node ./node_modules/.bin/js-tetris-cli', {
-			spawnOptions: {
-				stdio: [process.stdin, 'pipe', 'pipe'],
-			},
-			onData: (data: string) => {
-				if (!this.killed) {
-					process.stdout?.write(data)
-					if (this.statusMessage) {
-						this.ui.saveCursor()
-						this.ui.moveCursorTo(0, 25)
-						this.ui.clearBelowCursor()
-						process.stdout?.write(this.statusMessage)
-						this.ui.restoreCursor()
-					}
-				}
-			},
-		})
-	}
+        await this.command.execute('node ./node_modules/.bin/js-tetris-cli', {
+            spawnOptions: {
+                stdio: [process.stdin, 'pipe', 'pipe'],
+            },
+            onData: (data: string) => {
+                if (!this.killed) {
+                    process.stdout?.write(data)
+                    if (this.statusMessage) {
+                        this.ui.saveCursor()
+                        this.ui.moveCursorTo(0, 25)
+                        this.ui.clearBelowCursor()
+                        process.stdout?.write(this.statusMessage)
+                        this.ui.restoreCursor()
+                    }
+                }
+            },
+        })
+    }
 
-	public kill() {
-		this.killed = true
-		this.command.kill()
-		this.ui.clear()
-	}
+    public kill() {
+        this.killed = true
+        this.command.kill()
+        this.ui.clear()
+    }
 }