@sprucelabs/spruce-cli 18.0.0 → 18.1.1

package/src/__tests__/implementation/SkillStore.test.ts

@@ -1,22 +1,25 @@
 import { test, assert } from '@sprucelabs/test-utils'
 import { errorAssert } from '@sprucelabs/test-utils'
+import SkillStore from '../../features/skill/stores/SkillStore'
 import AbstractCliTest from '../../tests/AbstractCliTest'
 
 export default class SkillStoreTest extends AbstractCliTest {
-	@test()
-	protected static async canInstantiateSkillStore() {
-		assert.isTruthy(this.Store('skill'))
+	private static store: SkillStore
+
+	protected static async beforeEach() {
+		await super.beforeEach()
+		this.store = this.SkillStore()
 	}
 
 	@test()
 	protected static async hasRegisterMethod() {
-		assert.isFunction(this.Store('skill').register)
+		assert.isFunction(this.store.register)
 	}
 
 	@test()
 	protected static async cantRegisterIfNotInSkill() {
 		const err = await assert.doesThrowAsync(() =>
-			this.Store('skill').register({
+			this.store.register({
 				name: 'awesome skill',
 				slug: 'awesome-skill',
 			})
@@ -26,16 +29,14 @@ export default class SkillStoreTest extends AbstractCliTest {
 
 	@test()
 	protected static async cantLoadcurrentSkillIfNotInSkill() {
-		const err = await assert.doesThrowAsync(() =>
-			this.Store('skill').loadCurrentSkill()
-		)
+		const err = await assert.doesThrowAsync(() => this.store.loadCurrentSkill())
 		errorAssert.assertError(err, 'DIRECTORY_NOT_SKILL')
 	}
 
 	@test()
 	protected static async cantCheckIfSkillIsRegisteredNotInSkill() {
 		const err = await assert.doesThrowAsync(() =>
-			this.Store('skill').isCurrentSkillRegistered()
+			this.store.isCurrentSkillRegistered()
 		)
 		errorAssert.assertError(err, 'DIRECTORY_NOT_SKILL')
 	}
@@ -43,8 +44,7 @@ export default class SkillStoreTest extends AbstractCliTest {
 	@test()
 	protected static async canGetNamespace() {
 		await this.FeatureFixture().installCachedFeatures('skills')
-
-		const namespace = await this.Store('skill').loadCurrentSkillsNamespace()
+		const namespace = await this.store.loadCurrentSkillsNamespace()
 		assert.isEqual(namespace, 'TestSkill')
 	}
 
@@ -52,12 +52,9 @@ export default class SkillStoreTest extends AbstractCliTest {
 	protected static async canSetNamespace() {
 		await this.FeatureFixture().installCachedFeatures('skills')
 
-		const store = this.Store('skill')
-		let namespace = await store.loadCurrentSkillsNamespace()
-
-		await this.Store('skill').setCurrentSkillsNamespace('new-namespace')
-
-		namespace = await store.loadCurrentSkillsNamespace()
+		let namespace = await this.store.loadCurrentSkillsNamespace()
+		await this.store.setCurrentSkillsNamespace('new-namespace')
+		namespace = await this.store.loadCurrentSkillsNamespace()
 		assert.isEqual(namespace, 'NewNamespace')
 	}
 
@@ -68,12 +65,10 @@ export default class SkillStoreTest extends AbstractCliTest {
 		const slug = `awesome-skill-${new Date().getTime()}`
 		await this.people.loginAsDemoPerson()
 
-		const skillStore = this.Store('skill')
-
-		let isRegistered = await skillStore.isCurrentSkillRegistered()
+		let isRegistered = await this.store.isCurrentSkillRegistered()
 		assert.isFalse(isRegistered)
 
-		const skill = await skillStore.register({
+		const skill = await this.store.register({
 			name: 'awesome skill',
 			slug,
 		})
@@ -92,10 +87,10 @@ export default class SkillStoreTest extends AbstractCliTest {
 
 		assert.isEqual(results.skill?.id, skill.id)
 
-		isRegistered = await skillStore.isCurrentSkillRegistered()
+		isRegistered = await this.store.isCurrentSkillRegistered()
 		assert.isTrue(isRegistered)
 
-		const currentSkill = await skillStore.loadCurrentSkill()
+		const currentSkill = await this.store.loadCurrentSkill()
 
 		assert.isEqual(currentSkill.id, skill.id)
 		assert.isTrue(currentSkill.isRegistered)
@@ -109,7 +104,7 @@ export default class SkillStoreTest extends AbstractCliTest {
 		assert.isEqual(env.get('SKILL_API_KEY'), skill.apiKey)
 
 		const err = await assert.doesThrowAsync(() =>
-			skillStore.setCurrentSkillsNamespace('test')
+			this.store.setCurrentSkillsNamespace('test')
 		)
 
 		errorAssert.assertError(err, 'GENERIC')
@@ -118,4 +113,8 @@ export default class SkillStoreTest extends AbstractCliTest {
 		const namespace = pkg.get('skill.namespace')
 		assert.isEqual(namespace, slug)
 	}
+
+	private static SkillStore(): SkillStore {
+		return this.Store('skill', {})
+	}
 }

package/src/__tests__/implementation/StoreFeature.test.ts

@@ -12,7 +12,7 @@ export default class StoreFeatureTest extends AbstractCliTest {
 		})
 
 		let hitCount = 0
-		const emitter = this.getEmitter()
+		const emitter = this.emitter
 		await emitter.on(
 			'feature.will-execute',
 			async ({ featureCode, actionCode }) => {

package/src/cli.ts

@@ -20,7 +20,9 @@ import FeatureCommandAttacher, {
 	BlockedCommands,
 	OptionOverrides,
 } from './features/FeatureCommandAttacher'
-import FeatureInstaller from './features/FeatureInstaller'
+import FeatureInstaller, {
+	FeatureInstallerImpl,
+} from './features/FeatureInstaller'
 import FeatureInstallerFactory from './features/FeatureInstallerFactory'
 import { FeatureCode, InstallFeatureOptions } from './features/features.types'
 import CliGlobalEmitter, {
@@ -471,14 +473,16 @@ async function setupInFlightEntertainment(ui: TerminalInterface) {
 		const command = new CommandService(diskUtil.resolvePath(__dirname, '../'))
 		InFlightEntertainment.setup({ command, ui })
 
-		FeatureInstaller.startInFlightIntertainmentHandler = (didUpdateHandler) => {
+		FeatureInstallerImpl.startInFlightIntertainmentHandler = (
+			didUpdateHandler
+		) => {
 			InFlightEntertainment.start()
 			didUpdateHandler((message) => {
 				InFlightEntertainment.writeStatus(message)
 			})
 		}
 
-		FeatureInstaller.stopInFlightIntertainmentHandler = () => {
+		FeatureInstallerImpl.stopInFlightIntertainmentHandler = () => {
 			InFlightEntertainment.stop()
 		}
 	}

package/src/features/AbstractAction.ts

@@ -9,7 +9,7 @@ import ServiceFactory, {
 } from '../services/ServiceFactory'
 import StoreFactory, {
 	StoreCode,
-	StoreFactoryMethodOptions,
+	CreateStoreOptions,
 	StoreMap,
 } from '../stores/StoreFactory'
 import {
@@ -79,9 +79,9 @@ export default abstract class AbstractAction<S extends Schema = Schema>
 
 	protected Store<C extends StoreCode>(
 		code: C,
-		options?: StoreFactoryMethodOptions
+		options?: CreateStoreOptions<C>
 	): StoreMap[C] {
-		return this.storeFactory.Store(code, { cwd: this.cwd, ...options })
+		return this.storeFactory.Store(code, { cwd: this.cwd, ...(options as any) })
 	}
 
 	protected Writer<C extends WriterCode>(

package/src/features/AbstractFeature.ts

@@ -10,7 +10,7 @@ import ServiceFactory, {
 } from '../services/ServiceFactory'
 import StoreFactory, {
 	StoreCode,
-	StoreFactoryMethodOptions,
+	CreateStoreOptions,
 	StoreMap,
 } from '../stores/StoreFactory'
 import {
@@ -28,29 +28,6 @@ import featuresUtil from './feature.utilities'
 import FeatureInstaller from './FeatureInstaller'
 import { FeatureCode } from './features.types'
 
-export interface InstallResults {
-	files?: GeneratedFile[]
-	cwd?: string
-}
-
-export interface FeatureDependency {
-	isRequired: boolean
-	code: FeatureCode
-}
-
-export interface FeatureOptions {
-	cwd: string
-	serviceFactory: ServiceFactory
-	templates: Templates
-	storeFactory: StoreFactory
-	actionFactory?: ActionFactory
-	featureInstaller: FeatureInstaller
-	ui: GraphicsInterface
-	emitter: GlobalEmitter
-	apiClientFactory: ApiClientFactory
-	actionExecuter: ActionExecuter
-}
-
 export default abstract class AbstractFeature<
 	S extends Schema | undefined = Schema | undefined
 > implements ServiceProvider
@@ -162,9 +139,9 @@ export default abstract class AbstractFeature<
 
 	public Store<C extends StoreCode>(
 		code: C,
-		options?: StoreFactoryMethodOptions
+		options?: CreateStoreOptions<C>
 	): StoreMap[C] {
-		return this.storeFactory.Store(code, { cwd: this.cwd, ...options })
+		return this.storeFactory.Store(code, { cwd: this.cwd, ...(options as any) })
 	}
 
 	protected async connectToApi(
@@ -173,3 +150,26 @@ export default abstract class AbstractFeature<
 		return this.apiClientFactory(options)
 	}
 }
+
+export interface InstallResults {
+	files?: GeneratedFile[]
+	cwd?: string
+}
+
+export interface FeatureDependency {
+	isRequired: boolean
+	code: FeatureCode
+}
+
+export interface FeatureOptions {
+	cwd: string
+	serviceFactory: ServiceFactory
+	templates: Templates
+	storeFactory: StoreFactory
+	actionFactory?: ActionFactory
+	featureInstaller: FeatureInstaller
+	ui: GraphicsInterface
+	emitter: GlobalEmitter
+	apiClientFactory: ApiClientFactory
+	actionExecuter: ActionExecuter
+}

package/src/features/ActionExecuter.ts

@@ -14,15 +14,6 @@ import {
 	FeatureActionResponse,
 } from './features.types'
 
-export interface ActionExecuterOptions {
-	ui: GraphicsInterface
-	emitter: GlobalEmitter
-	actionFactory: ActionFactory
-	featureInstallerFactory: () => FeatureInstaller
-	shouldAutoHandleDependencies?: boolean
-	shouldThrowOnListenerError?: boolean
-}
-
 export default class ActionExecuter {
 	private emitter: GlobalEmitter
 	private ui: GraphicsInterface
@@ -201,3 +192,12 @@ export default class ActionExecuter {
 		return action as any
 	}
 }
+
+export interface ActionExecuterOptions {
+	ui: GraphicsInterface
+	emitter: GlobalEmitter
+	actionFactory: ActionFactory
+	featureInstallerFactory: () => FeatureInstaller
+	shouldAutoHandleDependencies?: boolean
+	shouldThrowOnListenerError?: boolean
+}

package/src/features/FeatureInstaller.ts

@@ -17,7 +17,7 @@ import {
 	FeatureMap,
 } from './features.types'
 
-export default class FeatureInstaller implements ServiceProvider {
+export class FeatureInstallerImpl implements ServiceProvider, FeatureInstaller {
 	public cwd: string
 
 	private featureMap: Partial<FeatureMap> = {}
@@ -97,12 +97,12 @@ export default class FeatureInstaller implements ServiceProvider {
 	}
 
 	public getFeatureDependencies<C extends FeatureCode>(
-		featureCode: C,
-		trackedFeatures: FeatureDependency[] = []
+		featureCode: C
+		// trackedFeatures: FeatureDependency[] = []
 	): FeatureDependency[] {
 		let deps = this.getFeatureDependenciesIncludingSelf(
 			{ code: featureCode, isRequired: true },
-			trackedFeatures
+			[] // trackedFeatures
 		).filter((f) => f.code !== featureCode)
 
 		deps = this.sortFeatures(deps)
@@ -170,10 +170,10 @@ export default class FeatureInstaller implements ServiceProvider {
 		const shouldAllowEntertainment = !!features.find((f) => f.code === 'skill')
 
 		if (
-			FeatureInstaller.startInFlightIntertainmentHandler &&
+			FeatureInstallerImpl.startInFlightIntertainmentHandler &&
 			shouldAllowEntertainment
 		) {
-			FeatureInstaller.startInFlightIntertainmentHandler(
+			FeatureInstallerImpl.startInFlightIntertainmentHandler(
 				(handler: InternalUpdateHandler) => {
 					didUpdateHandler = handler
 				}
@@ -193,6 +193,7 @@ export default class FeatureInstaller implements ServiceProvider {
 			didUpdateHandler?.(`Checking if ${code} is installed...`)
 
 			const isInstalled = await this.isInstalled(code)
+
 			if (!isInstalled && installFeatureDependencies) {
 				didUpdateHandler?.(`It is not, checking dependencies...`)
 				dependenciesToInstall = dependenciesToInstall.concat(
@@ -227,6 +228,7 @@ export default class FeatureInstaller implements ServiceProvider {
 					installFeature,
 					didUpdateHandler
 				)
+
 				results = merge(results, installResults)
 			}
 		}
@@ -235,10 +237,10 @@ export default class FeatureInstaller implements ServiceProvider {
 		results = merge(results, pendingResults)
 
 		if (
-			FeatureInstaller.stopInFlightIntertainmentHandler &&
+			FeatureInstallerImpl.stopInFlightIntertainmentHandler &&
 			shouldAllowEntertainment
 		) {
-			FeatureInstaller.stopInFlightIntertainmentHandler()
+			FeatureInstallerImpl.stopInFlightIntertainmentHandler()
 		}
 
 		return results
@@ -308,8 +310,8 @@ export default class FeatureInstaller implements ServiceProvider {
 		features: AbstractFeature[],
 		didUpdateHandler?: InternalUpdateHandler
 	) {
-		if (FeatureInstaller.startInFlightIntertainmentHandler) {
-			FeatureInstaller.startInFlightIntertainmentHandler(
+		if (FeatureInstallerImpl.startInFlightIntertainmentHandler) {
+			FeatureInstallerImpl.startInFlightIntertainmentHandler(
 				(handler: InternalUpdateHandler) => {
 					didUpdateHandler = handler
 				}
@@ -325,8 +327,8 @@ export default class FeatureInstaller implements ServiceProvider {
 
 		await this.installAllPending(didUpdateHandler)
 
-		if (FeatureInstaller.stopInFlightIntertainmentHandler) {
-			FeatureInstaller.stopInFlightIntertainmentHandler()
+		if (FeatureInstallerImpl.stopInFlightIntertainmentHandler) {
+			FeatureInstallerImpl.stopInFlightIntertainmentHandler()
 		}
 	}
 
@@ -341,6 +343,7 @@ export default class FeatureInstaller implements ServiceProvider {
 					this.packagesToInstall.length === 1 ? '' : 's'
 				}. Please be patient.`
 			)
+
 			await pkgService.install(this.packagesToInstall, {})
 		}
 
@@ -350,6 +353,7 @@ export default class FeatureInstaller implements ServiceProvider {
 					this.devPackagesToInstall.length === 1 ? '' : 's'
 				}. Please be patient.`
 			)
+
 			await pkgService.install(this.devPackagesToInstall, {
 				isDev: true,
 			})
@@ -491,3 +495,19 @@ export default class FeatureInstaller implements ServiceProvider {
 		return installed.filter((f) => !!f) as FeatureMap[keyof FeatureMap][]
 	}
 }
+
+export default interface FeatureInstaller {
+	isInstalled(code: FeatureCode): Promise<boolean>
+	markAsSkippedThisRun(code: FeatureCode): void
+	markAsPermanentlySkipped(code: FeatureCode): void
+	isMarkedAsSkipped(code: FeatureCode): boolean
+	getFeature<C extends FeatureCode>(code: C): FeatureMap[C]
+	areInstalled(codes: FeatureCode[]): Promise<boolean>
+	install(options: InstallFeatureOptions): Promise<FeatureInstallResponse>
+	getInstalledFeatures(): Promise<FeatureMap[keyof FeatureMap][]>
+	getFeatureDependencies<C extends FeatureCode>(
+		featureCode: C
+	): FeatureDependency[]
+	getAllCodes(): FeatureCode[]
+	mapFeature<C extends FeatureCode>(code: C, feature: FeatureMap[C]): void
+}

package/src/features/FeatureInstallerFactory.ts

@@ -13,7 +13,7 @@ import DeployFeature from './deploy/DeployFeature'
 import ErrorFeature from './error/ErrorFeature'
 import EventFeature from './event/EventFeature'
 import EventContractFeature from './eventContract/EventContractFeature'
-import FeatureInstaller from './FeatureInstaller'
+import FeatureInstaller, { FeatureInstallerImpl } from './FeatureInstaller'
 import { FeatureCode } from './features.types'
 import LogFeature from './log/LogFeature'
 import NodeFeature from './node/NodeFeature'
@@ -30,6 +30,7 @@ import TestFeature from './test/TestFeature'
 import ViewFeature from './view/ViewFeature'
 import VsCodeFeature from './vscode/VsCodeFeature'
 import WatchFeature from './watch/WatchFeature'
+
 export default class FeatureInstallerFactory {
 	private static readonly features: any[] = [
 		ErrorFeature,
@@ -81,21 +82,14 @@ export default class FeatureInstallerFactory {
 		'permission',
 	]
 
-	public static WithAllFeatures(options: {
-		cwd: string
-		serviceFactory: ServiceFactory
-		storeFactory: StoreFactory
-		featureInstaller?: FeatureInstaller
-		ui: GraphicsInterface
-		emitter: GlobalEmitter
-		apiClientFactory: ApiClientFactory
-		actionExecuter: ActionExecuter
-	}): FeatureInstaller {
+	public static WithAllFeatures(
+		options: InstallerWithAllFeaturesOptions
+	): FeatureInstaller {
 		const { cwd, serviceFactory, storeFactory, ui, emitter, actionExecuter } =
 			options
 
 		const featureInstaller =
-			options.featureInstaller ?? new FeatureInstaller(cwd, serviceFactory)
+			options.featureInstaller ?? new FeatureInstallerImpl(cwd, serviceFactory)
 
 		const featureOptions: FeatureOptions = {
 			cwd,
@@ -111,10 +105,20 @@ export default class FeatureInstallerFactory {
 
 		this.features.forEach((Feature) => {
 			const feature = new Feature(featureOptions)
-
 			featureInstaller.mapFeature(feature.code, feature)
 		})
 
 		return featureInstaller
 	}
 }
+
+interface InstallerWithAllFeaturesOptions {
+	cwd: string
+	serviceFactory: ServiceFactory
+	storeFactory: StoreFactory
+	featureInstaller?: FeatureInstaller
+	ui: GraphicsInterface
+	emitter: GlobalEmitter
+	apiClientFactory: ApiClientFactory
+	actionExecuter: ActionExecuter
+}

package/src/features/OverrideActionDecorator.ts

@@ -109,11 +109,8 @@ export default class OverrideActionDecorator implements FeatureAction {
 	public execute = async (optionsArg: any) => {
 		this.assertCommandIsNotBlocked()
 
-		let { ...options } = optionsArg
-
-		options = this.mixinOptionOverrides(options)
-
-		let response = await this.childAction.execute(options)
+		const options = this.mixinOptionOverrides(optionsArg)
+		const response = await this.childAction.execute(options)
 
 		return response
 	}

package/src/features/event/actions/ListenAction.ts

@@ -157,6 +157,7 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 
 	private async fetchEventContracts(namespace?: string) {
 		const eventStore = this.Store('event')
+
 		const skill = await this.Store('skill').loadCurrentSkill()
 
 		const namespacesForFetch =

package/src/features/event/actions/SetRemoteAction.ts

@@ -8,7 +8,8 @@ const optionsSchema = buildSchema({
 	description: 'Point your skill to different Mercury environments.',
 	fields: {
 		remote: {
-			label: 'Where should remote point?',
+			label: 'Set remote',
+			hint: 'Start with developer and read more here: https://developer.spruce.bot/#/skills/index',
 			type: 'select',
 			isRequired: true,
 			options: {

package/src/features/event/actions/SyncListenersAction.ts

@@ -18,7 +18,6 @@ export default class SyncListenerAction extends AbstractAction<OptionsSchema> {
 	public async execute() {
 		const listeners = await this.Store('listener').loadListeners()
 		const builder = new ListenerTemplateItemBuilder()
-
 		const templateItems = builder.buildTemplateItems({
 			listeners,
 			cwd: this.cwd,

package/src/features/node/NodeFeature.ts

@@ -128,7 +128,9 @@ export default class NodeFeature<
 		pkg.unset('main')
 		pkg.unset('license')
 
-		await this.Store('skill', { cwd }).setCurrentSkillsNamespace(options.name)
+		await this.Store('skill', {
+			cwd,
+		}).setCurrentSkillsNamespace(options.name)
 
 		return {}
 	}

package/src/features/skill/SkillFeature.ts

@@ -134,9 +134,9 @@ export default class SkillFeature<
 
 	public async afterPackageInstall(options: SkillFeatureOptions) {
 		const destination = this.resolveDestination(options)
-		await this.Store('skill', { cwd: destination }).setCurrentSkillsNamespace(
-			options.name
-		)
+		await this.Store('skill', {
+			cwd: destination,
+		}).setCurrentSkillsNamespace(options.name)
 		return {}
 	}
 

package/src/features/skill/stores/SkillStore.ts

@@ -1,13 +1,17 @@
 import { eventResponseUtil } from '@sprucelabs/spruce-event-utils'
 import { namesUtil } from '@sprucelabs/spruce-skill-utils'
 import SpruceError from '../../../errors/SpruceError'
-import AbstractStore from '../../../stores/AbstractStore'
+import AbstractStore, { StoreOptions } from '../../../stores/AbstractStore'
 import { CurrentSkill, RegisteredSkill } from '../../../types/cli.types'
 
 export default class SkillStore extends AbstractStore {
 	public readonly name = 'skill'
 	private static currentSkill?: CurrentSkill
 
+	public constructor(options: StoreOptions<SkillStoreOptions>) {
+		super(options)
+	}
+
 	public static clearCurrentSkill() {
 		this.currentSkill = undefined
 	}
@@ -19,7 +23,7 @@ export default class SkillStore extends AbstractStore {
 		const isRegisteringCurrentSkill =
 			options?.isRegisteringCurrentSkill !== false
 
-		isRegisteringCurrentSkill && this.assertInSkill()
+		isRegisteringCurrentSkill && (await this.assertInSkill())
 
 		const { name, slug, description, isPublished } = values
 		const client = await this.connectToApi()
@@ -43,7 +47,7 @@ export default class SkillStore extends AbstractStore {
 		return skill
 	}
 
-	private assertInSkill() {
+	private async assertInSkill() {
 		const isInstalled = this.Service('settings').isMarkedAsInstalled('skill')
 
 		if (!isInstalled) {
@@ -56,7 +60,7 @@ export default class SkillStore extends AbstractStore {
 			return SkillStore.currentSkill
 		}
 
-		this.assertInSkill()
+		await this.assertInSkill()
 
 		const currentSkill = this.Service('auth').getCurrentSkill()
 
@@ -169,13 +173,14 @@ export default class SkillStore extends AbstractStore {
 	}) {
 		const client = await this.connectToApi()
 
-		const response = await client.emit('list-skills::v2020_12_25', {
-			payload: {
-				...query,
-			},
-		})
-
-		const { skills } = eventResponseUtil.getFirstResponseOrThrow(response)
+		const [{ skills }] = await client.emitAndFlattenResponses(
+			'list-skills::v2020_12_25',
+			{
+				payload: {
+					...query,
+				},
+			}
+		)
 
 		return skills
 	}
@@ -191,3 +196,5 @@ export interface CreateSkill {
 export interface RegisterSkillOptions {
 	isRegisteringCurrentSkill?: boolean
 }
+
+export interface SkillStoreOptions {}

package/src/features/watch/WatchFeature.ts

@@ -89,7 +89,7 @@ export default class WatchFeature extends AbstractFeature {
 		const changes = this.changesSinceLastChange
 		this.changesSinceLastChange = []
 
-		await this.emitter.emit('watcher.did-detect-change', {
+		await this.emitter.emitAndFlattenResponses('watcher.did-detect-change', {
 			changes,
 		})
 	}

package/src/interfaces/SpyInterface.ts

@@ -28,6 +28,7 @@ export default class SpyInterface implements GraphicsInterface {
 	private term?: TerminalInterface
 	private startTime: number
 	private promptTimeout?: any
+	private error?: Error
 
 	public constructor() {
 		this.startTime = new Date().getTime()
@@ -80,6 +81,10 @@ export default class SpyInterface implements GraphicsInterface {
 		clearTimeout(this.promptTimeout)
 	}
 
+	public setError(err: Error) {
+		this.error = err
+	}
+
 	public getLastInvocation() {
 		return this.invocations[this.invocations.length - 1]
 	}
@@ -298,6 +303,11 @@ export default class SpyInterface implements GraphicsInterface {
 					testUtil.log('waitForInput timeout reset because of new output.')
 				}
 			}
+
+			if (this.error) {
+				throw this.error
+			}
+
 			await new Promise((resolve) => setTimeout(resolve, checkInterval))
 		}
 	}