@stream44.studio/t44 0.4.0-rc.24

package/caps/WorkspaceConnection.ts

@@ -0,0 +1,329 @@
+
+import { join } from 'path'
+
+// IMPORTANT: Connection config files contain encrypted credentials.
+// NEVER delete these files programmatically. If decryption fails,
+// log a clear error and exit so the user can investigate. The user must manually delete and re-enter
+// credentials if the workspace key has changed.
+
+// Track which connection setup titles and descriptions have been shown
+const shownConnectionTitles = new Set<string>()
+const shownDescriptions = new Set<string>()
+
+// Cache for in-flight getStoredConfig promises to prevent parallel decryption race conditions
+const storedConfigCache = new Map<string, Promise<Record<string, any> | null>>()
+
+// TODO: Remove after all workspaces have been migrated.
+// Maps new capsule name prefixes to old capsule name prefixes for credential file migration.
+const structRelocations: Record<string, string> = {
+    '@stream44.studio/t44-bunny.net/structs/': '@stream44.studio/t44/structs/providers/bunny.net/',
+    '@stream44.studio/t44-vercel.com/structs/': '@stream44.studio/t44/structs/providers/vercel.com/',
+    '@stream44.studio/t44-github.com/structs/': '@stream44.studio/t44/structs/providers/github.com/',
+    '@stream44.studio/t44-dynadot.com/structs/': '@stream44.studio/t44/structs/providers/dynadot.com/',
+    '@stream44.studio/t44-npmjs.com/structs/': '@stream44.studio/t44/structs/providers/npmjs.com/',
+}
+
+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': {},
+            '#': {
+                Home: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/Home'
+                },
+                WorkspaceConfig: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/WorkspaceConfig'
+                },
+                WorkspacePrompt: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/WorkspacePrompt'
+                },
+                WorkspaceKey: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/WorkspaceKey'
+                },
+                HomeRegistry: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/HomeRegistry'
+                },
+                JsonSchema: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/JsonSchemas'
+                },
+                RegisterSchemas: {
+                    type: CapsulePropertyTypes.StructInit,
+                    value: async function (this: any): Promise<void> {
+                        if (this.schema?.schema) {
+                            const version = this.schemaMinorVersion || '0'
+                            await this.JsonSchema.registerSchema(this.capsuleName, this.schema.schema, version)
+                        }
+                    }
+                },
+                getFilepath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<string> {
+                        const registryDir = await this.Home.registryDir
+                        const workspaceConfig = await this.WorkspaceConfig.config
+                        const workspaceConfigStruct = workspaceConfig?.['#@stream44.studio/t44/structs/WorkspaceConfig'] || {}
+                        const workspaceName = workspaceConfigStruct.name
+                        const connectionType = this.capsuleName.replace(/\//g, '~')
+                        return join(registryDir, '@t44.sh~t44~caps~WorkspaceConnection', workspaceName, `${connectionType}.json`)
+                    }
+                },
+                getRelativeFilepath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<string> {
+                        const fullPath = await this.getFilepath()
+                        return this.Home.relativePath(fullPath)
+                    }
+                },
+                getStoredConfig: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<Record<string, any> | null> {
+                        const filepath = await this.getFilepath()
+
+                        // TODO: Remove after all workspaces have been migrated.
+                        // Migrate credential files from old struct paths to new package paths.
+                        await this._migrateCredentialFile(filepath)
+
+                        // Use cached promise if already in-flight to prevent parallel decryption race conditions
+                        if (storedConfigCache.has(filepath)) {
+                            return storedConfigCache.get(filepath)!
+                        }
+
+                        const promise = this._getStoredConfigImpl(filepath)
+                        storedConfigCache.set(filepath, promise)
+
+                        try {
+                            return await promise
+                        } finally {
+                            // Clear cache after completion so next call gets fresh data
+                            storedConfigCache.delete(filepath)
+                        }
+                    }
+                },
+                // TODO: Remove after all workspaces have been migrated.
+                _migrateCredentialFile: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, newFilepath: string): Promise<void> {
+                        const { access, rename, mkdir } = await import('fs/promises')
+                        const { dirname } = await import('path')
+
+                        // Check if the new file already exists — nothing to migrate
+                        try {
+                            await access(newFilepath)
+                            return
+                        } catch { }
+
+                        // Determine if this capsule name matches a known relocation
+                        let oldCapsuleName: string | null = null
+                        for (const [newPrefix, oldPrefix] of Object.entries(structRelocations)) {
+                            if (this.capsuleName.startsWith(newPrefix)) {
+                                oldCapsuleName = oldPrefix + this.capsuleName.slice(newPrefix.length)
+                                break
+                            }
+                        }
+                        if (!oldCapsuleName) return
+
+                        // Build old filepath using the same pattern as getFilepath
+                        const oldConnectionType = oldCapsuleName.replace(/\//g, '~')
+                        const dir = dirname(newFilepath)
+                        const oldFilepath = join(dir, `${oldConnectionType}.json`)
+
+                        // Check if old file exists and move it
+                        try {
+                            await access(oldFilepath)
+                            await mkdir(dirname(newFilepath), { recursive: true })
+                            await rename(oldFilepath, newFilepath)
+                        } catch { }
+                    }
+                },
+                _getStoredConfigImpl: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, filepath: string): Promise<Record<string, any> | null> {
+                        const { readFile } = await import('fs/promises')
+
+                        try {
+                            const content = await readFile(filepath, 'utf-8')
+                            const parsed = JSON.parse(content)
+                            const config = parsed.config || {}
+
+                            // Handle legacy encryptedConfig format (migrate to per-value encryption)
+                            if (parsed.encryptedConfig) {
+                                const decrypted = await this.WorkspaceKey.decryptString(parsed.encryptedConfig)
+                                const legacyConfig = JSON.parse(decrypted)
+                                // Re-save with per-value encryption
+                                await this.setStoredConfig(legacyConfig)
+                                return legacyConfig
+                            }
+
+                            const result: Record<string, any> = {}
+                            let needsMigration = false
+
+                            for (const [key, value] of Object.entries(config)) {
+                                if (typeof value === 'string' && value.startsWith('aes-256-gcm:')) {
+                                    // Encrypted value: <algo>:<keyName>-<did>:<enc value>
+                                    // Also supports legacy format: <algo>:<keyName>:<enc value>
+                                    // Use lastIndexOf since DID contains colons but base64 does not
+                                    const lastColon = value.lastIndexOf(':')
+                                    if (lastColon > 'aes-256-gcm:'.length) {
+                                        const encryptedValue = value.substring(lastColon + 1)
+                                        const keyIdentifier = value.substring('aes-256-gcm:'.length, lastColon)
+                                        try {
+                                            const decrypted = await this.WorkspaceKey.decryptString(encryptedValue)
+                                            result[key] = JSON.parse(decrypted)
+                                        } catch (decryptErr: any) {
+                                            const chalk = (await import('chalk')).default
+                                            let currentKeyId = 'unknown'
+                                            try {
+                                                const keyConfig = await this.WorkspaceKey.ensureKey()
+                                                const did = await this.WorkspaceKey.getDid()
+                                                currentKeyId = `${keyConfig.keyName}-${did}`
+                                            } catch { }
+                                            console.error(chalk.red(`\n┌─────────────────────────────────────────────────────────────────┐`))
+                                            console.error(chalk.red(`│  ✗  Connection Credential Decryption Failed                     │`))
+                                            console.error(chalk.red(`├─────────────────────────────────────────────────────────────────┤`))
+                                            console.error(chalk.red(`│                                                                 │`))
+                                            console.error(chalk.red(`│  Cannot decrypt '${key}' in ${this.capsuleName}`))
+                                            console.error(chalk.red(`│                                                                 │`))
+                                            console.error(chalk.red(`│  This credential was encrypted with a different workspace key.  │`))
+                                            console.error(chalk.red(`│  Encrypted with: ${keyIdentifier}`))
+                                            console.error(chalk.red(`│  Current key:    ${currentKeyId}`))
+                                            console.error(chalk.red(`│                                                                 │`))
+                                            console.error(chalk.red(`├─────────────────────────────────────────────────────────────────┤`))
+                                            console.error(chalk.red(`│  To fix, delete the connection config and re-enter credentials: │`))
+                                            console.error(chalk.red(`│                                                                 │`))
+                                            console.error(chalk.red(`│    rm ${filepath}`))
+                                            console.error(chalk.red(`│                                                                 │`))
+                                            console.error(chalk.red(`└─────────────────────────────────────────────────────────────────┘\n`))
+                                            process.exit(1)
+                                        }
+                                    }
+                                } else {
+                                    // Plain text value - needs migration
+                                    result[key] = value
+                                    needsMigration = true
+                                }
+                            }
+
+                            // Auto-migrate plain text values to encrypted
+                            if (needsMigration) {
+                                await this.setStoredConfig(result)
+                            }
+
+                            return Object.keys(result).length > 0 ? result : null
+                        } catch (err: any) {
+                            // If file doesn't exist, that's normal - user hasn't configured this provider yet
+                            if (err?.code === 'ENOENT') {
+                                return null
+                            }
+
+                            // For other errors (permission issues, malformed JSON, etc.), log and exit
+                            const chalk = (await import('chalk')).default
+                            console.error(chalk.red(`\n\u2717 Failed to read connection config for '${this.capsuleName}'\n`))
+                            console.error(chalk.red(`  File: ${filepath}`))
+                            console.error(chalk.red(`  Error: ${err?.message || err}\n`))
+                            process.exit(1)
+                        }
+                    }
+                },
+                setStoredConfig: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, config: Record<string, any>): Promise<void> {
+                        const { mkdir, writeFile } = await import('fs/promises')
+                        const { dirname } = await import('path')
+                        const filepath = await this.getFilepath()
+                        const dir = dirname(filepath)
+
+                        await mkdir(dir, { recursive: true })
+
+                        // Ensure workspace key exists and get key name + DID
+                        const { keyName } = await this.WorkspaceKey.ensureKey()
+                        const did = await this.WorkspaceKey.getDid()
+
+                        // Encrypt each value separately with prefix format
+                        const encryptedConfig: Record<string, string> = {}
+                        for (const [key, value] of Object.entries(config)) {
+                            const valueJson = JSON.stringify(value)
+                            const encrypted = await this.WorkspaceKey.encryptString(valueJson)
+                            // Format: <algo>:<keyName>-<did>:<enc value>
+                            encryptedConfig[key] = `aes-256-gcm:${keyName}-${did}:${encrypted}`
+                        }
+
+                        const output = {
+                            config: encryptedConfig
+                        }
+
+                        await writeFile(filepath, JSON.stringify(output, null, 4), { mode: 0o600 })
+                    }
+                },
+                getConfigValue: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, key: string): Promise<any> {
+                        const storedConfig = await this.getStoredConfig() || {}
+
+                        if (storedConfig[key] !== undefined) {
+                            return storedConfig[key]
+                        }
+
+                        // Value not set, need to prompt user
+                        const propertySchema = this.schema?.schema?.properties?.[key]
+                        if (!propertySchema) {
+                            throw new Error(`No schema defined for config key "${key}" in ${this.capsuleName} connection config`)
+                        }
+
+                        // Create promptFactId for deduplication
+                        const promptFactId = `${this.capsuleName}:${key}`
+
+                        // Show title once per capsuleName
+                        const chalk = (await import('chalk')).default
+                        if (!shownConnectionTitles.has(this.capsuleName)) {
+                            console.log(chalk.cyan(`\n🔑 ${this.capsuleName} Connection Setup\n`))
+                            shownConnectionTitles.add(this.capsuleName)
+                        }
+
+                        // Show description once per promptFactId
+                        if (propertySchema.description && !shownDescriptions.has(promptFactId)) {
+                            console.log(chalk.gray(`   ${propertySchema.description}\n`))
+                            shownDescriptions.add(promptFactId)
+                        }
+
+                        const value = await this.WorkspacePrompt.input({
+                            message: `${propertySchema.title || key}:`,
+                            validate: (input: string) => {
+                                if (!input || input.trim().length === 0) {
+                                    return `${propertySchema.title || key} cannot be empty`
+                                }
+                                return true
+                            },
+                            promptFactId
+                        })
+
+                        // Store the value
+                        storedConfig[key] = value
+                        await this.setStoredConfig(storedConfig)
+
+                        console.log(chalk.green(`\n   ✓ ${propertySchema.title || key} saved to connection config\n`))
+
+                        return value
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/WorkspaceConnection'

package/caps/WorkspaceEntityConfig.ts

@@ -0,0 +1,78 @@
+
+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': {},
+            '#': {
+                WorkspaceConfig: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/WorkspaceConfig'
+                },
+                JsonSchema: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/JsonSchemas'
+                },
+                config: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: async function (this: any): Promise<void> {
+
+                        const config = await this.WorkspaceConfig.config
+
+                        const configKey = '#' + this.capsuleName
+
+                        const entityConfig = config[configKey] || undefined
+
+                        return entityConfig
+                    }
+                },
+                setConfigValue: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, path: string[], value: any): Promise<void> {
+
+                        const configKey = '#' + this.capsuleName
+
+                        const now = new Date().toISOString()
+                        await this.WorkspaceConfig.ensureEntityTimestamps(
+                            { entityName: this.capsuleName },
+                            configKey, now
+                        )
+
+                        const changed = await this.WorkspaceConfig.setConfigValueForEntity(
+                            { entityName: this.capsuleName, schema: this.schema },
+                            [configKey, ...path], value
+                        )
+
+                        if (changed) {
+                            await this.WorkspaceConfig.setConfigValueForEntity(
+                                { entityName: this.capsuleName, schema: this.schema },
+                                [configKey, 'updatedAt'], new Date().toISOString()
+                            )
+                        }
+                    }
+                },
+                RegisterSchemas: {
+                    type: CapsulePropertyTypes.StructInit,
+                    value: async function (this: any): Promise<void> {
+                        if (this.schema?.schema) {
+                            const version = this.schemaMinorVersion || '0'
+                            await this.JsonSchema.registerSchema(this.capsuleName, this.schema.schema, version)
+                        }
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/WorkspaceEntityConfig'

package/caps/WorkspaceEntityConfig.v0.ts

@@ -0,0 +1,77 @@
+
+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.v0': {},
+            '#': {
+                WorkspaceConfig: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/WorkspaceConfig.v0'
+                },
+                JsonSchema: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/JsonSchemas.v0'
+                },
+                config: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: async function (this: any): Promise<void> {
+
+                        const config = await this.WorkspaceConfig.config
+
+                        const configKey = '#' + this.capsuleName
+
+                        const entityConfig = config[configKey] || undefined
+
+                        return entityConfig
+                    }
+                },
+                setConfigValue: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, path: string[], value: any): Promise<void> {
+
+                        const configKey = '#' + this.capsuleName
+
+                        await this.WorkspaceConfig.setConfigValueForEntity(
+                            { entityName: this.capsuleName, schema: this.schema },
+                            [configKey, 'createdAt'], new Date().toISOString(), { ifAbsent: true }
+                        )
+
+                        const changed = await this.WorkspaceConfig.setConfigValueForEntity(
+                            { entityName: this.capsuleName, schema: this.schema },
+                            [configKey, ...path], value
+                        )
+
+                        if (changed) {
+                            await this.WorkspaceConfig.setConfigValueForEntity(
+                                { entityName: this.capsuleName, schema: this.schema },
+                                [configKey, 'updatedAt'], new Date().toISOString()
+                            )
+                        }
+                    }
+                },
+                RegisterSchemas: {
+                    type: CapsulePropertyTypes.StructInit,
+                    value: async function (this: any): Promise<void> {
+                        if (this.schema?.schema) {
+                            const version = this.schemaMinorVersion || '0'
+                            await this.JsonSchema.registerSchema(this.capsuleName, this.schema.schema, version)
+                        }
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/WorkspaceEntityConfig.v0'