@sprucelabs/spruce-cli 29.0.0 → 29.1.0

package/src/__tests__/support/EventFaker.ts

@@ -1,10 +1,68 @@
 import { SpruceSchemas } from '@sprucelabs/mercury-types'
-import { Organization } from '@sprucelabs/spruce-core-schemas'
+import { Organization, Skill } from '@sprucelabs/spruce-core-schemas'
 import { eventFaker } from '@sprucelabs/spruce-test-fixtures'
 import { generateId } from '@sprucelabs/test-utils'
 import { ListPermContractsTargetAndPayload } from '../../features/permission/stores/PermissionStore'
 
 export default class EventFaker {
+    public async fakeUnregisterSkill(
+        cb?: (targetAndPayload: UnregisterSkillTargetAndPayload) => void
+    ) {
+        await eventFaker.on(
+            'unregister-skill::v2020_12_25',
+            (targetAndPayload) => {
+                cb?.(targetAndPayload)
+                return {}
+            }
+        )
+    }
+    public async fakeRegisterSkill(
+        cb?: (targetAndPayload: RegisterSkillTargetAndPayload) => void | Skill
+    ) {
+        await eventFaker.on(
+            'register-skill::v2020_12_25',
+            (targetAndPayload) => {
+                return {
+                    skill: cb?.(targetAndPayload) ?? {
+                        id: generateId(),
+                        name: generateId(),
+                        slug: generateId(),
+                        apiKey: generateId(),
+                        dateCreated: Date.now(),
+                        creators: [],
+                    },
+                }
+            }
+        )
+    }
+
+    public async fakeSyncPermissionContracts() {
+        await eventFaker.on('sync-permission-contracts::v2020_12_25', () => {
+            return {
+                contractRecords: [],
+            }
+        })
+    }
+    public async fakeRegisterEvents(cb?: () => void) {
+        await eventFaker.on('register-events::v2020_12_25', () => {
+            cb?.()
+            return {
+                fqens: [],
+            }
+        })
+    }
+    public async fakeGetEventContracts() {
+        await eventFaker.on('get-event-contracts::v2020_12_25', () => {
+            return {
+                contracts: [
+                    {
+                        id: generateId(),
+                        eventSignatures: {},
+                    },
+                ],
+            }
+        })
+    }
     public async fakeCreateOrganization(
         cb?: (
             targetAndPayload: CreateOrganizationTargetAndPayload
@@ -31,10 +89,14 @@ export default class EventFaker {
         }
     }
 
-    public async fakeListSkills(cb?: () => void | ListSkill[]) {
-        await eventFaker.on('list-skills::v2020_12_25', () => {
+    public async fakeListSkills(
+        cb?: (
+            targetAndPayload: ListSkillsTargetAndPayload
+        ) => void | ListSkill[]
+    ) {
+        await eventFaker.on('list-skills::v2020_12_25', (targetAndPayload) => {
             return {
-                skills: cb?.() ?? [],
+                skills: cb?.(targetAndPayload) ?? [],
             }
         })
     }
@@ -81,3 +143,12 @@ export default class EventFaker {
 export type ListSkill = SpruceSchemas.Mercury.v2020_12_25.ListSkillsSkill
 export type CreateOrganizationTargetAndPayload =
     SpruceSchemas.Mercury.v2020_12_25.CreateOrganizationEmitTargetAndPayload
+
+export type RegisterSkillTargetAndPayload =
+    SpruceSchemas.Mercury.v2020_12_25.RegisterSkillEmitTargetAndPayload
+
+export type ListSkillsTargetAndPayload =
+    SpruceSchemas.Mercury.v2020_12_25.ListSkillsEmitTargetAndPayload
+
+export type UnregisterSkillTargetAndPayload =
+    SpruceSchemas.Mercury.v2020_12_25.UnregisterSkillEmitTargetAndPayload

package/src/errors/SpruceError.ts

@@ -174,7 +174,7 @@ export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
                 break
 
             case 'SKILL_NOT_REGISTERED':
-                message = `Dang! I can't continue until you register your skill! Run \`spruce login\` and then \`spruce register.skill\` to get the ball rolling!`
+                message = `Dang! I can't continue until you register your skill! Run \`spruce login\` and then \`spruce register\` to get the ball rolling!`
                 break
 
             case 'NO_ORGANIZATIONS_FOUND':

package/src/features/FeatureInstallerFactory.ts

@@ -16,6 +16,7 @@ import EventFeature from './event/EventFeature'
 import EventContractFeature from './eventContract/EventContractFeature'
 import FeatureInstaller, { FeatureInstallerImpl } from './FeatureInstaller'
 import { FeatureCode } from './features.types'
+import GlobalFeature from './global/GlobalFeature'
 import LogFeature from './log/LogFeature'
 import NodeFeature from './node/NodeFeature'
 import OnboardFeature from './onboard/OnboardFeature'
@@ -57,6 +58,7 @@ export default class FeatureInstallerFactory {
         PolishFeature,
         PermissionFeature,
         AgentFeature,
+        GlobalFeature,
     ]
 
     public static readonly featureCodes: FeatureCode[] = [
@@ -83,6 +85,7 @@ export default class FeatureInstallerFactory {
         'polish',
         'permission',
         'agent',
+        'global',
     ]
 
     public static WithAllFeatures(

package/src/features/global/GlobalFeature.ts

@@ -0,0 +1,29 @@
+import { diskUtil, NpmPackage } from '@sprucelabs/spruce-skill-utils'
+import AbstractFeature, { FeatureDependency } from '../AbstractFeature'
+import { FeatureCode } from '../features.types'
+
+export default class GlobalFeature extends AbstractFeature {
+    public code: FeatureCode = 'global'
+    public nameReadable = 'Global'
+    public description =
+        'Place for all global actions that affect your Spruce account (outside your profile).'
+    public dependencies: FeatureDependency[] = []
+    public _packageDependencies: NpmPackage[] = []
+
+    public actionsDir = diskUtil.resolvePath(__dirname, 'actions')
+    public scripts = {}
+
+    public async isInstalled(): Promise<boolean> {
+        return true
+    }
+}
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        global: GlobalFeature
+    }
+
+    interface FeatureOptionsMap {
+        global: undefined
+    }
+}

package/src/features/global/actions/UnregisterSkillAction.ts

@@ -0,0 +1,67 @@
+import { buildSchema } from '@sprucelabs/schema'
+import { ListSkill } from '../../../__tests__/support/EventFaker'
+import SpruceError from '../../../errors/SpruceError'
+import AbstractAction from '../../AbstractAction'
+import { ActionOptions, FeatureActionResponse } from '../../features.types'
+import { SkillStore } from '../../skill/stores/SkillStore'
+
+const optionsSchema = buildSchema({
+    id: 'unregisterSkill',
+    description: 'Unregister a skill from your account.',
+    fields: {},
+})
+
+type OptionsSchema = typeof optionsSchema
+
+export default class UnregisterSkillAction extends AbstractAction<OptionsSchema> {
+    public optionsSchema: OptionsSchema = optionsSchema
+    public commandAliases = ['unregister.skill']
+    public invocationMessage = 'Unregistering skill... 🔧'
+    private skills: SkillStore
+
+    public constructor(options: ActionOptions) {
+        super(options)
+        this.skills = this.Store('skill')
+    }
+
+    public async execute(): Promise<FeatureActionResponse> {
+        const response: FeatureActionResponse = {}
+
+        const skills = await this.skills.fetchMySkills()
+        if (skills.length > 0) {
+            const skillId = await this.ui.prompt({
+                type: 'select',
+                isRequired: true,
+                options: {
+                    choices: skills.map((skill) => this.skillToChoices(skill)),
+                },
+            })
+
+            const match = skills.find((s) => s.id === skillId)
+
+            const confirm = await this.ui.confirm(
+                `Are you sure you want to unregister the skill "${match?.name}"?`
+            )
+
+            if (confirm) {
+                await this.skills.unregisterSkill(skillId)
+                response.summaryLines = [`Unregistered ${match?.name}`]
+            } else {
+                response.summaryLines = ['Unregister cancelled.']
+            }
+        } else {
+            response.errors = [
+                new SpruceError({ code: 'NO_SKILLS_REGISTERED' }),
+            ]
+        }
+
+        return response
+    }
+
+    private skillToChoices(skill: ListSkill): { value: string; label: string } {
+        return {
+            value: skill.id,
+            label: `${skill.slug}: ${skill.name}`,
+        }
+    }
+}

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

@@ -242,6 +242,10 @@ export default class SkillStoreImpl
         return this.fetchAllSkills({ shouldOnlyShowMine: true })
     }
 
+    public static setCurrentSkill(skill: CurrentSkill) {
+        this.currentSkill = skill
+    }
+
     public async fetchAllSkills(query?: {
         shouldOnlyShowMine?: boolean
         namespaces?: string[]

package/src/widgets/terminalKit/TkTextWidget.ts

@@ -154,9 +154,10 @@ export default class TkTextWidget extends TkBaseWidget implements TextWidget {
             return segment
         }
 
-        if ('{}[]()'.includes(segment)) {
+        if (segment.trim().length > 0) {
             // Terminal-kit drops single-character chunks when parsing ANSI
-            // sequences, so pad with a zero-width space to keep braces visible.
+            // sequences, so pad with a zero-width space to keep visible
+            // single characters (digits, braces, etc.) from disappearing.
             return `${segment}​`
         }