@stream44.studio/t44 0.4.0-rc.24

package/caps/SigningKey.ts

@@ -0,0 +1,243 @@
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#@stream44.studio/t44/structs/WorkspaceConfig': {
+                as: '$WorkspaceConfig'
+            },
+            '#@stream44.studio/t44/structs/SigningKeyConfig': {
+                as: '$SigningKeyConfig'
+            },
+            '#': {
+                Home: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/Home'
+                },
+                WorkspacePrompt: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/WorkspacePrompt'
+                },
+                ensureKey: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<{ keyName: string; privateKeyPath: string; publicKey: string; keyFingerprint: string } | null> {
+                        const { join } = await import('path')
+                        const { readFile, stat: statFile } = await import('fs/promises')
+                        const chalk = (await import('chalk')).default
+                        const {
+                            discoverEd25519Keys,
+                            validateConfiguredKey,
+                            ensurePassphrase,
+                            ensureKeyInAgent,
+                            computeFingerprint,
+                            promptPassphrase,
+                            generateEd25519Key
+                        } = await import('../lib/key.js')
+
+                        const workspaceConfig = await this.$WorkspaceConfig.config
+                        const keyConfig = await this.$SigningKeyConfig.config
+                        const sshDir = await this.Home.sshDir
+
+                        // --- Already configured: validate ---
+                        if (keyConfig?.name && keyConfig?.privateKeyPath && keyConfig?.publicKey && keyConfig?.keyFingerprint) {
+                            const valid = await validateConfiguredKey(keyConfig, 'Signing Key')
+                            if (!valid) {
+                                return null
+                            }
+                            return {
+                                keyName: keyConfig.name,
+                                privateKeyPath: keyConfig.privateKeyPath,
+                                publicKey: keyConfig.publicKey,
+                                keyFingerprint: keyConfig.keyFingerprint
+                            }
+                        }
+
+                        // --- Not configured: discover or create ---
+                        console.log(chalk.cyan(`\n🔏 Signing Key Setup\n`))
+                        console.log(chalk.gray(`   Workspace: ${workspaceConfig?.name || 'unknown'}`))
+                        console.log(chalk.gray(`   Root: ${workspaceConfig?.rootDir || 'unknown'}`))
+                        console.log(chalk.gray(''))
+                        console.log(chalk.gray('   The signing key is an Ed25519 SSH key used for code and artifact signing.'))
+                        console.log(chalk.gray(`   You can select an existing key from ${sshDir} or create a new one.`))
+                        console.log(chalk.gray(''))
+
+                        // Discover existing Ed25519 keys in ~/.ssh
+                        const existingKeys = await discoverEd25519Keys(sshDir)
+
+                        // Build choices
+                        const choices: Array<{ name: string; value: any }> = []
+
+                        for (const key of existingKeys) {
+                            choices.push({
+                                name: `${key.name}  ${chalk.gray(key.publicKey.substring(0, 60) + '...')}`,
+                                value: { type: 'existing', ...key }
+                            })
+                        }
+
+                        choices.push({
+                            name: chalk.yellow('+ Create a new Ed25519 key'),
+                            value: { type: 'create' }
+                        })
+
+                        const selected = await this.WorkspacePrompt.select({
+                            message: 'Select an Ed25519 key for signing:',
+                            choices,
+                            defaultValue: { type: 'create' },
+                            pageSize: 15
+                        })
+
+                        let keyName: string
+                        let privateKeyPath: string
+                        let publicKey: string
+                        let keyFingerprint: string
+
+                        if (selected.type === 'existing') {
+                            keyName = selected.name
+                            privateKeyPath = selected.privateKeyPath
+                            publicKey = selected.publicKey
+                            keyFingerprint = computeFingerprint(selected.privateKeyPath)
+
+                            // Ensure selected existing key has a passphrase
+                            const passphraseOk = await ensurePassphrase(privateKeyPath, keyName, 'Signing key')
+                            if (!passphraseOk) {
+                                return null
+                            }
+
+                            // Add to ssh-agent
+                            await ensureKeyInAgent(privateKeyPath, keyName, 'Signing key')
+                        } else {
+                            // Prompt for key name
+                            keyName = await this.WorkspacePrompt.input({
+                                message: 'Enter a name for the new signing key:',
+                                defaultValue: 'id_t44_signing_ed25519',
+                                validate: (input: string) => {
+                                    if (!input || input.trim().length === 0) {
+                                        return 'Key name cannot be empty'
+                                    }
+                                    if (!/^[a-zA-Z0-9_.-]+$/.test(input)) {
+                                        return 'Key name can only contain letters, numbers, underscores, dots, and hyphens'
+                                    }
+                                    return true
+                                }
+                            })
+
+                            privateKeyPath = join(sshDir, keyName)
+
+                            // Check if file already exists
+                            let exists = false
+                            try {
+                                await statFile(privateKeyPath)
+                                exists = true
+                            } catch { }
+
+                            if (exists) {
+                                console.log(chalk.red(`\n   ✗ File already exists: ${privateKeyPath}`))
+                                console.log(chalk.red(`     Choose a different name or select the existing key.\n`))
+                                return null
+                            }
+
+                            // Prompt for passphrase
+                            console.log(chalk.cyan(`\n   Generating Ed25519 signing key '${keyName}'...`))
+                            console.log(chalk.gray(`   The key will be protected with a passphrase and added to the macOS Keychain.\n`))
+
+                            const envPassphrase = process.env.T44_KEYS_PASSPHRASE
+                            const passphrase = envPassphrase || await promptPassphrase()
+                            if (!passphrase) {
+                                console.log(chalk.red(`\n   ✗ A passphrase is required for the signing key.\n`))
+                                return null
+                            }
+
+                            const result = await generateEd25519Key(privateKeyPath, passphrase, 't44-signing-key')
+                            if (!result) {
+                                return null
+                            }
+
+                            publicKey = result.publicKey
+                            keyFingerprint = result.keyFingerprint
+
+                            console.log(chalk.green(`   ✓ Signing key generated:`))
+                            console.log(chalk.green(`     ${privateKeyPath}`))
+                            console.log(chalk.green(`     ${privateKeyPath}.pub\n`))
+
+                            // Add the new key to the ssh-agent with Keychain storage
+                            if (!envPassphrase) {
+                                await ensureKeyInAgent(privateKeyPath, keyName, 'Signing key')
+                            }
+                        }
+
+                        // Store in config
+                        await this.$SigningKeyConfig.setConfigValue(['name'], keyName)
+                        await this.$SigningKeyConfig.setConfigValue(['privateKeyPath'], privateKeyPath)
+                        await this.$SigningKeyConfig.setConfigValue(['publicKey'], publicKey)
+                        await this.$SigningKeyConfig.setConfigValue(['keyFingerprint'], keyFingerprint)
+
+                        console.log(chalk.green(`   ✓ Signing key configured: ${keyName}`))
+                        console.log(chalk.green(`     ${keyFingerprint}\n`))
+
+                        return { keyName, privateKeyPath, publicKey, keyFingerprint }
+                    }
+                },
+                getKeyPath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<string | null> {
+                        const keyConfig = await this.$SigningKeyConfig.config
+
+                        if (!keyConfig?.privateKeyPath) {
+                            return null
+                        }
+
+                        return keyConfig.privateKeyPath
+                    }
+                },
+                getPublicKey: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<string | null> {
+                        const keyConfig = await this.$SigningKeyConfig.config
+
+                        if (!keyConfig?.publicKey) {
+                            return null
+                        }
+
+                        return keyConfig.publicKey
+                    }
+                },
+                getFingerprint: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<string | null> {
+                        const keyConfig = await this.$SigningKeyConfig.config
+
+                        if (!keyConfig?.keyFingerprint) {
+                            return null
+                        }
+
+                        return keyConfig.keyFingerprint
+                    }
+                },
+                getKeyName: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<string | null> {
+                        const keyConfig = await this.$SigningKeyConfig.config
+
+                        if (!keyConfig?.name) {
+                            return null
+                        }
+
+                        return keyConfig.name
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/SigningKey'

package/caps/TaskWorkflow.ts

@@ -0,0 +1,192 @@
+
+type TaskType = 'serial' | 'parallel' | 'step';
+
+type Task = {
+    type: TaskType;
+    name: string;
+    fn: () => void | Promise<void>;
+    children: Task[];
+    timeout?: number;
+};
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+
+                lib: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/ProjectTestLib',
+                },
+
+                _rootTasks: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: [] as Task[],
+                },
+
+                _currentParent: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: null as Task | null,
+                },
+
+                _breadcrumb: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: [] as string[],
+                },
+
+                exitOnComplete: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: true,
+                },
+
+                serial: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, name: string, fn: () => void | Promise<void>) {
+                        const task: Task = {
+                            type: 'serial',
+                            name,
+                            fn,
+                            children: []
+                        };
+
+                        if (this._currentParent) {
+                            this._currentParent.children.push(task);
+                        } else {
+                            this._rootTasks.push(task);
+                        }
+
+                        const previousParent = this._currentParent;
+                        this._currentParent = task;
+                        fn();
+                        this._currentParent = previousParent;
+                    }
+                },
+
+                parallel: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, name: string, fn: () => void | Promise<void>) {
+                        const task: Task = {
+                            type: 'parallel',
+                            name,
+                            fn,
+                            children: []
+                        };
+
+                        if (this._currentParent) {
+                            this._currentParent.children.push(task);
+                        } else {
+                            this._rootTasks.push(task);
+                        }
+
+                        const previousParent = this._currentParent;
+                        this._currentParent = task;
+                        fn();
+                        this._currentParent = previousParent;
+                    }
+                },
+
+                step: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, name: string, fn: () => void | Promise<void>, timeout?: number) {
+                        const task: Task = {
+                            type: 'step',
+                            name,
+                            fn,
+                            children: [],
+                            timeout,
+                        };
+
+                        if (this._currentParent) {
+                            this._currentParent.children.push(task);
+                        } else {
+                            this._rootTasks.push(task);
+                        }
+                    }
+                },
+
+                _executeTask: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, task: Task): Promise<void> {
+                        const previousBreadcrumb = [...this._breadcrumb];
+                        this._breadcrumb.push(task.name);
+                        const trail = this._breadcrumb.join(' -> ');
+
+                        const colors = {
+                            reset: '\x1b[0m',
+                            blue: '\x1b[34m',
+                            cyan: '\x1b[36m',
+                            magenta: '\x1b[35m',
+                            green: '\x1b[32m',
+                            red: '\x1b[31m',
+                        };
+
+                        let startSymbol = '▶';
+                        let color = colors.reset;
+
+                        if (task.type === 'serial') {
+                            startSymbol = '⚡';
+                            color = colors.blue;
+                        } else if (task.type === 'parallel') {
+                            startSymbol = '⚙';
+                            color = colors.magenta;
+                        } else {
+                            startSymbol = '▸';
+                            color = colors.cyan;
+                        }
+
+                        console.log(`${color}${startSymbol} ${trail}${colors.reset}`);
+
+                        try {
+                            if (task.type === 'serial') {
+                                for (const child of task.children) {
+                                    await this._executeTask(child);
+                                }
+                            } else if (task.type === 'parallel') {
+                                await Promise.all(task.children.map((child: Task) => this._executeTask(child)));
+                            } else {
+                                await task.fn();
+                            }
+                            console.log(`${colors.green}✓ ${trail}${colors.reset}`);
+                        } catch (error) {
+                            console.log(`${colors.red}✗ ${trail}${colors.reset}`);
+                            throw error;
+                        } finally {
+                            this._breadcrumb = previousBreadcrumb;
+                        }
+                    }
+                },
+
+                run: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<void> {
+                        try {
+                            for (const task of this._rootTasks) {
+                                await this._executeTask(task);
+                            }
+                        } finally {
+                            this._rootTasks = [];
+                            this._breadcrumb = [];
+                            this._currentParent = null;
+                        }
+
+                        if (this.exitOnComplete) process.exit(0);
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/TaskWorkflow'