@stream44.studio/t44 0.4.0-rc.24

package/caps/ProjectTestLib.ts

@@ -0,0 +1,257 @@
+import * as path from 'path'
+import * as fsPromises from 'fs/promises'
+import { constants as fsConstants } from 'fs'
+import { spawn } from 'bun'
+
+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': {},
+            '#': {
+                path: {
+                    type: CapsulePropertyTypes.Constant,
+                    value: path,
+                },
+
+                fs: {
+                    type: CapsulePropertyTypes.Constant,
+                    value: {
+                        ...fsPromises,
+                        ...fsConstants
+                    },
+                },
+
+                spawnProcess: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: any): Promise<any> {
+                        const {
+                            cmd,
+                            cwd = process.cwd(),
+                            waitForReady = false,
+                            readySignal = 'READY',
+                            waitForExit = false,
+                            showOutput = false,
+                            env = {},
+                            verbose = false,
+                            detached = false
+                        } = options;
+
+                        const outputData = { stdout: '', stderr: '' };
+                        const mergedEnv = { ...process.env, ...env };
+
+                        if (verbose && env.NODE_ENV) {
+                            console.log('[spawnProcess] Setting NODE_ENV to:', env.NODE_ENV);
+                            console.log('[spawnProcess] Merged env NODE_ENV:', mergedEnv.NODE_ENV);
+                        }
+
+                        const proc = spawn({
+                            cmd,
+                            cwd,
+                            stdout: 'pipe',
+                            stderr: 'pipe',
+                            env: mergedEnv
+                        });
+
+                        if (detached && proc.unref) {
+                            proc.unref();
+                        }
+
+                        let readySignalFound: (() => void) | null = null;
+                        const readyPromise = waitForReady ? new Promise<void>((resolve) => {
+                            readySignalFound = resolve;
+                        }) : null;
+
+                        if (proc.stdout && !detached) {
+                            const reader = (proc.stdout as any).getReader();
+                            const decoder = new TextDecoder();
+                            (async () => {
+                                try {
+                                    while (true) {
+                                        const { done, value } = await reader.read();
+                                        if (done) break;
+                                        const chunk = decoder.decode(value);
+                                        outputData.stdout += chunk;
+                                        if (waitForReady && readySignalFound && chunk.indexOf(readySignal) !== -1) {
+                                            readySignalFound();
+                                            readySignalFound = null;
+                                        }
+                                        if (showOutput || verbose) {
+                                            process.stdout.write(chunk);
+                                        }
+                                    }
+                                } catch (e) {
+                                    // Stream closed
+                                }
+                            })();
+                        }
+
+                        if (proc.stderr && !detached) {
+                            const reader = (proc.stderr as any).getReader();
+                            const decoder = new TextDecoder();
+                            (async () => {
+                                try {
+                                    while (true) {
+                                        const { done, value } = await reader.read();
+                                        if (done) break;
+                                        const chunk = decoder.decode(value);
+                                        outputData.stderr += chunk;
+                                        if (waitForReady && readySignalFound && chunk.indexOf(readySignal) !== -1) {
+                                            readySignalFound();
+                                            readySignalFound = null;
+                                        }
+                                        if (showOutput || verbose) {
+                                            process.stderr.write(chunk);
+                                        }
+                                    }
+                                } catch (e) {
+                                    // Stream closed
+                                }
+                            })();
+                        }
+
+                        if (waitForReady && readyPromise) {
+                            await Promise.race([
+                                readyPromise,
+                                proc.exited.then(() => {
+                                    throw new Error(`Process exited with code ${proc.exitCode} before emitting ${readySignal} signal. stderr: ${outputData.stderr}`);
+                                })
+                            ]);
+                        } else if (waitForExit) {
+                            await proc.exited;
+                        }
+
+                        return {
+                            process: proc,
+                            stdout: outputData.stdout,
+                            stderr: outputData.stderr,
+                            exitCode: proc.exitCode ?? 0,
+                            getStdout: () => outputData.stdout,
+                            getStderr: () => outputData.stderr
+                        };
+                    }
+                },
+
+                runPackageScript: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: any): Promise<any> {
+                        const {
+                            runtime = 'bun',
+                            script,
+                            args = [],
+                            cwd,
+                            env,
+                            verbose = false
+                        } = options;
+
+                        const cmdArgs = [...args];
+                        if (cmdArgs.length) {
+                            cmdArgs.unshift('--')
+                        }
+
+                        const spawned = await this.spawnProcess({
+                            cmd: [runtime, 'run', script, ...cmdArgs],
+                            cwd,
+                            waitForReady: false,
+                            waitForExit: true,
+                            env,
+                            verbose
+                        });
+
+                        return {
+                            exitCode: spawned.exitCode,
+                            stdout: spawned.stdout,
+                            stderr: spawned.stderr
+                        };
+                    }
+                },
+
+                waitForFetch: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: any): Promise<boolean | Response> {
+                        const {
+                            url,
+                            method = 'GET',
+                            headers,
+                            body,
+                            status,
+                            retryDelayMs = 1000,
+                            requestTimeoutMs = 2000,
+                            timeoutMs = 30000,
+                            verbose = false,
+                            returnResponse = false
+                        } = options;
+
+                        const startTime = Date.now();
+                        let attemptCount = 0;
+
+                        while (Date.now() - startTime < timeoutMs) {
+                            attemptCount++;
+                            const elapsed = Date.now() - startTime;
+
+                            try {
+                                const response = await fetch(url, {
+                                    method,
+                                    headers,
+                                    body,
+                                    signal: AbortSignal.timeout(requestTimeoutMs)
+                                });
+
+                                if (status === true) {
+                                    if (verbose) {
+                                        console.log(`[waitForFetch] URL ${url} responded (status: ${response.status}) after ${attemptCount} attempts (${elapsed}ms)`);
+                                    }
+                                    return returnResponse ? response : true;
+                                } else if (typeof status === 'number') {
+                                    if (response.status === status) {
+                                        if (verbose) {
+                                            console.log(`[waitForFetch] URL ${url} responded with status ${status} after ${attemptCount} attempts (${elapsed}ms)`);
+                                        }
+                                        return returnResponse ? response : true;
+                                    } else {
+                                        if (verbose) {
+                                            console.log(`[waitForFetch] Attempt ${attemptCount}: Got status ${response.status}, expected ${status} (${elapsed}ms)`);
+                                        }
+                                    }
+                                }
+                            } catch (error) {
+                                if (status === false) {
+                                    if (verbose) {
+                                        console.log(`[waitForFetch] URL ${url} is not responding (as expected) after ${attemptCount} attempts (${elapsed}ms)`);
+                                    }
+                                    return true;
+                                } else {
+                                    if (verbose) {
+                                        console.log(`[waitForFetch] Attempt ${attemptCount}: Request failed (${elapsed}ms)`);
+                                    }
+                                }
+                            }
+
+                            const remainingTime = timeoutMs - (Date.now() - startTime);
+                            if (remainingTime > 0) {
+                                await new Promise(resolve => setTimeout(resolve, Math.min(retryDelayMs, remainingTime)));
+                            }
+                        }
+
+                        if (verbose) {
+                            console.log(`[waitForFetch] Timeout reached after ${attemptCount} attempts (${Date.now() - startTime}ms)`);
+                        }
+                        return false;
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#']
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/ProjectTestLib'

package/caps/RootKey.ts

@@ -0,0 +1,219 @@
+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/RootKeyConfig': {
+                as: '$RootKeyConfig'
+            },
+            '#': {
+                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 { 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.$RootKeyConfig.config
+                        const sshDir = await this.Home.sshDir
+
+                        // --- Already configured: validate ---
+                        if (keyConfig?.name && keyConfig?.privateKeyPath && keyConfig?.publicKey && keyConfig?.keyFingerprint) {
+                            const valid = await validateConfiguredKey(keyConfig, 'Root 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🔑 Root 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 root key is an Ed25519 SSH key used to identify this workspace.'))
+                        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:',
+                            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, 'Root key')
+                            if (!passphraseOk) {
+                                return null
+                            }
+
+                            // Add to ssh-agent
+                            await ensureKeyInAgent(privateKeyPath, keyName, 'Root key')
+                        } else {
+                            // Prompt for key name
+                            keyName = await this.WorkspacePrompt.input({
+                                message: 'Enter a name for the new key:',
+                                defaultValue: 'id_t44_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 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 root key.\n`))
+                                return null
+                            }
+
+                            const result = await generateEd25519Key(privateKeyPath, passphrase, 't44-root-key')
+                            if (!result) {
+                                return null
+                            }
+
+                            publicKey = result.publicKey
+                            keyFingerprint = result.keyFingerprint
+
+                            console.log(chalk.green(`   ✓ 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, 'Root key')
+                            }
+                        }
+
+                        // Store in config
+                        await this.$RootKeyConfig.setConfigValue(['name'], keyName)
+                        await this.$RootKeyConfig.setConfigValue(['privateKeyPath'], privateKeyPath)
+                        await this.$RootKeyConfig.setConfigValue(['publicKey'], publicKey)
+                        await this.$RootKeyConfig.setConfigValue(['keyFingerprint'], keyFingerprint)
+
+                        console.log(chalk.green(`   ✓ Root 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.$RootKeyConfig.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.$RootKeyConfig.config
+
+                        if (!keyConfig?.publicKey) {
+                            return null
+                        }
+
+                        return keyConfig.publicKey
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/RootKey'