@bhooai/nexus-cli 2.0.2 → 2.0.4

package/templates/base/apps/admin/src/main.tsx.ejs

@@ -1,7 +1,7 @@
-import '@bhooai/nexus-admin/style.css';
-import { App as NexusAdmin } from '@bhooai/nexus-admin';
+import './index.css';
+import { App as NexusAdmin } from './App.js';
 import React from 'react';
 import { createRoot } from 'react-dom/client';
 
 const el = document.getElementById('root');
-if (el) createRoot(el).render(<NexusAdmin />);
+if (el) createRoot(el).render(<NexusAdmin />);

package/templates/base/apps/admin/src/vite-env.d.ts

@@ -0,0 +1,19 @@
+// Ambient declarations that keep `@bhooai/admin` self-contained: it does
+// not depend on the consumer having `vite/client` types installed. Vite /
+// esbuild inject `import.meta.env` and resolve asset imports at runtime; the
+// host project's build (vite build) handles actual bundling.
+interface ImportMetaEnv {
+  readonly VITE_SUPERVISOR_URL?: string;
+  readonly [key: string]: string | undefined;
+}
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}
+declare module '*.svg' {
+  const src: string;
+  export default src;
+}
+declare module '*.png' {
+  const src: string;
+  export default src;
+}

package/templates/base/apps/admin/tailwind.config.js

@@ -0,0 +1,9 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    './index.html',
+    './src/**/*.{ts,tsx}',
+  ],
+  theme: { extend: {} },
+  plugins: [],
+};

package/templates/base/apps/admin/vite.config.ts.ejs

@@ -8,15 +8,34 @@ export default defineConfig({
         target: 'http://localhost:<%= backendPort %>',
         changeOrigin: true,
       },
+      '/ai': {
+        target: 'http://localhost:<%= backendPort %>',
+        changeOrigin: true,
+      },
       '/api': {
         target: 'http://localhost:<%= backendPort %>',
         changeOrigin: true,
-        rewrite: (p: string) => p.replace(/^\/api/, ''),
+      },
+      '/auth': {
+        target: 'http://localhost:<%= backendPort %>',
+        changeOrigin: true,
+      },
+      '/csrf-token': {
+        target: 'http://localhost:<%= backendPort %>',
+        changeOrigin: true,
       },
       '/health': {
         target: 'http://localhost:<%= backendPort %>',
         changeOrigin: true,
       },
+      '/uploads': {
+        target: 'http://localhost:<%= backendPort %>',
+        changeOrigin: true,
+      },
+      '/ws': {
+        target: 'ws://localhost:<%= backendPort %>',
+        ws: true,
+      },
     },
   },
-});
+});

package/templates/base/apps/ai-server/main.py.ejs

@@ -1,9 +1,25 @@
-"""AI server (FastAPI) — provides /health and OpenAI-compatible /v1/chat/completions stub.
+"""AI server (FastAPI) — OpenAI-compatible proxy to Ollama by default.
 
-Extend with real provider integrations (Ollama, OpenAI, Anthropic, etc.).
+Routes:
+  GET  /health            — liveness probe
+  GET  /v1/models         — list Ollama models (OpenAI format)
+  POST /v1/chat/completions — chat completions (stream + non-stream) via Ollama
+
+Env:
+  OLLAMA_BASE_URL  Ollama server URL (default http://ollama:11434)
+  OLLAMA_MODEL    Default model if not specified in request (default llama3.2)
 """
-from fastapi import FastAPI
+import json
+import os
+from typing import Any
+
+import httpx
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, StreamingResponse
+
+OLLAMA_BASE_URL = os.getenv("OLLAMA_BASE_URL", "http://ollama:11434")
+DEFAULT_MODEL = os.getenv("OLLAMA_MODEL", "llama3.2")
 
 app = FastAPI(title="<%= name %> AI server")
 
@@ -17,14 +33,86 @@ app.add_middleware(
 
 @app.get("/health")
 async def health():
-    return {"ok": True, "service": "ai", "app": "<%= nameSlug %>"}
+    return {"ok": True, "service": "ai", "app": "<%= nameSlug %>", "provider": "ollama"}
 
 
 @app.get("/v1/models")
 async def models():
-    return {"data": [{"id": "default", "object": "model"}]}
+    async with httpx.AsyncClient(timeout=30) as client:
+        try:
+            resp = await client.get(f"{OLLAMA_BASE_URL}/api/tags")
+            resp.raise_for_status()
+            data = resp.json()
+        except Exception:
+            return {"data": [{"id": DEFAULT_MODEL, "object": "model"}]}
+    models_list = [
+        {"id": m["name"], "object": "model"}
+        for m in data.get("models", [])
+    ]
+    return {"data": models_list or [{"id": DEFAULT_MODEL, "object": "model"}]}
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(req: Request):
+    body: dict[str, Any] = await req.json()
+    model = body.get("model") or DEFAULT_MODEL
+    messages = body.get("messages", [])
+    stream = body.get("stream", False)
+
+    ollama_payload = {"model": model, "messages": messages, "stream": stream}
+
+    if not stream:
+        async with httpx.AsyncClient(timeout=120) as client:
+            resp = await client.post(
+                f"{OLLAMA_BASE_URL}/api/chat", json=ollama_payload
+            )
+            resp.raise_for_status()
+            data = resp.json()
+
+        return JSONResponse({
+            "id": "chatcmpl-ollama",
+            "object": "chat.completion",
+            "model": model,
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": data.get("message", {}).get("role", "assistant"),
+                        "content": data.get("message", {}).get("content", ""),
+                    },
+                    "finish_reason": data.get("done", True) and "stop" or None,
+                }
+            ],
+            "usage": {
+                "prompt_tokens": data.get("prompt_eval_count", 0),
+                "completion_tokens": data.get("eval_count", 0),
+                "total_tokens": data.get("prompt_eval_count", 0)
+                + data.get("eval_count", 0),
+            },
+        })
+
+    async def stream_generator():
+        async with httpx.AsyncClient(timeout=120) as client:
+            async with client.stream(
+                "POST", f"{OLLAMA_BASE_URL}/api/chat", json=ollama_payload
+            ) as resp:
+                resp.raise_for_status()
+                async for line in resp.aiter_lines():
+                    if not line:
+                        continue
+                    try:
+                        chunk = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    content = chunk.get("message", {}).get("content", "")
+                    if content:
+                        yield f"data: {json.dumps({'choices': [{'index': 0, 'delta': {'content': content}, 'finish_reason': None}]})}\n\n"
+                    if chunk.get("done"):
+                        yield "data: [DONE]\n\n"
+
+    return StreamingResponse(stream_generator(), media_type="text/event-stream")
 
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="127.0.0.1", port=<%= aiPort %>)
+    uvicorn.run(app, host="0.0.0.0", port=<%= aiPort %>)

package/templates/base/apps/backend/package.json.ejs

@@ -0,0 +1,27 @@
+{
+  "name": "@<%= nameSlug %>/backend",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/main.ts",
+    "start": "tsx src/main.ts"
+  },
+  "dependencies": {
+    "@bhooai/nexus-core": "^2.0.1",
+    "@bhooai/nexus-auth": "^2.0.1",
+    "@bhooai/nexus-data": "^2.0.1",
+    "@bhooai/nexus-cache": "^2.0.1",
+    "@bhooai/nexus-realtime": "^2.0.1",
+    "@bhooai/nexus-payments": "^2.0.1",
+    "@bhooai/nexus-email": "^2.0.1",
+    "@bhooai/nexus-ai-client": "^2.0.1",
+    "@bhooai/nexus-graphql": "^2.0.1",
+    "@bhooai/nexus-telemetry": "^2.0.1",
+    "tsx": "^4.19.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.2",
+    "@types/node": "^22.5.0"
+  }
+}

package/templates/base/apps/frontend/package.json.ejs

@@ -7,5 +7,12 @@
     "dev": "vite --port <%= frontendPort %>",
     "build": "vite build",
     "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "vite": "^5.4.10"
   }
 }

package/templates/base/apps/frontend/vite.config.ts.ejs

@@ -7,7 +7,6 @@ export default defineConfig({
       '/api': {
         target: 'http://localhost:<%= backendPort %>',
         changeOrigin: true,
-        rewrite: (p: string) => p.replace(/^\/api/, ''),
       },
       '/uploads': {
         target: 'http://localhost:<%= backendPort %>',

package/templates/base/docker-compose.yml.ejs

@@ -15,6 +15,9 @@ services:
       NODE_ENV: production
       NEXUS_DB_URI: ${NEXUS_DB_URI:-mongodb://mongo:27017/<%= nameSlug %>}
       NEXUS_REDIS_URL: ${NEXUS_REDIS_URL:-redis://redis:6379}
+      NEXUS_AI_URL: http://ai-server:<%= aiPort %>/v1
+      NEXUS_AI_PROVIDER: ollama
+      NEXUS_AI_MODEL: ${OLLAMA_MODEL:-llama3.2}
     volumes:
       - ./apps/backend/storage:/app/apps/backend/storage
     depends_on:
@@ -56,9 +59,11 @@ services:
       context: .
       dockerfile: Dockerfile
       target: ai-server
-    profiles: ["ai"]
     ports:
       - "<%= aiPort %>:<%= aiPort %>"
+    environment:
+      OLLAMA_BASE_URL: http://host.docker.internal:11434
+      OLLAMA_MODEL: ${OLLAMA_MODEL:-llama3.2}
     restart: unless-stopped
 
   mongo:

package/templates/base/nexus.config.ts.ejs

@@ -13,7 +13,7 @@ const config: Partial<NexusConfig> = {
 
   server: {
     port: <%= backendPort %>,
-    host: '127.0.0.1',
+    host: process.env.NEXUS_SERVER_HOST ?? '0.0.0.0',
     https: false,
     trustProxy: false,
     bodyLimit: 12 * 1024 * 1024,
@@ -79,10 +79,10 @@ const config: Partial<NexusConfig> = {
   webrtc: { rtcMinPort: 40000, rtcMaxPort: 40100, announceIp: '127.0.0.1' },
 
   ai: {
-    serverUrl: `http://localhost:${process.env.AI_PORT ?? <%= aiPort %>}`,
+    serverUrl: process.env.NEXUS_AI_URL ?? `http://localhost:${process.env.AI_PORT ?? <%= aiPort %>}/v1`,
     timeoutMs: 60_000,
-    defaultProvider: 'auto',
-    schemaModel: 'llama3:latest',
+    defaultProvider: process.env.NEXUS_AI_PROVIDER ?? 'ollama',
+    schemaModel: process.env.NEXUS_AI_MODEL ?? 'llama3.1:8b',
   },
 
   logging: { level: 'info', format: 'pretty', console: true, dir: 'logs', maxFileSize: 10 * 1024 * 1024, maxFiles: 7 },

package/templates/features/auth/apps/backend/src/models/User.ts

@@ -0,0 +1,21 @@
+import { model, Schema } from '@bhooai/nexus-data';
+
+/**
+ * Auth starter — User model.
+ *
+ * passwordHash is set by POST /auth/register (see routes/auth.ts).
+ * roles is an array of strings used by the RBAC middleware.
+ */
+const userSchema = new Schema({
+  email:        { type: String, required: true, unique: true, index: true },
+  name:         { type: String, default: '' },
+  passwordHash: { type: String },
+  roles:        { type: Array,  default: ['user'] },
+  createdAt:    { type: Date,   default: () => new Date() },
+  updatedAt:    { type: Date,   default: () => new Date() },
+});
+
+export const User = model('users', userSchema);
+
+/** A hydrated User document (property reads proxy to the underlying doc). */
+export type UserDoc = InstanceType<typeof User>;

package/templates/features/auth/apps/backend/src/routes/auth.ts

@@ -0,0 +1,95 @@
+import { defineRoutes } from '@bhooai/nexus-core';
+import type { RequestContext } from '@bhooai/nexus-core';
+import {
+  AuthService,
+  MemorySessionStore,
+  authToken,
+  hashPassword,
+  verifyPassword,
+} from '@bhooai/nexus-auth';
+import { User } from '../models/User.js';
+
+/**
+ * Auth starter — register / login / me.
+ *
+ * Tokens are JWT pairs (access + rotating refresh). The MemorySessionStore is
+ * per-process; swap in a Redis-backed store for horizontal scaling.
+ */
+const jwt = {
+  secret: process.env.NEXUS_AUTH_JWT_SECRET ?? 'dev-secret-change-me',
+  accessTtl: 60 * 15,
+  refreshTtl: 60 * 60 * 24 * 30,
+  algorithm: 'HS256' as const,
+  issuer: 'nexus-app',
+  audience: 'nexus-app-client',
+};
+
+const sessions = new MemorySessionStore();
+const auth = new AuthService(jwt, sessions);
+
+interface UserShape {
+  _id: unknown;
+  email: string;
+  name?: string;
+  roles?: string[];
+}
+
+function toUser(doc: unknown) {
+  const u = doc as UserShape;
+  return { id: String(u._id), email: u.email, name: u.name ?? '', roles: u.roles ?? ['user'] };
+}
+
+export default defineRoutes([
+  {
+    method: 'POST',
+    path: '/auth/register',
+    handler: async (ctx) => {
+      const body = (ctx.body ?? {}) as { email?: string; password?: string; name?: string };
+      if (!body.email?.trim() || !body.password || body.password.length < 6) {
+        return ctx.json({ error: 'email and password (min 6 chars) are required' }, 422);
+      }
+      const email = body.email.trim().toLowerCase();
+      const existing = await User.findOne({ email });
+      if (existing) return ctx.json({ error: 'email already registered' }, 409);
+
+      const passwordHash = await hashPassword(body.password);
+      const [user] = await User.create({
+        email,
+        name: body.name?.trim() ?? '',
+        passwordHash,
+        roles: ['user'],
+      });
+
+      const pair = await auth.login({ userId: String((user as UserShape)._id), roles: ['user'] });
+      ctx.json({ user: toUser(user), accessToken: pair.accessToken, refreshToken: pair.refreshToken }, 201);
+    },
+  },
+  {
+    method: 'POST',
+    path: '/auth/login',
+    handler: async (ctx) => {
+      const body = (ctx.body ?? {}) as { email?: string; password?: string };
+      const email = body.email?.trim().toLowerCase() ?? '';
+      const user = await User.findOne({ email });
+      const hash = (user as { passwordHash?: string } | null)?.passwordHash;
+      if (!user || !hash || !(await verifyPassword(body.password ?? '', hash))) {
+        return ctx.json({ error: 'invalid credentials' }, 401);
+      }
+      const userId = String((user as UserShape)._id);
+      const pair = await auth.login({ userId, roles: (user as UserShape).roles ?? ['user'] });
+      ctx.json({ user: toUser(user), accessToken: pair.accessToken, refreshToken: pair.refreshToken });
+    },
+  },
+  {
+    method: 'GET',
+    path: '/auth/me',
+    middleware: [authToken(auth)],
+    handler: async (ctx: RequestContext) => {
+      const sub = (ctx.state.user as { id?: string })?.id;
+      if (!sub) return ctx.json({ error: 'not authenticated' }, 401);
+      const user = await User.findById(sub);
+      if (!user) return ctx.json({ error: 'user not found' }, 404);
+      ctx.json({ user: toUser(user) });
+    },
+  },
+]);

package/templates/features/email/apps/backend/src/mail/mailables/WelcomeMail.ts

@@ -0,0 +1,25 @@
+import { Mailable } from '@bhooai/nexus-core';
+
+/**
+ * Email feature — Welcome Mailable. Template: mail/templates/welcome.ejs.
+ *
+ *   await WelcomeMail.to('someone@example.com').send();
+ *   await WelcomeMail.to('someone@example.com').queue();
+ *
+ * The dev driver logs to the console (see config.email.provider = 'log').
+ */
+export default class WelcomeMail extends Mailable {
+  subject = 'Welcome aboard';
+  template = 'welcome';
+
+  constructor(
+    private user: { name: string; email: string },
+    private appName = 'Nexus',
+  ) {
+    super();
+  }
+
+  data() {
+    return { name: this.user.name, email: this.user.email, app: this.appName };
+  }
+}

package/templates/features/email/apps/backend/src/mail/templates/welcome.ejs.ejs

@@ -0,0 +1,10 @@
+<!doctype html>
+<html>
+  <body style="font-family: system-ui, sans-serif; color: #222;">
+    <h1>Welcome aboard!</h1>
+    <p>Your account is ready. Customize this template and the
+    <code>WelcomeMail</code> mailable to fit your product.</p>
+    <p style="color: #666; font-size: 0.85rem;">Rendered by the BhooAI Nexus
+    mail system (dev driver logs to the console).</p>
+  </body>
+</html>

package/templates/features/graphql/apps/backend/src/graphql/post.graph.ts

@@ -0,0 +1,61 @@
+/**
+ * GraphQL feature — posts subgraph. Auto-discovered from graphql/*.graph.ts
+ * and composed into the federated gateway under /graphql.
+ */
+import { defineSubgraph } from '@bhooai/nexus-graphql';
+import { Post } from '../models/Post.js';
+
+export const typeDefs = /* GraphQL */ `
+  type Post @key(fields: "id") {
+    id: ID!
+    title: String!
+    slug: String!
+    body: String!
+    published: Boolean!
+    createdAt: String!
+  }
+
+  type Query {
+    posts(publishedOnly: Boolean): [Post!]!
+    post(id: ID!): Post
+  }
+
+  type Mutation {
+    publishPost(id: ID!): Post
+  }
+`;
+
+const toPost = (p: Record<string, any>) => ({
+  id: String(p._id),
+  title: p.title,
+  slug: p.slug,
+  body: p.body,
+  published: !!p.published,
+  createdAt: p.createdAt instanceof Date ? p.createdAt.toISOString() : String(p.createdAt),
+});
+
+export default defineSubgraph({
+  name: 'posts',
+  typeDefs,
+  resolvers: {
+    Query: {
+      posts: async (_parent, args) => {
+        const filter = args.publishedOnly ? { published: true } : {};
+        return (await Post.find(filter, { sort: { createdAt: -1 } })).map(toPost);
+      },
+      post: async (_parent, args) => {
+        const post = await Post.findById(args.id);
+        return post ? toPost(post) : null;
+      },
+    },
+    Mutation: {
+      publishPost: async (_parent, args) => {
+        const post = await Post.findOneAndUpdate(
+          { _id: args.id },
+          { $set: { published: true, updatedAt: new Date() } },
+        );
+        return post ? toPost(post) : null;
+      },
+    },
+  },
+});

package/templates/features/graphql/apps/backend/src/models/Post.ts

@@ -0,0 +1,15 @@
+import { model, Schema } from '@bhooai/nexus-data';
+
+/**
+ * GraphQL feature — Post model backing the posts subgraph.
+ */
+const postSchema = new Schema({
+  title:     { type: String, required: true },
+  slug:      { type: String, required: true, unique: true, index: true },
+  body:      { type: String, required: true },
+  published: { type: Boolean, default: false },
+  createdAt: { type: Date, default: () => new Date(), index: true },
+  updatedAt: { type: Date, default: () => new Date() },
+});
+
+export const Post = model('posts', postSchema);

package/templates/features/payments/apps/backend/src/routes/payments.ts

@@ -0,0 +1,45 @@
+import { defineRoutes } from '@bhooai/nexus-core';
+
+/**
+ * Payments feature — checkout + webhook routes.
+ *
+ * This is a wiring skeleton: provider SDK calls (Razorpay / PayPal) are
+ * commented where your keys go. Config lives in nexus.config.ts under
+ * `payments` and provider secrets come from .env:
+ *   NEXUS_PAYMENTS_RAZORPAY_KEY_ID / KEY_SECRET
+ *   NEXUS_PAYMENTS_PAYPAL_CLIENT_ID / CLIENT_SECRET
+ */
+export default defineRoutes([
+  {
+    method: 'POST',
+    path: '/payments/order',
+    handler: async (ctx) => {
+      const body = (ctx.body ?? {}) as { amount?: number; currency?: string; metadata?: Record<string, unknown> };
+      const amount = Number(body.amount);
+      if (!Number.isFinite(amount) || amount <= 0) {
+        return ctx.json({ error: 'amount is required and must be > 0' }, 422);
+      }
+      const orderId = `ord_${Date.now().toString(36)}`;
+      ctx.json({
+        orderId,
+        amount,
+        currency: body.currency ?? 'INR',
+        status: 'created',
+        // providerIntent: await razorpay.orders.create({ amount, currency }),
+        metadata: body.metadata ?? {},
+      }, 201);
+    },
+  },
+  {
+    method: 'POST',
+    path: '/payments/webhook/:provider',
+    handler: async (ctx) => {
+      const provider = ctx.params.provider;
+      const raw = ctx.body;
+      // Verify the signature using the provider's webhook secret from .env,
+      // then reconcile the order status.
+      console.log(`[payments] webhook from ${provider}:`, raw);
+      ctx.json({ ok: true });
+    },
+  },
+]);

package/templates/features/queue/apps/backend/src/events/JobQueued.ts

@@ -0,0 +1,14 @@
+import { DomainEvent } from '@bhooai/nexus-core';
+
+/**
+ * Queue feature — event emitted when an ExampleJob is dispatched.
+ * Demo of the events + listeners convention.
+ */
+export default class JobQueued extends DomainEvent {
+  constructor(
+    public readonly message: string,
+    public readonly at: number = Date.now(),
+  ) {
+    super();
+  }
+}

package/templates/features/queue/apps/backend/src/jobs/ExampleJob.ts

@@ -0,0 +1,18 @@
+import { Job } from '@bhooai/nexus-core';
+
+/**
+ * Queue feature — example job.
+ *
+ *   await ExampleJob.dispatch('hello');
+ *
+ * Run a worker with:  nexus queue:work
+ */
+export default class ExampleJob extends Job<[message: string]> {
+  queue = 'default';
+  retries = 3;
+  backoff = 'exponential' as const;
+
+  async handle(message: string): Promise<void> {
+    console.log(`[queue] ExampleJob handled: ${message}`);
+  }
+}

package/templates/features/queue/apps/backend/src/listeners/OnJobQueued.ts

@@ -0,0 +1,12 @@
+import { Listener } from '@bhooai/nexus-core';
+import type JobQueued from '../events/JobQueued.js';
+
+/**
+ * Queue feature — auto-wired listener (On<EventName>.ts convention).
+ * Fires when the ExampleJob is enqueued.
+ */
+export default class OnJobQueued extends Listener<JobQueued> {
+  async handle(event: JobQueued): Promise<void> {
+    console.log(`[events] job queued: ${event.message}`);
+  }
+}

package/templates/features/realtime/apps/backend/src/models/Message.ts

@@ -0,0 +1,14 @@
+import { model, Schema } from '@bhooai/nexus-data';
+
+/**
+ * Realtime feature — chat message model persisted by ws/chat.room.ts.
+ */
+const messageSchema = new Schema({
+  roomId:    { type: String, required: true, index: true },
+  userId:    { type: String, required: true },
+  username:  { type: String, required: true },
+  text:      { type: String, required: true },
+  createdAt: { type: Date, default: () => new Date(), index: true },
+});
+
+export const Message = model('messages', messageSchema);