t44 0.2.0-rc.1

package/caps/WorkspaceShellCli.v0.ts

@@ -0,0 +1,109 @@
+
+import { Command } from 'commander'
+import { $ } 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.v0': {},
+            '#t44/structs/WorkspaceCliConfig.v0': {
+                as: '$WorkspaceCliConfig'
+            },
+            '#': {
+                WorkspaceConfig: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceConfig.v0'
+                },
+                shellCommands: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: async function (this: any): Promise<object> {
+
+                        const config = await this.WorkspaceConfig.config as any
+                        const self = this
+
+                        const commands: Record<string, (commandArgs?: any) => Promise<void>> = {}
+                        for (const commandName in config.shell.commands) {
+                            const commandConfig = config.shell.commands[commandName]
+
+                            commands[commandName] = async function () {
+                                throw new Error(`Shell commands cannot be run directly! They must be sourced into the shell.`)
+                            }
+                        }
+                        return commands
+                    }
+                },
+                runCli: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, argv: string[]): Promise<void> {
+
+                        const config = await this.WorkspaceConfig.config as any
+                        const cliConfig = await this.$WorkspaceCliConfig.config
+                        const shellCommands = await this.shellCommands as Record<string, (args?: any) => Promise<void>>
+
+                        const program = new Command()
+                            .option('--yes', 'Confirm all questions with default values.')
+
+                        for (const commandName in config.shell.commands) {
+                            const commandConfig = config.shell.commands[commandName]
+
+                            // If this is a cliCommand reference, pull description and arguments from CLI command
+                            let description = commandConfig.description || ''
+                            let commandArgs = commandConfig.arguments
+                            let commandOptions = commandConfig.options
+
+                            if (commandConfig.cliCommand) {
+                                const cliCommandName = commandConfig.cliCommand
+                                const cliCommand = cliConfig?.cli?.commands?.[cliCommandName]
+                                if (cliCommand) {
+                                    description = cliCommand.description || description
+                                    commandArgs = cliCommand.arguments || commandArgs
+                                    commandOptions = cliCommand.options || commandOptions
+                                }
+                            }
+
+                            const cmd = program
+                                .command(commandName)
+                                .description(description)
+
+                            // Add arguments if defined
+                            if (commandArgs) {
+                                for (const argName in commandArgs) {
+                                    const argConfig = commandArgs[argName]
+                                    const argSyntax = argConfig.optional ? `[${argName}]` : `<${argName}>`
+                                    cmd.argument(argSyntax, argConfig.description || '')
+                                }
+                            }
+
+                            // Add options if defined
+                            if (commandOptions) {
+                                for (const optionName in commandOptions) {
+                                    const optionConfig = commandOptions[optionName]
+                                    cmd.option(`--${optionName}`, optionConfig.description || '')
+                                }
+                            }
+
+                            cmd.action(async function (...actionArgs) {
+                                throw new Error(`Shell commands cannot be run directly! They must be sourced into the shell.`)
+                            })
+                        }
+
+                        await program.parseAsync(argv)
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/WorkspaceShellCli.v0'

package/caps/WorkspaceTest.v0.ts

@@ -0,0 +1,167 @@
+
+import type * as BunTest from 'bun:test'
+import { config as loadDotenv } from 'dotenv'
+import { join } from 'path'
+
+// Global cache for loaded env files (this is fine as a cache)
+const loadedEnvFiles = new Set<string>()
+
+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': {},
+            '#': {
+                bunTest: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: undefined as any as typeof BunTest,
+                },
+                env: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: undefined
+                },
+                testRootDir: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: undefined as string | undefined,
+                },
+                _envLoaded: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: false,
+                },
+                loadEnvFiles: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, cwd: string): void {
+                        if (this._envLoaded) return
+
+                        // Load .env file if it exists
+                        const envPath = join(cwd, '.env')
+                        if (!loadedEnvFiles.has(envPath)) {
+                            loadDotenv({ path: envPath, quiet: true })
+                            loadedEnvFiles.add(envPath)
+                        }
+
+                        // Load .env.dev file if it exists
+                        const envDevPath = join(cwd, '.env.dev')
+                        if (!loadedEnvFiles.has(envDevPath)) {
+                            loadDotenv({ path: envDevPath, quiet: true })
+                            loadedEnvFiles.add(envDevPath)
+                        }
+
+                        this._envLoaded = true
+                    }
+                },
+                getEnvValue: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, envVarName: string): string | undefined {
+                        // Auto-load env files from testRootDir if available
+                        if (this.testRootDir) {
+                            this.loadEnvFiles(this.testRootDir)
+                        }
+                        return process.env[envVarName]
+                    }
+                },
+                describe: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: function (this: any) {
+                        const bunTestModule = this.bunTest
+                        const describeMethod = (name: string, fn: () => void) => {
+                            return bunTestModule.describe(name, async () => {
+                                await fn()
+                            })
+                        }
+                        describeMethod.skip = (name: string, fn: () => void) => {
+                            return bunTestModule.describe.skip(name, async () => {
+                                await fn()
+                            })
+                        }
+                        return describeMethod
+                    }
+                },
+                it: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: function (this: any) {
+                        const bunTestModule = this.bunTest
+                        const itMethod = (name: string, fn: () => void | Promise<void>, options?: number | BunTest.TestOptions) => {
+                            return bunTestModule.it(name, async () => {
+                                await fn()
+                            }, options)
+                        }
+                        itMethod.skip = (name: string, fn: () => void | Promise<void>, options?: number | BunTest.TestOptions) => {
+                            return bunTestModule.it.skip(name, async () => {
+                                await fn()
+                            }, options)
+                        }
+                        return itMethod
+                    }
+                },
+                test: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: function (this: any) {
+                        const bunTestModule = this.bunTest
+                        const testMethod = (name: string, fn: () => void | Promise<void>, options?: number | BunTest.TestOptions) => {
+                            return bunTestModule.test(name, async () => {
+                                await fn()
+                            }, options)
+                        }
+                        testMethod.skip = (name: string, fn: () => void | Promise<void>, options?: number | BunTest.TestOptions) => {
+                            return bunTestModule.test.skip(name, async () => {
+                                await fn()
+                            }, options)
+                        }
+                        return testMethod
+                    }
+                },
+                expect: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: function (this: any): typeof BunTest.expect {
+                        return this.bunTest.expect
+                    }
+                },
+                beforeAll: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, fn: () => void | Promise<void>) {
+                        return this.bunTest.beforeAll(async () => {
+                            await fn()
+                        })
+                    }
+                },
+                afterAll: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, fn: () => void | Promise<void>) {
+                        return this.bunTest.afterAll(async () => {
+                            await fn()
+                        })
+                    }
+                },
+                beforeEach: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, fn: () => void | Promise<void>) {
+                        return this.bunTest.beforeEach(async () => {
+                            await fn()
+                        })
+                    }
+                },
+                afterEach: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, fn: () => void | Promise<void>) {
+                        return this.bunTest.afterEach(async () => {
+                            await fn()
+                        })
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/WorkspaceTest.v0'

package/caps/providers/LICENSE.md

@@ -0,0 +1,8 @@
+
+Copyright 2026 Christoph.diy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/caps/providers/README.md

@@ -0,0 +1,2 @@
+
+**NOTE: Code in this directory will be relocated to a different project under the same `MIT` license in future.**

package/caps/providers/bunny.net/ProjectDeployment.v0.ts

@@ -0,0 +1,328 @@
+
+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': {},
+            '#t44/structs/ProjectDeploymentFact.v0': {
+                as: '$StatusFact'
+            },
+            '#t44/structs/providers/bunny.net/ProjectDeploymentFact.v0': {
+                as: '$BunnyFact'
+            },
+            '#t44/structs/ProjectDeploymentConfig.v0': {
+                as: '$ProjectDeploymentConfig'
+            },
+            '#': {
+                WorkspacePrompt: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspacePrompt.v0'
+                },
+                storage: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './api-storage.v0'
+                },
+                pull: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './api-pull.v0'
+                },
+                deploy: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { projectionDir, alias, config, workspaceProjectName }: { projectionDir: string, alias: string, config: any, workspaceProjectName?: string }) {
+                        let projectName = config.provider.config.ProjectSettings.name
+                        const region = config.provider.config.ProjectSettings.region || 'LA'
+
+                        console.log(`Deploying '${projectName}' to Bunny.net CDN ...`)
+
+                        console.log(`Ensuring storage zone '${projectName}' exists ...`)
+
+                        let storageZone: any
+                        let retryCount = 0
+                        const maxRetries = 3
+
+                        while (retryCount < maxRetries) {
+                            try {
+                                storageZone = await this.storage.ensureZone({
+                                    name: projectName,
+                                    region: region
+                                })
+                                break
+                            } catch (error: any) {
+                                const errorMessage = error.message || ''
+
+                                // Check if it's a zone name conflict error
+                                if (errorMessage.includes('storagezone.name_taken') ||
+                                    errorMessage.includes('storage zone is currently being deleted')) {
+
+                                    const chalk = (await import('chalk')).default
+
+                                    console.log(chalk.yellow(`\n⚠️  WARNING: Storage zone name '${projectName}' is already taken.\n`))
+                                    console.log(chalk.gray(`   Deleted zones may remain permanently reserved.`))
+                                    console.log(chalk.gray(`   Please choose a different project name.\n`))
+
+                                    try {
+                                        const newProjectName = await this.WorkspacePrompt.input({
+                                            message: 'Enter a new project name:',
+                                            defaultValue: `${projectName}-${Date.now()}`,
+                                            validate: (input: string) => {
+                                                if (!input || input.trim().length === 0) {
+                                                    return 'Project name cannot be empty'
+                                                }
+                                                if (!/^[a-z0-9-]+$/.test(input)) {
+                                                    return 'Project name must contain only lowercase letters, numbers, and hyphens'
+                                                }
+                                                return true
+                                            }
+                                        })
+
+                                        // Update the project name in config
+                                        projectName = newProjectName
+                                        config.provider.config.ProjectSettings.name = newProjectName
+
+                                        // Save the updated config back to the workspace config
+                                        if (workspaceProjectName) {
+                                            const configPath = ['deployments', workspaceProjectName, alias, 'provider', 'config', 'ProjectSettings', 'name']
+                                            await this.$ProjectDeploymentConfig.setConfigValue(configPath, newProjectName)
+                                        }
+
+                                        console.log(chalk.green(`\n✓ Updated project name to: ${newProjectName}\n`))
+
+                                        retryCount++
+                                        continue
+
+                                    } catch (promptError: any) {
+                                        if (promptError.message?.includes('SIGINT') || promptError.message?.includes('force closed')) {
+                                            console.log(chalk.red('\nABORTED\n'))
+                                            throw new Error('Deployment aborted by user')
+                                        }
+                                        throw promptError
+                                    }
+                                } else {
+                                    throw error
+                                }
+                            }
+                        }
+
+                        if (!storageZone) {
+                            throw new Error('Failed to create storage zone after multiple attempts')
+                        }
+
+                        console.log(`Storage Zone ID: ${storageZone.Id}`)
+
+                        console.log(`Ensuring pull zone '${projectName}' exists ...`)
+                        const pullZone = await this.pull.ensureZone({
+                            name: projectName,
+                            originUrl: `https://${storageZone.StorageHostname}/${projectName}`,
+                            storageZoneId: storageZone.Id
+                        })
+                        console.log(`Pull Zone ID: ${pullZone.Id}`)
+
+                        const publicUrl = pullZone.Hostnames?.[0]?.Value
+                            ? `https://${pullZone.Hostnames[0].Value}`
+                            : `https://${projectName}.b-cdn.net`
+                        console.log(`Public URL: ${publicUrl}`)
+
+                        console.log(`Uploading files from ${config.sourceDir} ...`)
+                        await this.storage.uploadDirectory({
+                            sourceDirectory: config.sourceDir,
+                            destinationDirectory: '',
+                            storageZoneName: projectName,
+                            password: storageZone.Password,
+                            region: region.toLowerCase(),
+                            cleanDestination: 'avoid-deletes'
+                        })
+                        console.log(`Files uploaded successfully`)
+
+                        console.log(`Purging CDN cache ...`)
+                        await this.pull.purgeZone(pullZone.Id)
+                        console.log(`Cache purged`)
+
+                        console.log(`Deployment complete: ${publicUrl}`)
+
+                        // Write deployment status with updatedAt
+                        const statusResult = {
+                            projectName,
+                            provider: 'bunny.net',
+                            status: 'READY',
+                            publicUrl,
+                            '#t44/structs/ProjectDeploymentConfig.v0': {
+                                updatedAt: new Date().toISOString()
+                            }
+                        }
+                        await this.$StatusFact.set('ProjectDeploymentStatus', projectName, 'ProjectDeploymentStatus', statusResult)
+                    }
+                },
+                deprovision: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { config }: { config: any }) {
+                        const projectName = config.provider.config.ProjectSettings.name
+
+                        console.log(`Deprovisioning '${projectName}' from Bunny.net ...`)
+
+                        try {
+                            const pullZones = await this.pull.listZones({ search: projectName })
+                            const zones = pullZones.Items || pullZones
+                            const pullZone = zones.find((zone: any) => zone.Name === projectName)
+
+                            if (pullZone) {
+                                console.log(`Deleting pull zone '${projectName}' (ID: ${pullZone.Id}) ...`)
+                                await this.pull.deleteZone(pullZone.Id)
+                                console.log(`Pull zone deleted`)
+                            } else {
+                                console.log(`Pull zone '${projectName}' not found`)
+                            }
+                        } catch (error: any) {
+                            console.log(`Error deleting pull zone: ${error.message}`)
+                        }
+
+                        try {
+                            const storageZones = await this.storage.listZones({ search: projectName })
+                            const storageZone = storageZones.find((zone: any) => zone.Name === projectName)
+
+                            if (storageZone) {
+                                console.log(`Deleting storage zone '${projectName}' (ID: ${storageZone.Id}) ...`)
+                                await this.storage.deleteZone(storageZone.Id)
+                                console.log(`Storage zone deleted`)
+                            } else {
+                                console.log(`Storage zone '${projectName}' not found`)
+                            }
+                        } catch (error: any) {
+                            console.log(`Error deleting storage zone: ${error.message}`)
+                        }
+
+                        // Delete fact files
+                        console.log(`Deleting fact files ...`)
+                        try {
+                            await this.$BunnyFact.delete('storage-zones', projectName)
+                            await this.$BunnyFact.delete('pull-zones', projectName)
+                            await this.$StatusFact.delete('ProjectDeploymentStatus', projectName)
+                            console.log(`Fact files deleted`)
+                        } catch (error: any) {
+                            console.log(`Error deleting fact files: ${error.message}`)
+                        }
+
+                        console.log(`Deprovision complete`)
+                    }
+                },
+                status: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { config, now, passive }: { config: any; now?: boolean; passive?: boolean }) {
+                        const projectName = config.provider.config.ProjectSettings.name
+
+                        if (!projectName) {
+                            return {
+                                projectName: projectName || 'unknown',
+                                provider: 'bunny.net',
+                                error: 'No project name configured',
+                                rawDefinitionFilepaths: []
+                            }
+                        }
+
+                        // Raw fact filepaths that this status depends on (specific zone files)
+                        const rawFilepaths = [
+                            this.$BunnyFact.getRelativeFilepath('storage-zones', projectName),
+                            this.$BunnyFact.getRelativeFilepath('pull-zones', projectName)
+                        ]
+
+                        // Try to get cached status if not forcing refresh
+                        if (!now) {
+                            const cached = await this.$StatusFact.get('ProjectDeploymentStatus', projectName, 'ProjectDeploymentStatus', rawFilepaths)
+                            if (cached) {
+                                return cached.data
+                            }
+                        }
+
+                        // In passive mode, don't call the provider if no cache exists
+                        if (passive) {
+                            return null
+                        }
+
+                        const storageZones = await this.storage.listZones({ search: projectName })
+                        const storageZoneMatch = storageZones.find((zone: any) => zone.Name === projectName)
+
+                        if (!storageZoneMatch) {
+                            // Write placeholder fact files so cache can be hit on subsequent calls
+                            await this.$BunnyFact.set('storage-zones', projectName, 'StorageZoneModel', { notFound: true, name: projectName })
+                            await this.$BunnyFact.set('pull-zones', projectName, 'PullZoneModel', { notFound: true, name: projectName })
+                            const errorResult = {
+                                projectName,
+                                provider: 'bunny.net',
+                                error: 'Storage zone not found',
+                                rawDefinitionFilepaths: rawFilepaths
+                            }
+                            await this.$StatusFact.set('ProjectDeploymentStatus', projectName, 'ProjectDeploymentStatus', errorResult)
+                            return errorResult
+                        }
+
+                        const pullZones = await this.pull.listZones({ search: projectName })
+                        const zones = pullZones.Items || pullZones
+                        const pullZoneMatch = zones.find((zone: any) => zone.Name === projectName)
+
+                        if (!pullZoneMatch) {
+                            // Write placeholder fact file so cache can be hit on subsequent calls
+                            await this.$BunnyFact.set('pull-zones', projectName, 'PullZoneModel', { notFound: true, name: projectName })
+                            const errorResult = {
+                                projectName,
+                                provider: 'bunny.net',
+                                error: 'Pull zone not found',
+                                rawDefinitionFilepaths: rawFilepaths
+                            }
+                            await this.$StatusFact.set('ProjectDeploymentStatus', projectName, 'ProjectDeploymentStatus', errorResult)
+                            return errorResult
+                        }
+
+                        // Fetch full zone details (this also saves the individual fact files)
+                        const storageZone = await this.storage.getZone(storageZoneMatch.Id)
+                        const pullZone = await this.pull.getZone(pullZoneMatch.Id)
+
+                        const publicUrl = pullZone.Hostnames?.[0]?.Value
+                            ? `https://${pullZone.Hostnames[0].Value}`
+                            : `https://${projectName}.b-cdn.net`
+
+                        // Preserve updatedAt from existing cached status
+                        const existingStatus = await this.$StatusFact.get('ProjectDeploymentStatus', projectName, 'ProjectDeploymentStatus')
+                        const existingMeta = existingStatus?.data?.['#t44/structs/ProjectDeploymentConfig.v0']
+
+                        const result: Record<string, any> = {
+                            projectName: projectName,
+                            provider: 'bunny.net',
+                            status: pullZone.Enabled ? 'READY' : 'DISABLED',
+                            publicUrl: publicUrl,
+                            providerProjectId: `storage:${storageZone.Id}|pull:${pullZone.Id}`,
+                            providerPortalUrl: `https://dash.bunny.net/cdn/${pullZone.Id}/general/hostnames`,
+                            usage: {
+                                storageBytes: storageZone.StorageUsed,
+                                filesCount: storageZone.FilesStored,
+                                bandwidthBytes: pullZone.MonthlyBandwidthUsed,
+                                charges: pullZone.MonthlyCharges
+                            },
+                            rawDefinitionFilepaths: rawFilepaths
+                        }
+
+                        if (existingMeta?.updatedAt) {
+                            result['#t44/structs/ProjectDeploymentConfig.v0'] = {
+                                updatedAt: existingMeta.updatedAt
+                            }
+                        }
+
+                        await this.$StatusFact.set('ProjectDeploymentStatus', projectName, 'ProjectDeploymentStatus', result)
+
+                        return result
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/bunny.net/ProjectDeployment.v0'