@stream44.studio/t44-docker.com 0.1.0-rc.3

package/caps/ImageContext.test.ts

@@ -0,0 +1,130 @@
+#!/usr/bin/env bun test
+
+import * as bunTest from 'bun:test'
+import { run } from 't44/standalone-rt'
+import { join } from 'path'
+
+const {
+    test: { describe, it, expect },
+    imageContext,
+} = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+    const spine = await encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                test: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/ProjectTest',
+                    options: {
+                        '#': {
+                            bunTest,
+                            env: {}
+                        }
+                    }
+                },
+                imageContext: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './ImageContext',
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: '@stream44.studio/t44-docker.com/caps/ImageContext.test'
+    })
+    return { spine }
+}, async ({ spine, apis }: any) => {
+    return apis[spine.capsuleSourceLineRef]
+}, {
+    importMeta: import.meta
+})
+
+describe('ImageContext Capsule', () => {
+
+    describe('DOCKERFILE_VARIANTS', () => {
+        it('should have correct structure', () => {
+            expect(imageContext.DOCKERFILE_VARIANTS).toBeDefined();
+            expect(imageContext.DOCKERFILE_VARIANTS.alpine).toBeDefined();
+            expect(imageContext.DOCKERFILE_VARIANTS.distroless).toBeDefined();
+            expect(imageContext.DOCKERFILE_VARIANTS.alpine.dockerfile).toBe('Dockerfile.alpine');
+            expect(imageContext.DOCKERFILE_VARIANTS.alpine.tagSuffix).toBe('alpine');
+            expect(imageContext.DOCKERFILE_VARIANTS.distroless.dockerfile).toBe('Dockerfile.distroless');
+        });
+    });
+
+    describe('getImageTag', () => {
+        it('should compute correct image tag', () => {
+            imageContext.organization = 'test-org';
+            imageContext.repository = 'test-repo';
+            const tag = imageContext.getImageTag({ variant: 'alpine', arch: 'linux-arm64' });
+            expect(tag).toBe('test-org/test-repo:alpine-arm64');
+        });
+
+        it('should compute tag for x64', () => {
+            imageContext.organization = 'test-org';
+            imageContext.repository = 'test-repo';
+            const tag = imageContext.getImageTag({ variant: 'alpine', arch: 'linux-x64' });
+            expect(tag).toBe('test-org/test-repo:alpine-amd64');
+        });
+
+        it('should throw without variant/arch', () => {
+            imageContext.variant = undefined;
+            imageContext.arch = undefined;
+            expect(() => imageContext.getImageTag()).toThrow('variant and arch must be set');
+        });
+
+        it('should use instance variant/arch when not passed as opts', () => {
+            imageContext.organization = 'test-org';
+            imageContext.repository = 'test-repo';
+            imageContext.variant = 'alpine';
+            imageContext.arch = 'linux-arm64';
+            const tag = imageContext.getImageTag();
+            expect(tag).toBe('test-org/test-repo:alpine-arm64');
+        });
+    });
+
+    describe('getLatestImageTag', () => {
+        it('should append -latest suffix', () => {
+            imageContext.organization = 'test-org';
+            imageContext.repository = 'test-repo';
+            const tag = imageContext.getLatestImageTag({ variant: 'alpine', arch: 'linux-arm64' });
+            expect(tag).toBe('test-org/test-repo:alpine-arm64-latest');
+        });
+    });
+
+    describe('getBuildContextDir', () => {
+        it('should compute correct build context dir from buildContextBaseDir', () => {
+            imageContext.buildContextBaseDir = '/tmp/build';
+            const dir = imageContext.getBuildContextDir({ variant: 'alpine' });
+            expect(dir).toBe('/tmp/build/alpine');
+        });
+
+        it('should derive buildContextBaseDir from appBaseDir when not set', () => {
+            imageContext.buildContextBaseDir = '';
+            imageContext.appBaseDir = '/tmp/myapp';
+            const dir = imageContext.getBuildContextDir({ variant: 'alpine' });
+            expect(dir).toBe(join('/tmp/myapp', '.~o/t44-docker.com', 'alpine'));
+        });
+
+        it('should throw without variant', () => {
+            imageContext.variant = undefined;
+            expect(() => imageContext.getBuildContextDir()).toThrow('variant must be set');
+        });
+
+        it('should use instance variant when not passed as opts', () => {
+            imageContext.buildContextBaseDir = '/tmp/build';
+            imageContext.variant = 'distroless';
+            const dir = imageContext.getBuildContextDir();
+            expect(dir).toBe('/tmp/build/distroless');
+        });
+    });
+
+    describe('templateDir', () => {
+        it('should default to the bundled tpl directory', () => {
+            expect(imageContext.templateDir).toBeTruthy();
+            expect(imageContext.templateDir).toContain('Image');
+            expect(imageContext.templateDir).toContain('tpl');
+        });
+    });
+});

package/caps/ImageContext.ts

@@ -0,0 +1,126 @@
+import { join } from 'path'
+
+const DEFAULT_TEMPLATE_DIR = join(__dirname, 'Image', 'tpl');
+
+const DOCKERFILE_VARIANTS = {
+    alpine: { dockerfile: 'Dockerfile.alpine', tagSuffix: 'alpine', variantDir: 'alpine', variant: 'alpine' },
+    distroless: { dockerfile: 'Dockerfile.distroless', tagSuffix: 'distroless', variantDir: 'distroless', variant: 'distroless' },
+} as const;
+
+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': {},
+            '#': {
+                cli: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './Cli',
+                },
+
+                verbose: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: false,
+                },
+                organization: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: '' as string,
+                },
+                repository: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: '' as string,
+                },
+                appBaseDir: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: '' as string,
+                },
+                buildContextBaseDir: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: '' as string,
+                },
+                templateDir: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: DEFAULT_TEMPLATE_DIR as string,
+                },
+                variant: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: undefined as string | undefined,
+                },
+                arch: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: undefined as string | undefined,
+                },
+                buildScriptName: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: undefined as string | undefined,
+                },
+                files: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: undefined as Record<string, any> | undefined,
+                },
+                attestations: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: undefined as { sbom?: boolean; provenance?: boolean } | undefined,
+                },
+                tagLatest: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: false,
+                },
+
+                DOCKERFILE_VARIANTS: {
+                    type: CapsulePropertyTypes.Constant,
+                    value: DOCKERFILE_VARIANTS,
+                },
+
+                /**
+                 * Compute image tag from org/repo/variant/arch
+                 */
+                getImageTag: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, opts?: { variant?: string; arch?: string }): string {
+                        const variant = opts?.variant ?? this.variant;
+                        const arch = opts?.arch ?? this.arch;
+                        if (!variant || !arch) {
+                            throw new Error('variant and arch must be set to get image tag');
+                        }
+                        const variantInfo = DOCKERFILE_VARIANTS[variant as keyof typeof DOCKERFILE_VARIANTS];
+                        const archInfo = this.cli.DOCKER_ARCHS[arch as keyof typeof this.cli.DOCKER_ARCHS];
+                        return `${this.organization}/${this.repository}:${variantInfo.tagSuffix}-${archInfo.arch}`;
+                    }
+                },
+
+                getLatestImageTag: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, opts?: { variant?: string; arch?: string }): string {
+                        return `${this.getImageTag(opts)}-latest`;
+                    }
+                },
+
+                getBuildContextDir: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, opts?: { variant?: string }): string {
+                        const variant = opts?.variant ?? this.variant;
+                        if (!variant) {
+                            throw new Error('variant must be set to get build context directory');
+                        }
+                        const effectiveBuildContextBaseDir = this.buildContextBaseDir
+                            || (this.appBaseDir ? join(this.appBaseDir, '.~o/t44-docker.com') : '');
+                        return join(effectiveBuildContextBaseDir, DOCKERFILE_VARIANTS[variant as keyof typeof DOCKERFILE_VARIANTS].variantDir);
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: '@stream44.studio/t44-docker.com/caps/ImageContext',
+    })
+}

package/caps/Project.test.ts

@@ -0,0 +1,267 @@
+#!/usr/bin/env bun test --timeout 180000
+
+import * as bunTest from 'bun:test'
+import { describe, it, expect } from 'bun:test'
+import { run } from 't44/standalone-rt'
+import { join, basename } from 'path'
+import { mkdir, writeFile } from 'fs/promises'
+
+const { test: { workbenchDir } } = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+    const spine = await encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                test: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/ProjectTest',
+                    options: { '#': { bunTest, env: {} } }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: '@stream44.studio/t44-docker.com/caps/Project.test'
+    })
+    return { spine }
+}, async ({ spine, apis }: any) => {
+    return apis[spine.capsuleSourceLineRef]
+}, { importMeta: import.meta })
+
+async function createSampleApp(baseDir: string): Promise<void> {
+    await mkdir(baseDir, { recursive: true });
+
+    await writeFile(join(baseDir, 'index.ts'), `
+const server = Bun.serve({
+    port: 3000,
+    fetch(req) {
+        return new Response("Hello from project test!");
+    },
+});
+console.log("READY");
+console.log(\`Server running on port \${server.port}\`);
+`);
+
+    await writeFile(join(baseDir, 'package.json'), JSON.stringify({
+        name: 'project-test-app',
+        version: '0.1.0',
+        scripts: { start: 'bun run index.ts' }
+    }, null, 2));
+}
+
+describe('Project Capsule', () => {
+
+    describe('getDevelopmentContainerConfig', () => {
+        it('should return correct container config', async () => {
+            const config = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+                const spine = await encapsulate({
+                    '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                        '#@stream44.studio/encapsulate/structs/Capsule': {},
+                        '#': {
+                            project: {
+                                type: CapsulePropertyTypes.Mapping,
+                                value: './Project',
+                                options: {
+                                    '@stream44.studio/t44-docker.com/caps/ImageContext': {
+                                        '#': {
+                                            organization: 'test-docker-com',
+                                            repository: 'project-config-test',
+                                            appBaseDir: '/tmp/test',
+                                            verbose: false
+                                        },
+                                    },
+                                    '@stream44.studio/t44-docker.com/caps/ContainerContext': {
+                                        '#': {
+                                            ports: [{ internal: 3000, external: 4000 }],
+                                        },
+                                    },
+                                },
+                            },
+                        }
+                    }
+                }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44-docker.com/caps/Project.test.config' })
+                return { spine }
+            }, async ({ spine, apis }: any) => {
+                return apis[spine.capsuleSourceLineRef].project.getDevelopmentContainerConfig()
+            }, { importMeta: import.meta, runFromSnapshot: false })
+
+            expect(config.image).toContain('test-docker-com/project-config-test');
+            expect(config.ports).toContainEqual({ internal: 3000, external: 4000 });
+            expect(config.name).toContain('dev');
+            expect(config.waitFor).toBe('READY');
+            expect(config.detach).toBe(true);
+        });
+
+        it('should merge runConfig env', async () => {
+            const config = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+                const spine = await encapsulate({
+                    '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                        '#@stream44.studio/encapsulate/structs/Capsule': {},
+                        '#': {
+                            project: {
+                                type: CapsulePropertyTypes.Mapping,
+                                value: './Project',
+                                options: {
+                                    '@stream44.studio/t44-docker.com/caps/ImageContext': {
+                                        '#': {
+                                            organization: 'test-docker-com',
+                                            repository: 'project-env-test',
+                                            appBaseDir: '/tmp/test',
+                                            verbose: false
+                                        },
+                                    },
+                                    '@stream44.studio/t44-docker.com/caps/ContainerContext': {
+                                        '#': {
+                                            ports: [{ internal: 3000, external: 4000 }],
+                                            env: {
+                                                MY_VAR: 'my-value',
+                                                DEBUG: 'true'
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        }
+                    }
+                }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44-docker.com/caps/Project.test.env' })
+                return { spine }
+            }, async ({ spine, apis }: any) => {
+                return apis[spine.capsuleSourceLineRef].project.getDevelopmentContainerConfig()
+            }, { importMeta: import.meta, runFromSnapshot: false })
+
+            expect(config.env.MY_VAR).toBe('my-value');
+            expect(config.env.DEBUG).toBe('true');
+        });
+    });
+
+    describe('buildDev + runDev + stopDev', () => {
+        it('should build, run, verify, and stop a dev container', async () => {
+            const appDir = join(workbenchDir, 'project-full-test');
+            await createSampleApp(appDir);
+
+            await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+                const spine = await encapsulate({
+                    '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                        '#@stream44.studio/encapsulate/structs/Capsule': {},
+                        '#': {
+                            project: {
+                                type: CapsulePropertyTypes.Mapping,
+                                value: './Project',
+                                options: {
+                                    '@stream44.studio/t44-docker.com/caps/ContainerContext': {
+                                        '#': {
+                                            ports: [{ internal: 3000, external: 13581 }],
+                                        },
+                                    },
+                                    '@stream44.studio/t44-docker.com/caps/ImageContext': {
+                                        '#': {
+                                            organization: 'test-docker-com',
+                                            repository: 'project-full-test',
+                                            verbose: false
+                                        },
+                                    },
+                                },
+                            },
+                        }
+                    }
+                }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44-docker.com/caps/Project.test.full' })
+                return { spine }
+            }, async ({ spine, apis }: any) => {
+                const project = apis[spine.capsuleSourceLineRef].project
+
+                project.image.context.appBaseDir = appDir;
+                project.image.context.buildContextBaseDir = join(appDir, '.~o/t44-docker.com');
+
+                const buildResult = await project.buildDev();
+                expect(buildResult.imageTag).toBeTruthy();
+                expect(buildResult.imageTag).toContain('test-docker-com/project-full-test');
+
+                const { containerId, stop, ensureRunning } = await project.runDev();
+                expect(containerId).toBeTruthy();
+
+                const isRunning = await ensureRunning();
+                expect(isRunning).toBe(true);
+
+                await stop();
+                await project.image.removeImage({ image: buildResult.imageTag, force: true }).catch(() => { });
+            }, { importMeta: import.meta, runFromSnapshot: false })
+        }, 180000);
+    });
+
+    describe('retagImages', () => {
+        it('should retag images from source to target org/repo', async () => {
+            const appDir = join(workbenchDir, 'project-retag-test');
+            await createSampleApp(appDir);
+
+            await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+                const sourceSpine = await encapsulate({
+                    '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                        '#@stream44.studio/encapsulate/structs/Capsule': {},
+                        '#': {
+                            project: {
+                                type: CapsulePropertyTypes.Mapping,
+                                value: './Project',
+                                options: {
+                                    '@stream44.studio/t44-docker.com/caps/ImageContext': {
+                                        '#': {
+                                            organization: 'test-docker-com',
+                                            repository: 'project-retag-source',
+                                            verbose: false
+                                        },
+                                    },
+                                },
+                            },
+                        }
+                    }
+                }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44-docker.com/caps/Project.test.retag-source' })
+
+                const targetSpine = await encapsulate({
+                    '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+                        '#@stream44.studio/encapsulate/structs/Capsule': {},
+                        '#': {
+                            project: {
+                                type: CapsulePropertyTypes.Mapping,
+                                value: './Project',
+                                options: {
+                                    '@stream44.studio/t44-docker.com/caps/ImageContext': {
+                                        '#': {
+                                            organization: 'test-docker-com',
+                                            repository: 'project-retag-target',
+                                            verbose: false
+                                        },
+                                    },
+                                },
+                            },
+                        }
+                    }
+                }, { importMeta: import.meta, importStack: makeImportStack(), capsuleName: '@stream44.studio/t44-docker.com/caps/Project.test.retag-target' })
+
+                return { sourceSpine, targetSpine }
+            }, async ({ sourceSpine, targetSpine, apis }: any) => {
+                const sourceProject = apis[sourceSpine.capsuleSourceLineRef].project
+                const targetProject = apis[targetSpine.capsuleSourceLineRef].project
+
+                sourceProject.image.context.appBaseDir = appDir;
+                sourceProject.image.context.buildContextBaseDir = join(appDir, '.~o/t44-docker.com');
+                targetProject.image.context.appBaseDir = appDir;
+                targetProject.image.context.buildContextBaseDir = join(appDir, '.~o/t44-docker.com');
+
+                const currentArch = sourceProject.cli.getCurrentPlatformArch();
+                await sourceProject.image.buildVariant({ variant: 'alpine', arch: currentArch });
+
+                await targetProject.retagImages({ organization: 'test-docker-com', repository: 'project-retag-source' });
+
+                const targetTags = await targetProject.image.getTags({ organization: 'test-docker-com', repository: 'project-retag-target' });
+                expect(targetTags.length).toBeGreaterThan(0);
+
+                for (const tag of targetTags) {
+                    await targetProject.image.removeImage({ image: tag.tag, force: true }).catch(() => { });
+                }
+                const sourceTags = await sourceProject.image.getTags({ organization: 'test-docker-com', repository: 'project-retag-source' });
+                for (const tag of sourceTags) {
+                    await sourceProject.image.removeImage({ image: tag.tag, force: true }).catch(() => { });
+                }
+            }, { importMeta: import.meta, runFromSnapshot: false })
+        }, 120000);
+    });
+});