@stream44.studio/t44 0.4.0-rc.24

package/caps/HomeRegistry.ts

@@ -0,0 +1,319 @@
+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/HomeRegistryConfig': {
+                as: '$HomeRegistryConfig'
+            },
+            '#@stream44.studio/t44/structs/HomeRegistry': {
+                as: '$HomeRegistry'
+            },
+            '#@stream44.studio/t44/structs/Workspace': {
+                as: '$Workspace'
+            },
+            '#@stream44.studio/t44/structs/WorkspaceKey': {
+                as: '$WorkspaceKey'
+            },
+            '#@stream44.studio/t44/structs/ProjectRack': {
+                as: '$ProjectRack'
+            },
+            '#@stream44.studio/t44/structs/WorkspaceCatalogs': {
+                as: '$WorkspaceCatalogs'
+            },
+            '#': {
+                Home: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/Home'
+                },
+                WorkspacePrompt: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/WorkspacePrompt'
+                },
+                rootDir: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: async function (this: any): Promise<string> {
+                        const config = await this.$HomeRegistryConfig.config
+                        if (!config?.rootDir) {
+                            throw new Error('Home registry rootDir is not configured. Run ensureRootDir() first.')
+                        }
+                        return config.rootDir
+                    }
+                },
+                ensureRootDir: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<string> {
+                        const { stat, mkdir } = await import('fs/promises')
+                        const { join } = await import('path')
+                        const chalk = (await import('chalk')).default
+
+                        const config = await this.$HomeRegistryConfig.config
+                        const defaultHomeDir = await this.Home.homeDir
+
+                        let chosenDir: string
+
+                        if (config?.rootDir) {
+                            // Validate that the directory exists
+                            try {
+                                const s = await stat(config.rootDir)
+                                if (!s.isDirectory()) {
+                                    throw new Error(`Home registry path '${config.rootDir}' exists but is not a directory.`)
+                                }
+                            } catch (error: any) {
+                                if (error.code === 'ENOENT') {
+                                    throw new Error(`Home registry directory '${config.rootDir}' does not exist. Please create it or reconfigure.`)
+                                }
+                                throw error
+                            }
+                            chosenDir = config.rootDir
+                        } else {
+                            // rootDir not set — prompt user for home directory
+                            console.log(chalk.cyan(`\n🏠 Home Directory Setup\n`))
+                            console.log(chalk.gray('   The home directory is where your workspace keeps its registry,'))
+                            console.log(chalk.gray('   SSH keys, and other workspace-related files.'))
+                            console.log('')
+
+                            const chosenHomeDir = await this.WorkspacePrompt.input({
+                                message: 'Enter the home directory:',
+                                defaultValue: defaultHomeDir,
+                                validate: (input: string) => {
+                                    if (!input || input.trim().length === 0) {
+                                        return 'Directory path cannot be empty'
+                                    }
+                                    return true
+                                }
+                            })
+
+                            // Check if home directory exists
+                            let homeDirExists = false
+                            try {
+                                const s = await stat(chosenHomeDir)
+                                homeDirExists = s.isDirectory()
+                            } catch {
+                                // Does not exist
+                            }
+
+                            if (homeDirExists) {
+                                const confirmed = await this.WorkspacePrompt.confirm({
+                                    message: `Directory '${chosenHomeDir}' already exists. Use it as the home directory for your workspace?`,
+                                    defaultValue: true
+                                })
+
+                                if (!confirmed) {
+                                    console.log(chalk.red('\n\nABORTED\n'))
+                                    process.exit(0)
+                                }
+                            } else {
+                                // Create the home directory
+                                await mkdir(chosenHomeDir, { recursive: true })
+                                console.log(chalk.green(`\n   ✓ Created home directory: ${chosenHomeDir}\n`))
+                            }
+
+                            // Derive registry dir from home dir
+                            chosenDir = join(chosenHomeDir, '.o/workspace.foundation')
+                            await mkdir(chosenDir, { recursive: true })
+
+                            await this.$HomeRegistryConfig.setConfigValue(['homeDir'], chosenHomeDir)
+                            await this.$HomeRegistryConfig.setConfigValue(['rootDir'], chosenDir)
+                        }
+
+                        // Ensure registry.json exists via the HomeRegistry struct
+                        let registryData = await this.$HomeRegistry.get('registry')
+
+                        if (!registryData) {
+                            // registry.json does not exist — generate identity
+                            console.log(chalk.cyan(`\n   Generating home registry identity...\n`))
+
+                            const { generateKeypair } = await import('../lib/ucan.js')
+                            const { did, privateKey } = await generateKeypair()
+
+                            registryData = {
+                                did,
+                                privateKey,
+                                createdAt: new Date().toISOString(),
+                                rootDir: chosenDir
+                            }
+
+                            const registryFilePath = await this.$HomeRegistry.set('registry', registryData)
+
+                            console.log(chalk.green(`   ✓ Registry identity saved to:`))
+                            console.log(chalk.green(`     ${registryFilePath}`))
+                            console.log(chalk.green(`   ✓ DID: ${registryData.did}\n`))
+                        }
+
+                        // Ensure rootDir is set in registry data
+                        if (!registryData.rootDir || registryData.rootDir !== chosenDir) {
+                            registryData.rootDir = chosenDir
+                            await this.$HomeRegistry.set('registry', registryData)
+                        }
+
+                        // Ensure identifier is set in config
+                        if (!config?.identifier || config.identifier !== registryData.did) {
+                            await this.$HomeRegistryConfig.setConfigValue(['identifier'], registryData.did)
+                        }
+
+                        return chosenDir
+                    }
+                },
+                getRegistryPath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<string> {
+                        return this.$HomeRegistry.getPath('registry')
+                    }
+                },
+                getRegistry: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<any | null> {
+                        return this.$HomeRegistry.get('registry')
+                    }
+                },
+                getWorkspace: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<any | null> {
+                        return this.$Workspace.get(name)
+                    }
+                },
+                setWorkspace: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string, data: { did: string; privateKey: string; createdAt: string; workspaceRootDir: string }): Promise<string> {
+                        return this.$Workspace.set(name, data)
+                    }
+                },
+                getWorkspacePath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<string> {
+                        return this.$Workspace.getPath(name)
+                    }
+                },
+                listKeys: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<Array<{ name: string; did: string; createdAt?: string }>> {
+                        const { readdir, readFile } = await import('fs/promises')
+                        const { join } = await import('path')
+                        const rootDir = await this.rootDir
+                        const keyDir = join(rootDir, '@t44.sh~t44~structs~WorkspaceKey')
+                        try {
+                            const files = await readdir(keyDir)
+                            const keys: Array<{ name: string; did: string; createdAt?: string }> = []
+                            for (const file of files) {
+                                if (file.endsWith('.json')) {
+                                    try {
+                                        const data = JSON.parse(await readFile(join(keyDir, file), 'utf-8'))
+                                        keys.push({
+                                            name: file.replace(/\.json$/, ''),
+                                            did: data.did || '',
+                                            createdAt: data.createdAt,
+                                        })
+                                    } catch { }
+                                }
+                            }
+                            return keys
+                        } catch {
+                            return []
+                        }
+                    }
+                },
+                getKey: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<any | null> {
+                        return this.$WorkspaceKey.get(name)
+                    }
+                },
+                setKey: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string, data: { did: string; privateKey: string; createdAt: string }): Promise<string> {
+                        return this.$WorkspaceKey.set(name, data)
+                    }
+                },
+                getKeyPath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<string> {
+                        return this.$WorkspaceKey.getPath(name)
+                    }
+                },
+                keyExists: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<boolean> {
+                        return this.$WorkspaceKey.exists(name)
+                    }
+                },
+                listRacks: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<Array<{ name: string; did: string; createdAt?: string }>> {
+                        const { readdir, readFile } = await import('fs/promises')
+                        const { join } = await import('path')
+                        const rootDir = await this.rootDir
+                        const rackDir = join(rootDir, '@t44.sh~t44~structs~ProjectRack')
+                        try {
+                            const files = await readdir(rackDir)
+                            const racks: Array<{ name: string; did: string; createdAt?: string }> = []
+                            for (const file of files) {
+                                if (file.endsWith('.json')) {
+                                    try {
+                                        const data = JSON.parse(await readFile(join(rackDir, file), 'utf-8'))
+                                        racks.push({
+                                            name: file.replace(/\.json$/, ''),
+                                            did: data.did || '',
+                                            createdAt: data.createdAt,
+                                        })
+                                    } catch { }
+                                }
+                            }
+                            return racks
+                        } catch {
+                            return []
+                        }
+                    }
+                },
+                getRack: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<any | null> {
+                        return this.$ProjectRack.get(name)
+                    }
+                },
+                setRack: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string, data: { did: string; privateKey: string; createdAt: string }): Promise<string> {
+                        return this.$ProjectRack.set(name, data)
+                    }
+                },
+                getRackPath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<string> {
+                        return this.$ProjectRack.getPath(name)
+                    }
+                },
+                getCatalog: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<any | null> {
+                        return this.$WorkspaceCatalogs.get(name)
+                    }
+                },
+                setCatalog: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string, data: any): Promise<string> {
+                        return this.$WorkspaceCatalogs.set(name, data)
+                    }
+                },
+                getCatalogPath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<string> {
+                        return this.$WorkspaceCatalogs.getPath(name)
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/HomeRegistry'

package/caps/HomeRegistryFile.ts

@@ -0,0 +1,144 @@
+
+import { join, relative, dirname } from 'path'
+import { readFile, writeFile, mkdir, access } from 'fs/promises'
+
+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/HomeRegistryConfig': {
+                as: '$HomeRegistryConfig'
+            },
+            '#': {
+                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)
+                        }
+                    }
+                },
+                _resolveDir: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: async function (this: any): Promise<string> {
+                        const config = await this.$HomeRegistryConfig.config
+                        if (!config?.rootDir) {
+                            throw new Error('Home registry rootDir is not configured. Run ensureRootDir() first.')
+                        }
+                        const dirName = this.capsuleName.replace(/\//g, '~')
+                        return join(config.rootDir, dirName)
+                    }
+                },
+                get: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<any | null> {
+                        const filePath = join(await this._resolveDir, `${name}.json`)
+                        let parsed: any
+                        try {
+                            parsed = JSON.parse(await readFile(filePath, 'utf-8'))
+                        } catch {
+                            return null
+                        }
+
+                        // Migrate old wrapper format: { $schema, $defs?, SchemaName: { ...data }, ... }
+                        // to flat format: { $schema, $id, ...data }
+                        if (parsed && parsed.$schema) {
+                            const schemaName = this.capsuleName.split('/').pop()?.replace(/\.v\d+$/, '')
+                            if (schemaName && parsed[schemaName] && typeof parsed[schemaName] === 'object') {
+                                const innerData = parsed[schemaName]
+                                // Re-write in new format with $schema and $id
+                                const version = this.schemaMinorVersion || '0'
+                                const output = this.schema.wrapWithSchema(innerData, this.capsuleName, version)
+                                await writeFile(filePath, JSON.stringify(output, null, 2), { mode: 0o600 })
+                                return innerData
+                            }
+                        }
+
+                        // Migrate old relative $schema format to new $schema + $id format
+                        if (parsed && parsed.$schema && !parsed.$id && typeof parsed.$schema === 'string' && parsed.$schema.includes('/')) {
+                            const data = { ...parsed }
+                            delete data.$schema
+                            // Re-write in new format with $schema and $id
+                            const version = this.schemaMinorVersion || '0'
+                            const output = this.schema.wrapWithSchema(data, this.capsuleName, version)
+                            await writeFile(filePath, JSON.stringify(output, null, 2), { mode: 0o600 })
+                            return data
+                        }
+
+                        // Already schema-wrapped (new format) — return data (strip $schema and $id)
+                        if (parsed && (parsed.$schema || parsed.$id)) {
+                            const data = { ...parsed }
+                            delete data.$schema
+                            delete data.$id
+                            return data
+                        }
+
+                        // Raw data — wrap with schema and re-write
+                        const data = parsed
+                        if (this.schema?.wrapWithSchema) {
+                            const version = this.schemaMinorVersion || '0'
+                            const output = this.schema.wrapWithSchema(data, this.capsuleName, version)
+                            await writeFile(filePath, JSON.stringify(output, null, 2), { mode: 0o600 })
+                        }
+
+                        return data
+                    }
+                },
+                set: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string, data: any): Promise<string> {
+                        const dir = await this._resolveDir
+                        const filePath = join(dir, `${name}.json`)
+                        await mkdir(dir, { recursive: true })
+
+                        if (this.schema?.wrapWithSchema) {
+                            const version = this.schemaMinorVersion || '0'
+                            const output = this.schema.wrapWithSchema(data, this.capsuleName, version)
+                            await writeFile(filePath, JSON.stringify(output, null, 2), { mode: 0o600 })
+                        } else {
+                            await writeFile(filePath, JSON.stringify(data, null, 2), { mode: 0o600 })
+                        }
+
+                        return filePath
+                    }
+                },
+                getPath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<string> {
+                        return join(await this._resolveDir, `${name}.json`)
+                    }
+                },
+                exists: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, name: string): Promise<boolean> {
+                        const filePath = join(await this._resolveDir, `${name}.json`)
+                        try {
+                            await access(filePath)
+                            return true
+                        } catch {
+                            return false
+                        }
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/HomeRegistryFile'

package/caps/JsonSchemas.ts

@@ -0,0 +1,220 @@
+
+import { join } from 'path'
+import { mkdir, readFile, writeFile } from 'fs/promises'
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+import chalk from 'chalk'
+
+function createAjvInstance(): Ajv {
+    const ajv = new Ajv({
+        allErrors: true,
+        strict: false,
+        validateFormats: true,
+        logger: false
+    })
+    addFormats(ajv)
+    return ajv
+}
+
+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'
+                },
+                schemas: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: {}
+                },
+                resolveDefinition: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, defName: string): Promise<any | null> {
+                        const defValue = this.schemas[defName]
+                        if (!defValue) return null
+                        if (typeof defValue === 'object') return defValue
+                        return null
+                    }
+                },
+                validate: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, definitionName: string, data: any): Promise<{ warnings: any[], errors: any[] }> {
+                        const warnings: any[] = []
+                        const errors: any[] = []
+
+                        const schema = this.schemas[definitionName]
+                        if (!schema) {
+                            errors.push({
+                                type: 'schema_not_found',
+                                message: `Definition "${definitionName}" not found in schema schemas`,
+                                definitionName
+                            })
+                            return { warnings, errors }
+                        }
+
+                        const ajv = createAjvInstance()
+
+                        let validate
+                        try {
+                            validate = ajv.compile(schema)
+                        } catch (error: any) {
+                            warnings.push({
+                                type: 'schema_compilation_failed',
+                                message: `Schema compilation failed for "${definitionName}": ${error.message}`,
+                                definitionName,
+                                error: error.message
+                            })
+                            return { warnings, errors }
+                        }
+
+                        if (!validate(data)) {
+                            const validationErrors = validate.errors?.map((err: any) => ({
+                                path: err.instancePath || '/',
+                                message: err.message,
+                                params: err.params,
+                                keyword: err.keyword,
+                                schemaPath: err.schemaPath
+                            })) || []
+
+                            errors.push({
+                                type: 'validation_failed',
+                                message: `Data does not conform to schema "${definitionName}"`,
+                                definitionName,
+                                validationErrors
+                            })
+                        }
+
+                        return { warnings, errors }
+                    }
+                },
+                registerSchema: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, capsuleName: string, schema: Record<string, any>, schemaMinorVersion?: string): Promise<string | undefined> {
+                        if (!schema || !capsuleName) {
+                            return undefined
+                        }
+
+                        this.schemas[capsuleName] = schema
+
+                        const workspaceRootDir = this.WorkspaceConfig?.workspaceRootDir
+                        if (!workspaceRootDir) {
+                            return undefined
+                        }
+
+                        const jsonSchemaDir = join(
+                            workspaceRootDir,
+                            '.~o',
+                            'workspace.foundation',
+                            capsule['#'].replace(/\//g, '~')
+                        )
+                        await mkdir(jsonSchemaDir, { recursive: true })
+
+                        const version = schemaMinorVersion || '0'
+                        const schemaFilename = capsuleName.replace(/\//g, '~') + '.json'
+                        const schemaFilePath = join(jsonSchemaDir, schemaFilename)
+
+                        const schemaOutput: Record<string, any> = {
+                            $schema: 'https://json-schema.org/draft/2020-12/schema',
+                            $id: capsuleName + '.v' + version,
+                            ...schema
+                        }
+
+                        const schemaJson = JSON.stringify(schemaOutput, null, 4)
+                        const existing = await readFile(schemaFilePath, 'utf-8').catch(() => null)
+                        if (existing !== schemaJson) {
+                            await writeFile(schemaFilePath, schemaJson)
+                        }
+                        return schemaFilePath
+                    }
+                },
+                formatValidationFeedback: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, feedback: { warnings: any[], errors: any[] }, context: { filePath?: string, schemaRef?: string }): string {
+                        const lines: string[] = [
+                            '',
+                            chalk.bold.red('✗ Schema Validation Failed'),
+                            ''
+                        ]
+
+                        if (context.filePath) {
+                            lines.push(
+                                chalk.gray('  File:'),
+                                chalk.yellow(`    ${context.filePath}`),
+                                ''
+                            )
+                        }
+
+                        if (context.schemaRef) {
+                            lines.push(
+                                chalk.gray('  Schema:'),
+                                chalk.cyan(`    ${context.schemaRef}`),
+                                ''
+                            )
+                        }
+
+                        if (feedback.errors.length > 0) {
+                            lines.push(
+                                chalk.gray('  Errors:'),
+                                ...feedback.errors.map((e: any) => chalk.red(`    • ${e.message || e}`)),
+                                ''
+                            )
+                        }
+
+                        if (feedback.warnings.length > 0) {
+                            lines.push(
+                                chalk.gray('  Warnings:'),
+                                ...feedback.warnings.map((w: any) => chalk.yellow(`    • ${w.message || w}`)),
+                                ''
+                            )
+                        }
+
+                        return lines.join('\n')
+                    }
+                },
+                resolveSchemaFilePath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, capsuleName: string): string | undefined {
+                        const workspaceRootDir = this.WorkspaceConfig?.workspaceRootDir
+                        if (!workspaceRootDir) return undefined
+                        const jsonSchemaDir = join(
+                            workspaceRootDir,
+                            '.~o',
+                            'workspace.foundation',
+                            capsule['#'].replace(/\//g, '~')
+                        )
+                        const schemaFilename = capsuleName.replace(/\//g, '~') + '.json'
+                        return join(jsonSchemaDir, schemaFilename)
+                    }
+                },
+                wrapWithSchema: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, data: any, capsuleName: string, version?: string): Record<string, any> {
+                        const output: Record<string, any> = {}
+                        // Use standard JSON Schema URL for $schema
+                        output.$schema = 'https://json-schema.org/draft/2020-12/schema'
+                        // Use entity identifier with version for $id
+                        const versionSuffix = version ? `.v${version}` : '.v0'
+                        output.$id = `${capsuleName}${versionSuffix}`
+                        Object.assign(output, data)
+                        return output
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/JsonSchemas'