@adaas/a-frame 0.0.22 → 0.1.1

package/src/lib/A-FrameCLI/A-FrameCLI.container.ts

@@ -0,0 +1,333 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { A_Concept, A_Container, A_Context, A_Error, A_Inject } from "@adaas/a-concept";
+import { A_FrameIndex } from '../A-FrameIndex/A-FrameIndex.context';
+import { A_FrameLogger } from '../A-FrameLogger';
+import { A_FrameBundleBuilder, A_FRAME_BUNDLE_DEFAULT_FILENAME } from '../A-FrameBundle';
+import { A_FrameChannel } from '../A-FrameChannel/A-FrameChannel.component';
+import { A_FrameEnv } from '../A-FrameEnv/A-FrameEnv.fragment.env-node';
+
+
+/**
+ * Decorator call patterns that signal a file registers A-Frame definitions.
+ * Matched against raw file content before importing to avoid loading every file.
+ */
+const DECORATOR_PATTERNS = [
+    /A_Frame\.Define\s*\(/,
+    /A_Frame\.NameSpace\s*\(/,
+    /A_Frame\.Component\s*\(/,
+    /A_Frame\.Entity\s*\(/,
+    /A_Frame\.Fragment\s*\(/,
+    /A_Frame\.Container\s*\(/,
+];
+
+export class A_FrameCLIContainer extends A_Container {
+
+    /**
+     * Logger instance — bound during `initialize()` via DI so the rest of
+     * the container can use it through `this.logger`.
+     */
+    get logger(): A_FrameLogger {
+        return A_Context.scope(this).resolve(A_FrameLogger) as A_FrameLogger;
+    };
+
+    @A_Concept.Load()
+    async initialize(
+        @A_Inject(A_FrameLogger) logger: A_FrameLogger,
+    ) {
+        if (A_Context.environment !== 'server') {
+            throw new A_Error('A-Frame CLI can only be used in Node.js environment.');
+        }
+    }
+
+    @A_Concept.Start()
+    async readCommandParams(
+        @A_Inject(A_FrameChannel) channel: A_FrameChannel,
+        @A_Inject(A_FrameEnv) env: A_FrameEnv,
+    ) {
+        const args = process.argv.slice(2);
+
+        switch (true) {
+            case args.includes('--embed'): {
+                const pathArg = args[args.indexOf('--embed') + 1];
+                if (!pathArg) {
+                    this.logger.error('--embed requires a path, directory, or glob pattern as next argument');
+                    process.exit(1);
+                }
+                await this.embed(pathArg);
+                break;
+            }
+            case args.includes('--bundle'): {
+                const outArg = args[args.indexOf('--bundle') + 1];
+                await this.bundle(outArg, channel, env);
+                break;
+            }
+            case args.includes('--search'):
+                this.logger.info('Search command detected');
+                break;
+            default:
+                this.logger.warn('No valid command detected. Available commands: --embed <path|dir|glob>, --bundle [out], --search');
+        }
+    }
+
+    // ─── Bundle ─────────────────────────────────────────────────────────────
+
+    /**
+     * Package the encrypted `.aframe` files in `A_FRAME_STORAGE_DIR` into a
+     * single artifact consumable by the browser bundle. Output format is
+     * inferred from the file extension (`.ts`/`.tsx` → typed module, anything
+     * else → JSON).
+     */
+    private async bundle(
+        outArg: string | undefined,
+        channel: A_FrameChannel,
+        env: A_FrameEnv,
+    ): Promise<void> {
+        this.logger.resetTimer();
+        this.logger.section('Building A-Frame browser bundle');
+
+        const storageDir = env.A_FRAME_STORAGE_DIR
+            ? path.resolve(env.A_FRAME_STORAGE_DIR)
+            : path.resolve(process.cwd(), 'storage');
+        const outFile = path.resolve(
+            process.cwd(),
+            outArg || A_FRAME_BUNDLE_DEFAULT_FILENAME,
+        );
+
+        this.logger.info(`Storage:  ${storageDir}`);
+        this.logger.info(`Output:   ${outFile}`);
+
+        // Need server version to stamp the bundle metadata. Authenticate first.
+        let serverVersion = 'unknown';
+        try {
+            const credentials = await channel.getCredentials();
+            if (credentials.error) {
+                this.logger.warn(`Could not fetch credentials: ${credentials.error.message}. Bundle will be tagged with serverVersion="unknown".`);
+            } else {
+                serverVersion = credentials.response?.server_version || 'unknown';
+            }
+        } catch (err) {
+            this.logger.warn(`getCredentials failed: ${err instanceof Error ? err.message : String(err)}. Bundle will be tagged with serverVersion="unknown".`);
+        }
+
+        const builder = new A_FrameBundleBuilder();
+        try {
+            const bundle = await builder.build({ storageDir, serverVersion });
+            await builder.writeAuto(bundle, outFile);
+
+            this.logger.set('namespaces', bundle.namespaces ? 1 : 0);
+            this.logger.set('definitionFiles', Object.keys(bundle.definitions).length);
+            this.logger.set('serverVersion', 0); // placeholder (counters are numeric)
+            this.logger.success(`Bundle written to ${outFile}`);
+            this.logger.info(`  serverVersion: ${bundle.serverVersion}`);
+            this.logger.info(`  aFrameVersion: ${bundle.aFrameVersion}`);
+            this.logger.summary('Bundle Stats');
+        } catch (err) {
+            this.logger.error(`Bundle build failed: ${err instanceof Error ? err.message : String(err)}`);
+            this.logger.summary('Bundle Stats');
+            process.exit(1);
+        }
+    }
+
+    // ─── Embed ───────────────────────────────────────────────────────────────
+
+    private async embed(pattern: string): Promise<void> {
+        this.logger.resetTimer();
+        this.logger.section(`Embedding: ${pattern}`);
+
+        // 1. Discover source files
+        const files = this.resolveFiles(pattern);
+        this.logger.info(`Discovered ${files.length} candidate file(s)`);
+        this.logger.set('files.scanned', files.length);
+
+        if (files.length === 0) {
+            this.logger.warn(`No files found for: ${pattern}`);
+            this.logger.summary();
+            return;
+        }
+
+        // 2. Filter files that contain A-Frame decorators
+        const decoratedFiles = files.filter(f => this.containsDecorators(f));
+        this.logger.info(`Found ${decoratedFiles.length} file(s) with A-Frame decorators`);
+        this.logger.set('files.matched', decoratedFiles.length);
+
+        if (decoratedFiles.length === 0) {
+            this.logger.warn('Nothing to embed.');
+            this.logger.summary();
+            return;
+        }
+
+        // 3. Import them — decorators auto-register into A_FrameIndex
+        const importBar = this.logger.progress('Importing files', decoratedFiles.length);
+        for (const file of decoratedFiles) {
+            try {
+                await import(file);
+                importBar.tick(path.basename(file));
+                this.logger.increment('files.imported');
+            } catch (err) {
+                importBar.tick(`failed: ${path.basename(file)}`);
+                this.logger.increment('files.failed');
+                this.logger.error(`Failed to import ${file}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        importBar.succeed('done');
+
+        // 4. Collect items needing embed
+        const index = A_FrameIndex.instance;
+        const namespacesNeedEmbed = index.listNamespaces().filter(ns => !ns.isEmbed);
+        const definitionsNeedEmbed = index.listDefinitions({}).filter(def => !def.isEmbed);
+
+        this.logger.set('namespaces.total', index.listNamespaces().length);
+        this.logger.set('definitions.total', index.listDefinitions({}).length);
+        this.logger.set('namespaces.toEmbed', namespacesNeedEmbed.length);
+        this.logger.set('definitions.toEmbed', definitionsNeedEmbed.length);
+
+        // 5. Embed namespaces (parallel API calls, sequential file writes)
+        if (namespacesNeedEmbed.length > 0) {
+            const nsBar = this.logger.progress('Embedding namespaces', namespacesNeedEmbed.length);
+            for (const batch of this.chunkArray(namespacesNeedEmbed, 10)) {
+                await Promise.all(batch.map(async ns => {
+                    try {
+                        await ns.embed();
+                        this.logger.increment('namespaces.embedded');
+                    } catch (err) {
+                        this.logger.increment('namespaces.failed');
+                        this.logger.error(`Embed failed for namespace "${ns.name}": ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    nsBar.tick(ns.name);
+                }));
+                for (const ns of batch) {
+                    try { await ns.save(); this.logger.increment('namespaces.saved'); }
+                    catch (err) {
+                        this.logger.increment('namespaces.saveFailed');
+                        this.logger.error(`Save failed for namespace "${ns.name}": ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+            nsBar.succeed('done');
+        }
+
+        // 6. Embed definitions (parallel API calls, sequential file writes)
+        if (definitionsNeedEmbed.length > 0) {
+            const defBar = this.logger.progress('Embedding definitions', definitionsNeedEmbed.length);
+            for (const batch of this.chunkArray(definitionsNeedEmbed, 10)) {
+                await Promise.all(batch.map(async def => {
+                    try {
+                        await def.embed();
+                        this.logger.increment('definitions.embedded');
+                    } catch (err) {
+                        this.logger.increment('definitions.failed');
+                        this.logger.error(`Embed failed for "${def.name}": ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    defBar.tick(def.name);
+                }));
+                for (const def of batch) {
+                    try { await def.save(); this.logger.increment('definitions.saved'); }
+                    catch (err) {
+                        this.logger.increment('definitions.saveFailed');
+                        this.logger.error(`Save failed for "${def.name}": ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+            defBar.succeed('done');
+        }
+
+        this.logger.summary('Embed Stats');
+    }
+
+    // ─── File discovery (no external deps) ───────────────────────────────────
+
+    /**
+     * Resolve a path argument to an array of absolute `.ts`/`.js` file paths.
+     * Handles:
+     *   - Single file          → [file]
+     *   - Directory            → all source files found recursively
+     *   - Glob pattern         → files matching the pattern
+     */
+    private resolveFiles(pattern: string): string[] {
+        const absolute = path.isAbsolute(pattern)
+            ? pattern
+            : path.resolve(process.cwd(), pattern);
+
+        // No glob characters — plain file or directory path
+        if (!/[*?{]/.test(pattern)) {
+            const stat = (fs as any).statSync(absolute, { throwIfNoEntry: false }) as fs.Stats | undefined;
+            if (!stat) return [];
+            if (stat.isFile()) return this.isSourceFile(absolute) ? [absolute] : [];
+            if (stat.isDirectory()) return this.walkDir(absolute);
+            return [];
+        }
+
+        // Glob pattern: find the static base dir (before first segment with glob chars)
+        const sep = path.sep;
+        const parts = absolute.split(sep);
+        const firstGlobIdx = parts.findIndex(p => /[*?{]/.test(p));
+        const baseDir = parts.slice(0, firstGlobIdx).join(sep) || sep;
+        const relPattern = parts.slice(firstGlobIdx).join('/');
+
+        return this.walkDir(baseDir).filter(file => {
+            const rel = path.relative(baseDir, file).replace(/\\/g, '/');
+            return this.matchGlob(rel, relPattern);
+        });
+    }
+
+    /** Recursively collect all source files under a directory. */
+    private walkDir(dir: string): string[] {
+        const results: string[] = [];
+        let entries: fs.Dirent[];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+            return results;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...this.walkDir(full));
+            } else if (entry.isFile() && this.isSourceFile(full)) {
+                results.push(full);
+            }
+        }
+        return results;
+    }
+
+    private isSourceFile(file: string): boolean {
+        return /\.(ts|js|mts|mjs|cts|cjs)$/.test(file);
+    }
+
+    /**
+     * Minimal glob matcher (no external deps).
+     * Supports `*` (any chars except `/`), `**` (any path segments), `?` (one char).
+     */
+    private matchGlob(str: string, pattern: string): boolean {
+        const segments = pattern.split('/');
+        const regexStr = segments
+            .map(seg => {
+                if (seg === '**') return '(?:[^/]+/)*[^/]*';
+                return seg
+                    .replace(/\./g, '\\.')
+                    .replace(/\*/g, '[^/]*')
+                    .replace(/\?/g, '[^/]');
+            })
+            .join('/');
+        return new RegExp(`^${regexStr}$`).test(str);
+    }
+
+    /** Returns true if the file source contains any A-Frame decorator calls. */
+    private containsDecorators(filePath: string): boolean {
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            return DECORATOR_PATTERNS.some(re => re.test(content));
+        } catch {
+            return false;
+        }
+    }
+
+    private chunkArray<T>(array: T[], size: number): T[][] {
+        const result: T[][] = [];
+        for (let i = 0; i < array.length; i += size) {
+            result.push(array.slice(i, i + size));
+        }
+        return result;
+    }
+}

package/src/lib/A-FrameChannel/A-FrameChannel.component.env-browser.ts

@@ -0,0 +1,63 @@
+import { A_Feature, A_Inject } from "@adaas/a-concept";
+import { A_FrameFeatures } from "./A-FrameChannel.constants";
+import { A_FrameChannelRequest } from "./A-FrameChannelRequest.context";
+import { A_FrameEnv } from "../A-FrameEnv/A-FrameEnv.fragment.env-browser";
+import { A_FrameChannelError } from "./A-FrameChannel.error";
+import { A_FrameChannel } from "./A-FrameChannel.component";
+
+/**
+ * A_FrameChannel — Browser environment
+ *
+ * HTTP client for the embed-server API.
+ * Configuration must be provided explicitly via configure() since there is
+ * no process.env in the browser.
+ *
+ * At build time, generate .bin index files in Node. In the browser, load them
+ * via A_FrameStorage.loadBlob() — no embedding calls are needed at runtime.
+ */
+export class A_FrameBrowserChannel extends A_FrameChannel {
+
+
+    @A_Feature.Extend({
+        name: A_FrameFeatures.Request,
+        scope: [A_FrameChannel],
+    })
+     async request(
+        @A_Inject(A_FrameChannelRequest) context: A_FrameChannelRequest,
+        @A_Inject(A_FrameEnv) env: A_FrameEnv,
+    ) {
+        const url = `${env.A_FRAME_SERVER_URL}${context.path}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+            controller.abort()
+            context.fail(new A_FrameChannelError({
+                title: A_FrameChannelError.Timeout,
+                description: `Request to ${context.path} timed out after 15 seconds`,
+            }));
+        }, 15_000);
+        try {
+            const resp = await fetch(url, {
+                method: context.method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`,
+                },
+                body: context.body !== undefined ? JSON.stringify(context.body) : undefined,
+                signal: controller.signal,
+            });
+
+            context.complete(await resp.json());
+
+        } catch (err) {
+            context.fail(new A_FrameChannelError({
+                title: A_FrameChannelError.RequestFailed,
+                description: `Request to ${context.path} failed or timed out`,
+            }));
+        } finally {
+            clearTimeout(timer);
+        }
+    }
+}
+
+
+