nuclie 1.0.0

package/dist/marketplace/plugin-adapter.js

@@ -0,0 +1,85 @@
+/**
+ * Adapter to run Community (Vite/Rollup) plugins within Nuclie
+ * Converts middleware-based plugins to Nuclie's Command Pattern
+ */
+export function adaptPlugin(plugin) {
+    const hooks = [];
+    if (plugin.resolveId)
+        hooks.push('resolveId');
+    if (plugin.load)
+        hooks.push('load');
+    if (plugin.transform)
+        hooks.push('transformModule');
+    // Nuclie mandates strict versioning, so we mock it for community plugins
+    return {
+        manifest: {
+            name: `adapter:${plugin.name}`,
+            version: '0.0.0-adapter', // Placeholder
+            engineVersion: '2.0.0', // Target current engine
+            type: 'js',
+            hooks: hooks,
+            permissions: { fs: 'read' }
+        },
+        // Unique ID generation to safely allow multiple instances
+        id: `adapter:${plugin.name}-${Math.random().toString(36).substring(2, 6)}`,
+        async runHook(hookName, input, context) {
+            // 1. ResolveId Hook
+            if (hookName === 'resolveId' && plugin.resolveId) {
+                const handler = typeof plugin.resolveId === 'function' ? plugin.resolveId : plugin.resolveId.handler;
+                const ctx = {
+                    resolve: () => { }, // Mock resolve context
+                    warn: (msg) => console.warn(`[${plugin.name}] ${msg}`),
+                    error: (msg) => console.error(`[${plugin.name}] ${msg}`)
+                };
+                try {
+                    // Adapt input: Nuclie passes object { source, importer }, Rollup expects (source, importer)
+                    const source = input.source || input.id;
+                    const importer = input.importer;
+                    const res = await handler.call(ctx, source, importer, { isEntry: false });
+                    if (!res)
+                        return null;
+                    return typeof res === 'string' ? { id: res } : { id: res.id };
+                }
+                catch (e) {
+                    return null; // Fallback to next plugin
+                }
+            }
+            // 2. Load Hook
+            if (hookName === 'load' && plugin.load) {
+                const handler = typeof plugin.load === 'function' ? plugin.load : plugin.load.handler;
+                const ctx = {
+                    warn: (msg) => console.warn(`[${plugin.name}] ${msg}`),
+                    error: (msg) => console.error(`[${plugin.name}] ${msg}`)
+                };
+                try {
+                    const res = await handler.call(ctx, input.id);
+                    return res ? { code: typeof res === 'string' ? res : res.code } : null;
+                }
+                catch (e) {
+                    return null;
+                }
+            }
+            // 3. Transform Hook
+            if (hookName === 'transformModule' && plugin.transform) {
+                const handler = typeof plugin.transform === 'function' ? plugin.transform : plugin.transform.handler;
+                const ctx = {
+                    warn: (msg) => console.warn(`[${plugin.name}] ${msg}`),
+                    error: (msg) => console.error(`[${plugin.name}] ${msg}`)
+                };
+                try {
+                    const res = await handler.call(ctx, input.code, input.path);
+                    if (!res)
+                        return input;
+                    if (typeof res === 'string')
+                        return { ...input, code: res };
+                    return { ...input, code: res.code, map: res.map }; // Merge maps if needed
+                }
+                catch (e) {
+                    console.error(`Adapter error for ${plugin.name}:`, e);
+                    return input;
+                }
+            }
+            return input;
+        }
+    };
+}

package/dist/marketplace/server.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Nuclie Marketplace tRPC Server
+ * Implementation: tRPC Router for Publish/Search/Install
+ * Day 10: Marketplace MVP Lock
+ */
+export declare const createContext: () => {};
+export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {};
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    /**
+     * Search for plugins
+     */
+    search: import("@trpc/server").TRPCQueryProcedure<{
+        input: string;
+        output: {
+            name: string;
+            version: string;
+            description: string;
+            author: string;
+            verified: boolean;
+        }[];
+        meta: object;
+    }>;
+    /**
+     * Publish a plugin
+     * Verifies signature and hash before accepting.
+     */
+    publish: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            manifest: {
+                name: string;
+                version: string;
+                author: string;
+                description: string;
+                hash: string;
+                signature: string;
+                publicKey: string;
+                permissions: {
+                    network?: boolean | undefined;
+                    fs?: boolean | undefined;
+                };
+            };
+            wasmBase64: string;
+        };
+        output: {
+            success: boolean;
+            message: string;
+        };
+        meta: object;
+    }>;
+    /**
+     * Install (Get) a plugin
+     */
+    install: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            name: string;
+            version?: string | undefined;
+        };
+        output: import("./db.js").PluginRecord;
+        meta: object;
+    }>;
+}>>;
+export type AppRouter = typeof appRouter;

package/dist/marketplace/server.js

@@ -0,0 +1,97 @@
+/**
+ * Nuclie Marketplace tRPC Server
+ * Implementation: tRPC Router for Publish/Search/Install
+ * Day 10: Marketplace MVP Lock
+ */
+import { initTRPC, TRPCError } from '@trpc/server';
+import { z } from 'zod';
+import { marketplaceDB } from './db.js';
+import { PluginSigner } from '../plugins/signer.js';
+// Context (empty for local mvp)
+export const createContext = () => ({});
+const t = initTRPC.context().create();
+export const appRouter = t.router({
+    /**
+     * Search for plugins
+     */
+    search: t.procedure
+        .input(z.string())
+        .query(({ input }) => {
+        const results = marketplaceDB.search(input);
+        return results.map(r => ({
+            name: r.name,
+            version: r.version,
+            description: r.description,
+            author: r.author,
+            verified: true // In our DB, only signed stuff gets in
+        }));
+    }),
+    /**
+     * Publish a plugin
+     * Verifies signature and hash before accepting.
+     */
+    publish: t.procedure
+        .input(z.object({
+        manifest: z.object({
+            name: z.string(),
+            version: z.string(),
+            author: z.string(),
+            description: z.string(),
+            hash: z.string(),
+            signature: z.string(),
+            publicKey: z.string(),
+            permissions: z.object({
+                network: z.boolean().optional(),
+                fs: z.boolean().optional()
+            })
+        }),
+        wasmBase64: z.string() // WASM binary as Base64 for transport
+    }))
+        .mutation(async ({ input }) => {
+        const { manifest, wasmBase64 } = input;
+        const wasmBytes = Buffer.from(wasmBase64, 'base64');
+        // 1. Verify Hash Integrity
+        const calcHash = await PluginSigner.calculateHash(wasmBytes);
+        if (calcHash !== manifest.hash) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: `Hash mismatch. Manifest: ${manifest.hash}, Calc: ${calcHash}`
+            });
+        }
+        // 2. Verify Signature
+        const publicKey = await PluginSigner.importKey(manifest.publicKey, 'public');
+        const isValid = await PluginSigner.verify(wasmBytes, manifest.signature, publicKey);
+        if (!isValid) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'Invalid Signature. Plugin rejected.'
+            });
+        }
+        // 3. Save to DB
+        marketplaceDB.publish({
+            ...manifest,
+            public_key: manifest.publicKey,
+            permissions_json: JSON.stringify(manifest.permissions),
+            created_at: new Date().toISOString()
+        });
+        return { success: true, message: `Published ${manifest.name}@${manifest.version}` };
+    }),
+    /**
+     * Install (Get) a plugin
+     */
+    install: t.procedure
+        .input(z.object({
+        name: z.string(),
+        version: z.string().optional()
+    }))
+        .query(({ input }) => {
+        const plugin = marketplaceDB.get(input.name, input.version);
+        if (!plugin) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: `Plugin ${input.name} not found`
+            });
+        }
+        return plugin;
+    })
+});

package/dist/meta-frameworks/base-router.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Base Router Implementation
+ * Shared utilities for all meta-framework routers
+ */
+import { Route, RouteManifest, RouteMatch, IRouter, RouterConfig } from './types.js';
+export declare abstract class BaseRouter implements IRouter {
+    protected config: RouterConfig;
+    protected manifest: RouteManifest | null;
+    constructor(config: RouterConfig);
+    abstract scanRoutes(): Promise<RouteManifest>;
+    /**
+     * Match a URL to a route
+     */
+    match(url: string): RouteMatch | null;
+    /**
+     * Generate URL from route name and params
+     */
+    generate(name: string, params?: Record<string, any>): string;
+    /**
+     * Validate route configuration
+     */
+    validate(): Promise<void>;
+    /**
+     * Recursively scan directory for route files
+     */
+    protected scanDirectory(dir: string, extensions?: string[]): Promise<string[]>;
+    /**
+     * Convert file path to route path
+     */
+    protected fileToRoutePath(filePath: string, baseDir: string): string;
+    /**
+     * Extract dynamic parameters from route path
+     */
+    protected extractParams(routePath: string): string[];
+    /**
+     * Check if route path has dynamic segments
+     */
+    protected isDynamicPath(routePath: string): boolean;
+    /**
+     * Match dynamic route against pathname
+     */
+    protected matchDynamicRoute(pathname: string, route: Route): Record<string, string> | null;
+    /**
+     * Convert route path to regex pattern
+     */
+    protected routeToRegex(routePath: string): RegExp;
+    /**
+     * Parse query string
+     */
+    protected parseQuery(search?: string): Record<string, string>;
+    /**
+     * Build route tree from flat list
+     */
+    protected buildRouteTree(routes: Route[]): Route[];
+    /**
+     * Create route manifest
+     */
+    protected createManifest(routes: Route[]): RouteManifest;
+    /**
+     * Log route scanning results
+     */
+    protected logRoutes(manifest: RouteManifest): void;
+}

package/dist/meta-frameworks/base-router.js

@@ -0,0 +1,259 @@
+/**
+ * Base Router Implementation
+ * Shared utilities for all meta-framework routers
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { log } from '../utils/logger.js';
+export class BaseRouter {
+    constructor(config) {
+        this.manifest = null;
+        this.config = config;
+    }
+    /**
+     * Match a URL to a route
+     */
+    match(url) {
+        if (!this.manifest) {
+            throw new Error('Routes not scanned. Call scanRoutes() first.');
+        }
+        const [pathname, search] = url.split('?');
+        const query = this.parseQuery(search);
+        // Try exact match first
+        const exactMatch = this.manifest.byPath.get(pathname);
+        if (exactMatch) {
+            return { route: exactMatch, params: {}, query };
+        }
+        // Try dynamic routes
+        for (const route of this.manifest.routes) {
+            if (!route.isDynamic)
+                continue;
+            const params = this.matchDynamicRoute(pathname, route);
+            if (params) {
+                return { route, params, query };
+            }
+        }
+        return null;
+    }
+    /**
+     * Generate URL from route name and params
+     */
+    generate(name, params = {}) {
+        if (!this.manifest) {
+            throw new Error('Routes not scanned. Call scanRoutes() first.');
+        }
+        const route = this.manifest.routes.find(r => r.name === name);
+        if (!route) {
+            throw new Error(`Route not found: ${name}`);
+        }
+        let path = route.path;
+        // Replace dynamic segments
+        for (const [key, value] of Object.entries(params)) {
+            path = path.replace(`:${key}`, String(value));
+            path = path.replace(`[${key}]`, String(value));
+            path = path.replace(`$${key}`, String(value));
+        }
+        return path;
+    }
+    /**
+     * Validate route configuration
+     */
+    async validate() {
+        const srcDir = path.join(this.config.root, this.config.srcDir || '');
+        try {
+            await fs.access(srcDir);
+        }
+        catch {
+            throw new Error(`Source directory not found: ${srcDir}`);
+        }
+    }
+    /**
+     * Recursively scan directory for route files
+     */
+    async scanDirectory(dir, extensions = ['.tsx', '.ts', '.jsx', '.js', '.vue']) {
+        const files = [];
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    // Skip node_modules and hidden directories
+                    if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+                        continue;
+                    }
+                    const subFiles = await this.scanDirectory(fullPath, extensions);
+                    files.push(...subFiles);
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name);
+                    if (extensions.includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Directory doesn't exist, return empty array
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+        return files;
+    }
+    /**
+     * Convert file path to route path
+     */
+    fileToRoutePath(filePath, baseDir) {
+        let routePath = path.relative(baseDir, filePath);
+        // Remove extension
+        routePath = routePath.replace(/\.(tsx?|jsx?|vue)$/, '');
+        // Handle index files
+        routePath = routePath.replace(/\/index$/, '');
+        routePath = routePath.replace(/^index$/, '');
+        // Convert to URL path
+        routePath = '/' + routePath.replace(/\\/g, '/');
+        // Normalize
+        routePath = routePath.replace(/\/+/g, '/');
+        if (routePath === '/')
+            return '/';
+        return routePath;
+    }
+    /**
+     * Extract dynamic parameters from route path
+     */
+    extractParams(routePath) {
+        const params = [];
+        // Next.js/Nuxt style: [param] or [...param]
+        const bracketMatches = routePath.matchAll(/\[\.\.\.?([^\]]+)\]/g);
+        for (const match of bracketMatches) {
+            params.push(match[1]);
+        }
+        // Remix style: $param
+        const dollarMatches = routePath.matchAll(/\$([a-zA-Z0-9_]+)/g);
+        for (const match of dollarMatches) {
+            params.push(match[1]);
+        }
+        // Express style: :param
+        const colonMatches = routePath.matchAll(/:([a-zA-Z0-9_]+)/g);
+        for (const match of colonMatches) {
+            params.push(match[1]);
+        }
+        return [...new Set(params)]; // Remove duplicates
+    }
+    /**
+     * Check if route path has dynamic segments
+     */
+    isDynamicPath(routePath) {
+        return /[\[\]:$]/.test(routePath);
+    }
+    /**
+     * Match dynamic route against pathname
+     */
+    matchDynamicRoute(pathname, route) {
+        const pattern = this.routeToRegex(route.path);
+        const match = pathname.match(pattern);
+        if (!match)
+            return null;
+        const params = {};
+        route.params.forEach((param, index) => {
+            params[param] = match[index + 1];
+        });
+        return params;
+    }
+    /**
+     * Convert route path to regex pattern
+     */
+    routeToRegex(routePath) {
+        let pattern = routePath;
+        // Next.js/Nuxt catch-all: [...slug] -> (.*)
+        pattern = pattern.replace(/\[\.\.\.([^\]]+)\]/g, '(.*)');
+        // Next.js/Nuxt dynamic: [slug] -> ([^/]+)
+        pattern = pattern.replace(/\[([^\]]+)\]/g, '([^/]+)');
+        // Remix dynamic: $slug -> ([^/]+)
+        pattern = pattern.replace(/\$([a-zA-Z0-9_]+)/g, '([^/]+)');
+        // Express dynamic: :slug -> ([^/]+)
+        pattern = pattern.replace(/:([a-zA-Z0-9_]+)/g, '([^/]+)');
+        return new RegExp(`^${pattern}$`);
+    }
+    /**
+     * Parse query string
+     */
+    parseQuery(search) {
+        if (!search)
+            return {};
+        const params = new URLSearchParams(search);
+        const query = {};
+        params.forEach((value, key) => {
+            query[key] = value;
+        });
+        return query;
+    }
+    /**
+     * Build route tree from flat list
+     */
+    buildRouteTree(routes) {
+        const routeMap = new Map();
+        const rootRoutes = [];
+        // First pass: create map
+        for (const route of routes) {
+            routeMap.set(route.filePath, route);
+        }
+        // Second pass: build tree
+        for (const route of routes) {
+            const parentPath = path.dirname(route.filePath);
+            const parent = routeMap.get(parentPath);
+            if (parent && parent !== route) {
+                parent.children.push(route);
+                route.parent = parent;
+            }
+            else {
+                rootRoutes.push(route);
+            }
+        }
+        return rootRoutes;
+    }
+    /**
+     * Create route manifest
+     */
+    createManifest(routes) {
+        const byPath = new Map();
+        const byFile = new Map();
+        const apiRoutes = [];
+        const pageRoutes = [];
+        for (const route of routes) {
+            byPath.set(route.path, route);
+            byFile.set(route.filePath, route);
+            if (route.type === 'api') {
+                apiRoutes.push(route);
+            }
+            else if (route.type === 'page') {
+                pageRoutes.push(route);
+            }
+        }
+        return {
+            routes,
+            byPath,
+            byFile,
+            apiRoutes,
+            pageRoutes
+        };
+    }
+    /**
+     * Log route scanning results
+     */
+    logRoutes(manifest) {
+        log.info(`Found ${manifest.routes.length} routes`);
+        log.info(`  - ${manifest.pageRoutes.length} page routes`);
+        log.info(`  - ${manifest.apiRoutes.length} API routes`);
+        if (manifest.routes.length > 0) {
+            log.info('Route paths:');
+            for (const route of manifest.pageRoutes.slice(0, 10)) {
+                log.info(`  ${route.path} -> ${path.relative(this.config.root, route.filePath)}`);
+            }
+            if (manifest.pageRoutes.length > 10) {
+                log.info(`  ... and ${manifest.pageRoutes.length - 10} more`);
+            }
+        }
+    }
+}

package/dist/meta-frameworks/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Meta-Framework Routers Export
+ */
+export * from './types.js';
+export * from './base-router.js';
+export * from './nextjs/router.js';
+export * from './nuxt/router.js';
+export * from './remix/router.js';

package/dist/meta-frameworks/index.js

@@ -0,0 +1,8 @@
+/**
+ * Meta-Framework Routers Export
+ */
+export * from './types.js';
+export * from './base-router.js';
+export * from './nextjs/router.js';
+export * from './nuxt/router.js';
+export * from './remix/router.js';

package/dist/meta-frameworks/nextjs/router.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Next.js Router
+ * Supports both Pages Router and App Router
+ */
+import { BaseRouter } from '../base-router.js';
+import { RouteManifest, RouterConfig } from '../types.js';
+export declare class NextJsRouter extends BaseRouter {
+    constructor(config: RouterConfig);
+    scanRoutes(): Promise<RouteManifest>;
+    /**
+     * Scan Pages Router (pages/ directory)
+     */
+    private scanPagesRouter;
+    /**
+     * Create route from Pages Router file
+     */
+    private createPagesRoute;
+    /**
+     * Scan App Router (app/ directory)
+     */
+    private scanAppRouter;
+    /**
+     * Create route from App Router file
+     */
+    private createAppRoute;
+    /**
+     * Generate unique route name
+     */
+    private generateRouteName;
+    /**
+     * Validate Next.js project structure
+     */
+    validate(): Promise<void>;
+    private checkDirectory;
+}