t44 0.2.0-rc.1

package/caps/providers/dynadot.com/api-domains.v0.test.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env bun test
+
+export const testConfig = {
+    group: 'vendor',
+    runOnAll: false,
+}
+
+import * as bunTest from 'bun:test'
+import { run } from '../../../workspace-rt'
+
+const {
+    test: { describe, it, expect },
+    domains
+} = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+    const spine = await encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule.v0': {},
+            '#': {
+                test: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceTest.v0',
+                    options: {
+                        '#': {
+                            bunTest,
+                            env: {
+                                DYNADOT_API_KEY: { factReference: 't44/structs/providers/dynadot.com/WorkspaceConnectionConfig.v0:apiKey' }
+                            }
+                        }
+                    }
+                },
+                domains: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './api-domains.v0'
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: 't44/caps/providers/dynadot.com/api-domains.v0.test'
+    })
+    return { spine }
+}, async ({ spine, apis }: any) => {
+    return apis[spine.capsuleSourceLineRef]
+}, {
+    importMeta: import.meta
+})
+
+describe('Dynadot Domain API', function () {
+
+    let domainName: string
+
+    it('should return list of domains', async function () {
+
+        const result = await domains.list()
+
+        expect(result).toBeObject()
+        expect(result.ListDomainInfoResponse).toBeObject()
+        expect(result.ListDomainInfoResponse.MainDomains).toBeArray()
+        expect(result.ListDomainInfoResponse.MainDomains.length).toBeGreaterThan(0)
+
+        domainName = result.ListDomainInfoResponse.MainDomains[0].Name
+    })
+
+    it('should return domain info for a specific domain', async function () {
+
+        const result = await domains.getInfo({ name: domainName })
+
+        expect(result).toBeObject()
+        expect(result.DomainInfoResponse).toBeObject()
+        expect(result.DomainInfoResponse.DomainInfo).toBeObject()
+        expect(result.DomainInfoResponse.DomainInfo.Name).toBe(domainName)
+    })
+
+    it('should return DNS records for a specific domain', async function () {
+
+        const result = await domains.getDns({ name: domainName })
+
+        expect(result).toBeObject()
+        expect(result.GetDnsResponse).toBeObject()
+    })
+
+    it('should return nameservers for a specific domain', async function () {
+
+        const result = await domains.getNameservers({ name: domainName })
+
+        expect(result).toBeObject()
+        expect(result.GetNsResponse).toBeObject()
+    })
+
+    it('should set DNS records, verify, and restore original', async function () {
+
+        const originalDns = await domains.getDns({ name: domainName })
+        expect(originalDns).toBeObject()
+        expect(originalDns.GetDnsResponse).toBeObject()
+
+        const originalRecords = originalDns.GetDnsResponse.GetDns?.NameServerSettings?.SubDomains || []
+
+        const testCnameRecord = {
+            record_type: 'cname',
+            subdomain: 't44-test-api-domains',
+            value: 'example.com'
+        }
+
+        const updatedRecords = [...originalRecords.map((r: any) => ({
+            record_type: r.RecordType.toLowerCase(),
+            subdomain: r.Subhost,
+            value: r.Value
+        })), testCnameRecord]
+
+        const setResult = await domains.setDns({
+            name: domainName,
+            records: updatedRecords
+        })
+        expect(setResult).toBeObject()
+        expect(setResult.SetDnsResponse.Status).toBe('success')
+
+        const verifyDns = await domains.getDns({ name: domainName })
+        expect(verifyDns).toBeObject()
+        expect(verifyDns.GetDnsResponse).toBeObject()
+        const verifyRecords = verifyDns.GetDnsResponse.GetDns?.NameServerSettings?.SubDomains || []
+        expect(verifyRecords.length).toBe(originalRecords.length + 1)
+
+        const foundNewRecord = verifyRecords.find((r: any) => r.Subhost === 't44-test-api-domains')
+        expect(foundNewRecord).toBeDefined()
+        expect(foundNewRecord.RecordType).toBe('CNAME')
+        expect(foundNewRecord.Value).toBe('example.com')
+
+        const restoreRecords = originalRecords.map((r: any) => ({
+            record_type: r.RecordType.toLowerCase(),
+            subdomain: r.Subhost,
+            value: r.Value
+        }))
+
+        const restoreResult = await domains.setDns({
+            name: domainName,
+            records: restoreRecords
+        })
+        expect(restoreResult).toBeObject()
+
+        const finalDns = await domains.getDns({ name: domainName })
+        expect(finalDns).toBeObject()
+        const finalRecords = finalDns.GetDnsResponse.GetDns?.NameServerSettings?.SubDomains || []
+        expect(finalRecords.length).toBe(originalRecords.length)
+    })
+
+})

package/caps/providers/dynadot.com/api-domains.v0.ts

@@ -0,0 +1,137 @@
+
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+
+    // https://www.dynadot.com/domain/api-commands
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule.v0': {},
+            '#t44/structs/providers/dynadot.com/DomainFact.v0': {
+                as: '$DomainFact'
+            },
+            '#': {
+
+                api: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './api.v0'
+                },
+
+                list: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any) {
+                        const result = await this.api.call({
+                            command: 'list_domain',
+                            operation: 'list'
+                        });
+
+                        await this.$DomainFact.set('domains-list', 'list', 'ListDomainInfoResponse', result);
+
+                        return result;
+                    }
+                },
+
+                getInfo: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: { name: string }) {
+                        const result = await this.api.call({
+                            command: 'domain_info',
+                            params: {
+                                domain: options.name
+                            },
+                            operation: 'info'
+                        });
+
+                        await this.$DomainFact.set('domains', options.name, 'DomainInfoResponse', result);
+
+                        return result;
+                    }
+                },
+
+                getDns: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: { name: string }) {
+                        const result = await this.api.call({
+                            command: 'get_dns',
+                            params: {
+                                domain: options.name
+                            },
+                            operation: 'getDns'
+                        });
+
+                        await this.$DomainFact.set('dns', options.name, 'GetDnsResponse', result);
+
+                        return result;
+                    }
+                },
+
+                getNameservers: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: { name: string }) {
+                        const result = await this.api.call({
+                            command: 'get_ns',
+                            params: {
+                                domain: options.name
+                            },
+                            operation: 'getNameservers'
+                        });
+
+                        await this.$DomainFact.set('nameservers', options.name, 'GetNsResponse', result);
+
+                        return result;
+                    }
+                },
+
+                setDns: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: { name: string; records: any[]; mainDomain?: { recordType: string; value: string } }) {
+                        const params: Record<string, any> = {
+                            domain: options.name
+                        };
+
+                        // Set main domain record if provided (for root domain A/AAAA/CNAME)
+                        // Note: Dynadot API requires index suffix (e.g., main_record_type0, main_record0)
+                        if (options.mainDomain) {
+                            params['main_record_type0'] = options.mainDomain.recordType;
+                            params['main_record0'] = options.mainDomain.value;
+                        }
+
+                        options.records.forEach((record, index) => {
+                            const recordIndex = index + 1;
+
+                            if (record.subdomain !== undefined) {
+                                params[`subdomain${recordIndex}`] = record.subdomain;
+                            }
+                            if (record.record_type) {
+                                params[`sub_record_type${recordIndex}`] = record.record_type;
+                            }
+                            if (record.value !== undefined) {
+                                params[`sub_record${recordIndex}`] = record.value;
+                            }
+                        });
+
+                        return await this.api.call({
+                            command: 'set_dns2',
+                            params,
+                            operation: 'setDns'
+                        });
+                    }
+                }
+
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/dynadot.com/api-domains.v0'
+

package/caps/providers/dynadot.com/api.v0.ts

@@ -0,0 +1,88 @@
+
+import axios from 'axios';
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    // https://www.dynadot.com/domain/api-commands
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule.v0': {},
+            '#t44/structs/providers/dynadot.com/WorkspaceConnectionConfig.v0': {
+                as: '$ConnectionConfig'
+            },
+            '#': {
+
+                call: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: {
+                        command: string;
+                        params?: Record<string, string | number | boolean>;
+                        operation?: string;
+                    }) {
+                        const apiKey = await this.$ConnectionConfig.getConfigValue('apiKey')
+
+                        const baseUrl = 'https://api.dynadot.com/api3.json';
+
+                        // Build query params
+                        const searchParams = new URLSearchParams();
+                        searchParams.append('key', apiKey);
+                        searchParams.append('command', options.command);
+
+                        if (options.params) {
+                            for (const [key, value] of Object.entries(options.params)) {
+                                searchParams.append(key, String(value));
+                            }
+                        }
+
+                        const url = `${baseUrl}?${searchParams.toString()}`;
+
+                        try {
+                            const response = await axios.get(url);
+                            return response.data;
+                        } catch (error: any) {
+                            if (error.response) {
+                                const errorData = error.response.data;
+                                const status = error.response.status;
+                                const statusText = error.response.statusText;
+
+                                const operationName = options.operation || options.command;
+                                console.error(`Dynadot API Error [${operationName}]:`);
+                                console.error(`  Status: ${status} ${statusText}`);
+                                console.error(`  Response:`, JSON.stringify(errorData, null, 2));
+
+                                let errorMessage = `Dynadot API ${operationName} failed: ${status} ${statusText}`;
+
+                                if (errorData && typeof errorData === 'object') {
+                                    if (errorData.Message) {
+                                        errorMessage += ` - ${errorData.Message}`;
+                                    } else if (errorData.message) {
+                                        errorMessage += ` - ${errorData.message}`;
+                                    } else {
+                                        errorMessage += ` - ${JSON.stringify(errorData)}`;
+                                    }
+                                }
+
+                                throw new Error(errorMessage);
+                            }
+                            throw error;
+                        }
+                    }
+                }
+
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/dynadot.com/api.v0'
+

package/caps/providers/git-scm.com/ProjectPublishing.v0.ts

@@ -0,0 +1,231 @@
+
+import { join } from 'path'
+import { $ } from 'bun'
+import { mkdir, access, writeFile } from 'fs/promises'
+import { constants } from 'fs'
+import chalk from 'chalk'
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    // High level API that deals with everything concerning a git repository.
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule.v0': {},
+            '#t44/structs/providers/git-scm.com/ProjectPublishingFact.v0': {
+                as: '$GitFact'
+            },
+            '#t44/structs/ProjectPublishingFact.v0': {
+                as: '$StatusFact'
+            },
+            '#': {
+                WorkspacePrompt: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspacePrompt.v0'
+                },
+                push: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { projectionDir, config, dangerouslyResetMain }: { projectionDir: string, config: any, dangerouslyResetMain?: boolean }) {
+
+                        const originUri = config.provider.config.RepositorySettings.origin
+
+                        console.log(`Push source '${config.sourceDir}' to git repo '${originUri}' ...`)
+                        if (dangerouslyResetMain) {
+                            console.log(`Reset mode enabled - will reset repository to initial commit`)
+                        }
+
+                        const projectSourceDir = join(config.sourceDir)
+                        const projectProjectionDir = join(projectionDir, 'repos', originUri.replace(/[@:\/]/g, '~'))
+
+                        // Check if repository directory exists
+                        let repoExists = false
+                        try {
+                            await access(projectProjectionDir, constants.F_OK)
+                            repoExists = true
+                        } catch {
+                            repoExists = false
+                        }
+
+                        let isNewEmptyRepo = false
+                        if (!repoExists) {
+                            // Clone the repository if it doesn't exist
+                            console.log(`Cloning repository from '${originUri}' ...`)
+                            const reposDir = join(projectionDir, 'repos')
+                            await mkdir(reposDir, { recursive: true })
+                            await $`git clone "${originUri}" "${projectProjectionDir}"`.cwd(reposDir)
+
+                            // Check if the cloned repo is empty (no commits)
+                            const headCheck = await $`git rev-parse HEAD`.cwd(projectProjectionDir).quiet().nothrow()
+                            if (headCheck.exitCode !== 0) {
+                                isNewEmptyRepo = true
+                            }
+                        }
+
+                        // Sync files using rsync with gitignore support and delete removed files
+                        // --exclude-from reads patterns from .gitignore
+                        // --exclude '.git' ensures we don't copy git metadata
+                        // --delete removes files in dest that are no longer in source
+                        const gitignorePath = join(projectSourceDir, '.gitignore')
+                        await $`rsync -a --delete --exclude '.git' --exclude-from="${gitignorePath}" "${projectSourceDir}/" "${projectProjectionDir}/"`
+
+                        // Generate files from config properties starting with '/'
+                        // This happens AFTER rsync so generated files are not overwritten
+                        if (config.provider.config) {
+                            for (const [key, value] of Object.entries(config.provider.config)) {
+                                if (key.startsWith('/')) {
+                                    const targetPath = join(projectProjectionDir, key)
+                                    const targetDir = join(targetPath, '..')
+
+                                    // Check if file already exists
+                                    let fileExists = false
+                                    try {
+                                        await access(targetPath, constants.F_OK)
+                                        fileExists = true
+                                    } catch {
+                                        fileExists = false
+                                    }
+
+                                    if (fileExists) {
+                                        console.log(`Overwriting file '${key}' in repository ...`)
+                                    } else {
+                                        console.log(`Creating file '${key}' in repository ...`)
+                                    }
+
+                                    // Ensure directory exists
+                                    await mkdir(targetDir, { recursive: true })
+
+                                    // Write file content
+                                    const content = typeof value === 'string' ? value : JSON.stringify(value, null, 2)
+                                    await writeFile(targetPath, content, 'utf-8')
+                                }
+                            }
+                        }
+
+                        // Git add, commit, and push changes
+                        console.log(`Committing changes ...`)
+                        await $`git add .`.cwd(projectProjectionDir)
+
+                        // Check if there are changes to commit
+                        const statusResult = await $`git status --porcelain`.cwd(projectProjectionDir).text()
+                        const hasNewChanges = statusResult.trim().length > 0
+
+                        // Handle reset (works on existing commits, regardless of new changes)
+                        let shouldReset = false
+                        if (dangerouslyResetMain) {
+                            shouldReset = await this.WorkspacePrompt.confirm({
+                                title: '⚠️  WARNING: DESTRUCTIVE OPERATION ⚠️',
+                                description: [
+                                    '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━',
+                                    'Resetting will:',
+                                    '  • Destroy all commit history in the local repository',
+                                    '  • Destroy all commit history on GitHub when force pushed',
+                                    '  • Cannot be undone once pushed to remote',
+                                    '',
+                                    'This should ONLY be done at the very beginning of a project.',
+                                    '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'
+                                ],
+                                message: 'Are you absolutely sure you want to reset all commits and destroy the history?',
+                                defaultValue: false,
+                                onSuccess: async (confirmed: boolean) => {
+                                    if (confirmed) {
+                                        const chalk = (await import('chalk')).default
+                                        console.log(chalk.cyan(`\nResetting all commits to initial commit ...`))
+                                    } else {
+                                        console.log('\nReset operation cancelled. Pushing without resetting...\n')
+                                    }
+                                }
+                            })
+
+                            if (shouldReset) {
+                                // Get the initial commit (root commit)
+                                const rootCommit = await $`git rev-list --max-parents=0 HEAD`.cwd(projectProjectionDir).text()
+                                const rootCommitHash = rootCommit.trim()
+
+                                // Soft reset to the root commit, keeping all changes staged
+                                await $`git reset --soft ${rootCommitHash}`.cwd(projectProjectionDir)
+
+                                // Commit all changes as a single commit (this replaces the root commit)
+                                await $`git commit --amend -m "Published using @Stream44 Studio"`.cwd(projectProjectionDir)
+
+                                console.log(`Repository reset to initial commit`)
+                            }
+                        } else if (hasNewChanges) {
+                            // Only commit new changes if not resetting
+                            await $`git commit -m "Published using @Stream44 Studio"`.cwd(projectProjectionDir)
+                            console.log(`New changes committed`)
+                        } else {
+                            console.log(`No new changes to commit`)
+                        }
+
+                        // Check if local is ahead of remote using ls-remote (not cached refs)
+                        let localAheadOfRemote = false
+                        if (!shouldReset && !hasNewChanges && !isNewEmptyRepo) {
+                            const lsRemoteResult = await $`git ls-remote origin`.cwd(projectProjectionDir).quiet().nothrow()
+                            const lsRemoteOutput = lsRemoteResult.text().trim()
+
+                            if (!lsRemoteOutput) {
+                                // Remote is completely empty — must push
+                                localAheadOfRemote = true
+                            } else {
+                                // Parse remote HEAD ref
+                                const localHead = (await $`git rev-parse HEAD`.cwd(projectProjectionDir).quiet()).text().trim()
+                                const remoteHeadLine = lsRemoteOutput.split('\n').find((l: string) => l.includes('refs/heads/main'))
+                                const remoteHead = remoteHeadLine ? remoteHeadLine.split('\t')[0] : null
+
+                                if (!remoteHead || remoteHead !== localHead) {
+                                    localAheadOfRemote = true
+                                }
+                            }
+                        }
+
+                        // Push to remote
+                        if (shouldReset) {
+                            console.log(`Force pushing to remote ...`)
+                            await $`git push --force --tags`.cwd(projectProjectionDir)
+                            console.log(`Force pushed to remote`)
+                        } else if (isNewEmptyRepo || hasNewChanges || localAheadOfRemote) {
+                            console.log(`Pushing to remote ...`)
+                            await $`git push -u origin main --tags`.cwd(projectProjectionDir)
+                            console.log(`Pushed to remote`)
+                        }
+
+                        // Write fact files
+                        const lastCommit = await $`git rev-parse HEAD`.cwd(projectProjectionDir).text()
+                        const lastCommitMessage = await $`git log -1 --pretty=%B`.cwd(projectProjectionDir).text()
+                        const branch = await $`git rev-parse --abbrev-ref HEAD`.cwd(projectProjectionDir).text()
+
+                        const repoFactName = originUri.replace(/[@:\/]/g, '~')
+
+                        await this.$GitFact.set('repositories', repoFactName, 'GitRepository', {
+                            origin: originUri,
+                            branch: branch.trim(),
+                            lastCommit: lastCommit.trim(),
+                            lastCommitMessage: lastCommitMessage.trim(),
+                            pushedAt: new Date().toISOString()
+                        })
+
+                        await this.$StatusFact.set('ProjectPublishingStatus', repoFactName, 'ProjectPublishingStatus', {
+                            projectName: originUri,
+                            provider: 'git-scm.com',
+                            status: hasNewChanges || shouldReset || localAheadOfRemote ? 'PUBLISHED' : 'READY',
+                            publicUrl: originUri,
+                            updatedAt: new Date().toISOString()
+                        })
+
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/git-scm.com/ProjectPublishing.v0'

package/caps/providers/github.com/ProjectPublishing.v0.ts

@@ -0,0 +1,75 @@
+
+import chalk from 'chalk'
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    // Ensures the GitHub repository is provisioned before git-scm pushes to it.
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule.v0': {},
+            '#t44/structs/providers/github.com/ProjectPublishingFact.v0': {
+                as: '$GitHubFact'
+            },
+            '#t44/structs/ProjectPublishingFact.v0': {
+                as: '$StatusFact'
+            },
+            '#': {
+                GitHubApi: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/providers/github.com/api.v0'
+                },
+                push: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { config }: { config: any }) {
+
+                        const repoSettings = config.provider.config.RepositorySettings
+                        const owner = repoSettings.owner
+                        const repo = repoSettings.repo
+                        const isPrivate = repoSettings.public === true ? false : true
+                        const description = repoSettings.description || ''
+
+                        console.log(chalk.cyan(`\n🔍 Ensuring GitHub repository '${owner}/${repo}' ...`))
+
+                        const result = await this.GitHubApi.ensureRepo({
+                            owner,
+                            repo,
+                            isPrivate,
+                            description
+                        })
+
+                        if (result.created) {
+                            console.log(chalk.green(`   ✓ Repository '${owner}/${repo}' created on GitHub\n`))
+                        } else {
+                            console.log(chalk.green(`   ✓ Repository '${owner}/${repo}' already exists\n`))
+                        }
+
+                        // Write provider-specific fact file
+                        await this.$GitHubFact.set('repositories', `${owner}~${repo}`, 'Repository', result.repo)
+
+                        // Write publishing status fact
+                        const statusResult = {
+                            projectName: `${owner}/${repo}`,
+                            provider: 'github.com',
+                            status: 'READY',
+                            publicUrl: result.repo.html_url,
+                            updatedAt: new Date().toISOString()
+                        }
+                        await this.$StatusFact.set('ProjectPublishingStatus', `${owner}~${repo}`, 'ProjectPublishingStatus', statusResult)
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/github.com/ProjectPublishing.v0'