@bhooai/nexus-cli 0.1.0

package/templates/Dockerfile

@@ -0,0 +1,60 @@
+# BhooAI Nexus image - backend + built frontend + built admin in one container.
+#
+# Build:
+#   docker build -t node-1 .
+# Run (pass project secrets; real env vars always win over .env):
+#   docker run --rm -p 4000:4000 -p 3000:3000 -p 3001:3001 --env-file .env node-1
+#   # or override the server port / cluster node agent port:
+#   docker run --rm -p 4000:4000 -p 3000:3000 -p 3001:3001 -e NEXUS_SERVER_PORT=4000 -e NEXUS_NODE_PORT=7575 node-1
+#
+# Access:
+#   frontend  http://localhost:3000   (SPA; /health /graphql /auth /ai /ws proxied to the backend)
+#   admin     http://localhost:3001   (SPA; /admin /auth proxied to the backend)
+#   backend   http://localhost:4000   (API + /health)
+#   node      http://localhost:7575   (cluster node agent — link it from a root: `nexus cluster link http://<host>:7575`)
+#
+# The Python AI server, MongoDB, and Redis remain separate services and must
+# already be reachable (see nexus.config.*).
+
+ARG NODE_VERSION=24
+
+FROM node:${NODE_VERSION}-alpine AS base
+
+WORKDIR /app
+
+# npm workspaces: install deps for packages/*, apps/backend, admin, apps/frontend.
+# The dev deps (vite, typescript, tsx) are needed both to build the SPAs and at runtime.
+COPY package.json package-lock.json* ./
+COPY packages packages
+COPY apps apps
+COPY apps/admin apps/admin
+RUN npm install --no-audit --no-fund
+
+# Build the frontend + admin SPA bundles (static dist/ folders).
+RUN npm --prefix apps/frontend run build \
+ && npm --prefix apps/admin run build
+
+# Full source tree (config, bin, uploads dir, tsconfig).
+COPY . .
+
+# The uploads dir is written at runtime (uploads / certs).
+RUN mkdir -p uploads && chown -R node:node /app
+
+# Default ports are informational; the real values come from nexus.config.* /
+# NEXUS_* env overrides at runtime.
+EXPOSE 3000 3001 4000 7575
+
+ENV NODE_ENV=production
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+  CMD wget -qO- http://127.0.0.1:${NEXUS_SERVER_PORT:-4000}/health >/dev/null || exit 1
+
+USER node
+
+# Runs the stack: cluster node agent (:7575) + backend role service via
+# `nexus node serve --role=backend --port=7575`, plus frontend (:3000) and
+# admin (:3001) previews.
+COPY --chown=node:node bin/serve-all.mjs bin/serve-all.mjs
+COPY --chown=node:node package.json package.json
+
+CMD ["node", "bin/serve-all.mjs"]

package/templates/README.md

@@ -0,0 +1,69 @@
+# My Nexus App
+
+Scaffolded by `nexus init` — a [BhooAI Nexus](https://github.com/bhooai/nexus) full-stack app
+with four runnable terminals: backend, frontend, Python AI server, and admin.
+
+## Quick start
+
+```bash
+npm install
+npm run doctor     # verify node, python, mongo, redis
+npm run dev        # start all four terminals under the supervisor
+```
+
+`nexus init` installs these dependencies automatically. Run `npm install` manually only when this
+directory was copied without running `nexus init`, or after changing dependency versions.
+
+Then visit:
+
+- Backend: http://localhost:4000/health
+- Frontend: http://localhost:3000
+- Admin: http://localhost:3001
+- AI server: http://localhost:8000
+
+## What you got
+
+- `apps/backend/` — Node backend on the Nexus framework (custom HTTP server, CSRF/CORS,
+  GraphQL, websockets, ODM, OAuth, payments, and multipart uploads under `/uploads`.
+  Uploaded files are stored in the project-local `uploads/` directory. See `src/main.ts`.
+- `apps/frontend/` — React + Vite + Tailwind (placeholder; add components in `src/`).
+- `apps/ai-server/` — Python FastAPI (OpenAI + Ollama). `pip install -r requirements.txt`.
+- `apps/admin/` — React + Vite admin console (config, processes, plugins, users, monitoring).
+
+## Config
+
+Edit `nexus.config.ts` for app settings. Secrets go directly in `.env` (no `.env.example`).
+Admin overrides are written to `nexus.runtime.json` (gitignored).
+
+## Uploads
+
+The generated backend accepts a `multipart/form-data` `POST /uploads` request and returns generated
+file URLs. The default limit is 10 MiB per file and 20 files per request. The request must include the
+CSRF token returned by `GET /csrf-token`:
+
+```js
+const csrf = await fetch('/csrf-token', { credentials: 'include' }).then((r) => r.json());
+const form = new FormData();
+form.append('file', input.files[0]);
+const response = await fetch('/uploads', {
+  method: 'POST',
+  body: form,
+  credentials: 'include',
+  headers: { 'x-csrf-token': csrf.token },
+});
+```
+
+Configure `uploads.dir`, `uploads.path`, `uploads.maxFileSize`, `uploads.maxFiles`, and
+`uploads.allowedTypes` in `nexus.config.ts`. Uploaded files are ignored by Git.
+
+> Generated projects depend on the published `bhooai-nexus` package. Publish the framework package
+> from the `bhooai-nexus/` workspace root with `npm publish` before installing it from the public registry.
+
+## Scripts
+
+| command | what it does |
+| --- | --- |
+| `npm run dev` | start backend + frontend + AI + admin under the supervisor |
+| `npm run doctor` | check node/python versions and mongo/redis reachability |
+| `npm run build` | build all TypeScript workspaces |
+| `npm test` | run the test suites |

package/templates/apps/admin/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>BhooAI Nexus Admin</title>
+  </head>
+  <body class="bg-mesh text-slate-100">
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/apps/admin/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "my-nexus-admin",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite --port 3001",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.47",
+    "tailwindcss": "^3.4.13",
+    "typescript": "^5.6.0",
+    "vite": "^5.4.0"
+  }
+}

package/templates/apps/admin/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};

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

@@ -0,0 +1,10 @@
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { App } from '@bhooai/admin';
+import '@bhooai/admin/style.css';
+
+createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);

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

@@ -0,0 +1,18 @@
+// Ambient declarations for the admin host app. Self-contained: does not depend
+// on `vite/client` types being resolvable from the host workspace, so `@bhooai/admin`
+// imports (import.meta.env, *.svg) type-check consistently in every project.
+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/apps/admin/tailwind.config.js

@@ -0,0 +1,9 @@
+export default {
+  content: [
+    './index.html',
+    './src/**/*.{ts,tsx}',
+    '../../bhooai-nexus/packages/nexus-admin/src/**/*.{ts,tsx}',
+  ],
+  theme: { extend: {} },
+  plugins: [],
+};

package/templates/apps/admin/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "allowImportingTsExtensions": true
+  },
+  "include": ["src"]
+}

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

@@ -0,0 +1,64 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+// Read the merged host/port values from the project's single nexus config file
+// (ts/js/mjs/cjs, discovery order matches the backend loader) plus NEXUS_*
+// env overrides, so this Vite dev server and its proxy target stay in one
+// source of truth: nexus.config.js.
+async function loadConfig() {
+  const exts = ['ts', 'js', 'mjs', 'cjs'];
+  let user: Record<string, any> = {};
+  for (const ext of exts) {
+    const file = join(PROJECT_ROOT, `nexus.config.${ext}`);
+    if (existsSync(file)) {
+      const mod = (await import(pathToFileURL(file).href + `?v=${Date.now()}`)) as Record<string, any>;
+      user = mod.default ?? mod.config ?? {};
+      break;
+    }
+  }
+  const num = (v: string | undefined, fallback: number) => (v !== undefined && Number.isFinite(Number(v)) ? Number(v) : fallback);
+  const str = (v: string | undefined, fallback: string) => (v !== undefined && v !== '' ? v : fallback);
+
+  return {
+    server: {
+      host: str(process.env.NEXUS_SERVER_HOST, user.server?.host ?? '0.0.0.0'),
+      port: num(process.env.NEXUS_SERVER_PORT, user.server?.port ?? 4000),
+    },
+    admin: {
+      host: str(process.env.NEXUS_ADMIN_HOST, user.admin?.host ?? 'localhost'),
+      port: num(process.env.NEXUS_ADMIN_PORT, user.admin?.port ?? 3001),
+      enabled: user.admin?.enabled ?? true,
+    },
+    frontend: {
+      host: str(process.env.NEXUS_FRONTEND_HOST, user.frontend?.host ?? 'localhost'),
+      port: num(process.env.NEXUS_FRONTEND_PORT, user.frontend?.port ?? 3000),
+      enabled: user.frontend?.enabled ?? true,
+    },
+  };
+}
+
+export default defineConfig(async () => {
+  const cfg = await loadConfig();
+  const backendHost = cfg.server.host === '0.0.0.0' || cfg.server.host === '::' ? '127.0.0.1' : cfg.server.host;
+  const target = `http://${backendHost}:${cfg.server.port}`;
+
+  return {
+    plugins: [react()],
+    server: {
+      port: cfg.admin.port,
+      host: cfg.admin.host,
+      proxy: {
+        '/admin': { target, changeOrigin: true },
+        '/auth': { target, changeOrigin: true },
+        '/payments': { target, changeOrigin: true },
+        '/csrf-token': { target, changeOrigin: true },
+        '/ai': { target, changeOrigin: true },
+      },
+    },
+  };
+});

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

@@ -0,0 +1,43 @@
+"""BhooAI Nexus AI server (FastAPI).
+
+OpenAI-compatible gateway fronting OpenAI and Ollama. The Node backend proxies
+requests here (and re-emits SSE); the browser never calls this server directly.
+
+Run:  uvicorn main:app --reload --port 8000  (from apps/ai-server)
+"""
+from __future__ import annotations
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from settings import settings
+from providers import available_providers
+from routers import chat, embeddings, models, preflight, lint
+
+app = FastAPI(title="BhooAI Nexus AI", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "providers": available_providers()}
+
+
+app.include_router(chat.router)
+app.include_router(embeddings.router)
+app.include_router(models.router)
+app.include_router(preflight.router)
+app.include_router(lint.router)
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run("main:app", host="0.0.0.0", port=settings.server_port, reload=False)

package/templates/apps/ai-server/providers/__init__.py

@@ -0,0 +1,3 @@
+from .base import Provider, OpenAIProvider, OllamaProvider, get_provider, available_providers
+
+__all__ = ["Provider", "OpenAIProvider", "OllamaProvider", "get_provider", "available_providers"]

package/templates/apps/ai-server/providers/base.py

@@ -0,0 +1,111 @@
+"""Provider abstraction. Both OpenAI and Ollama expose OpenAI-compatible
+endpoints, so a single OpenAICompatibleProvider parameterised by base URL +
+auth handles both. Streaming uses SSE (upstream → parsed → re-emitted with the
+provider field injected)."""
+from __future__ import annotations
+
+import json
+from typing import Any, AsyncIterator
+
+import httpx
+
+from settings import Settings, settings, resolve_provider
+
+
+class Provider:
+    name = "base"
+
+    def __init__(self, base_url: str, api_key: str, timeout: float, transport: Any | None = None):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self.transport = transport
+
+    def _headers(self) -> dict[str, str]:
+        h = {"Content-Type": "application/json", "Accept": "application/json"}
+        if self.api_key:
+            h["Authorization"] = f"Bearer {self.api_key}"
+        return h
+
+    def _clean(self, body: dict[str, Any]) -> dict[str, Any]:
+        # Strip our routing field before forwarding upstream.
+        return {k: v for k, v in body.items() if k != "provider"}
+
+    async def chat(self, body: dict[str, Any]) -> dict[str, Any]:
+        async with httpx.AsyncClient(timeout=self.timeout, transport=self.transport) as client:
+            resp = await client.post(f"{self.base_url}/chat/completions", json=self._clean(body), headers=self._headers())
+            resp.raise_for_status()
+            data = resp.json()
+            data["provider"] = self.name
+            return data
+
+    async def chat_stream(self, body: dict[str, Any]) -> AsyncIterator[str]:
+        """Yield SSE-formatted `data: ...` lines (already ending in \\n\\n)."""
+        payload = self._clean(body)
+        payload["stream"] = True
+        async with httpx.AsyncClient(timeout=self.timeout, transport=self.transport) as client:
+            async with client.stream("POST", f"{self.base_url}/chat/completions", json=payload, headers=self._headers()) as resp:
+                resp.raise_for_status()
+                async for line in resp.aiter_lines():
+                    if not line or not line.startswith("data:"):
+                        continue
+                    raw = line[5:].strip()
+                    if raw == "[DONE]":
+                        yield "data: [DONE]\n\n"
+                        return
+                    try:
+                        chunk = json.loads(raw)
+                    except json.JSONDecodeError:
+                        continue
+                    chunk["provider"] = self.name
+                    yield f"data: {json.dumps(chunk)}\n\n"
+        # If the upstream didn't send [DONE], close the stream cleanly.
+        yield "data: [DONE]\n\n"
+
+    async def embed(self, body: dict[str, Any]) -> dict[str, Any]:
+        async with httpx.AsyncClient(timeout=self.timeout, transport=self.transport) as client:
+            resp = await client.post(f"{self.base_url}/embeddings", json=self._clean(body), headers=self._headers())
+            resp.raise_for_status()
+            data = resp.json()
+            data["provider"] = self.name
+            return data
+
+    async def list_models(self) -> dict[str, Any]:
+        async with httpx.AsyncClient(timeout=self.timeout, transport=self.transport) as client:
+            resp = await client.get(f"{self.base_url}/models", headers=self._headers())
+            resp.raise_for_status()
+            data = resp.json()
+            data["provider"] = self.name
+            return data
+
+
+class OpenAIProvider(Provider):
+    name = "openai"
+
+    @classmethod
+    def from_settings(cls, s: Settings) -> "OpenAIProvider":
+        return cls(s.openai_base_url, s.openai_api_key, s.request_timeout_s)
+
+
+class OllamaProvider(Provider):
+    name = "ollama"
+
+    @classmethod
+    def from_settings(cls, s: Settings) -> "OllamaProvider":
+        return cls(s.ollama_base_url, s.ollama_api_key, s.request_timeout_s)
+
+
+def get_provider(requested: str | None) -> Provider:
+    """Resolve and instantiate the provider for a request."""
+    name = resolve_provider(requested)
+    if name == "openai":
+        return OpenAIProvider.from_settings(settings)
+    return OllamaProvider.from_settings(settings)
+
+
+def available_providers() -> list[str]:
+    avail = []
+    if settings.openai_api_key:
+        avail.append("openai")
+    avail.append("ollama")
+    return avail

package/templates/apps/ai-server/requirements.txt

@@ -0,0 +1,3 @@
+fastapi>=0.115.0
+uvicorn[standard]>=0.30.0
+httpx>=0.27.0

package/templates/apps/ai-server/routers/__init__.py

@@ -0,0 +1,3 @@
+from . import chat, embeddings, models
+
+__all__ = ["chat", "embeddings", "models"]

package/templates/apps/ai-server/routers/chat.py

@@ -0,0 +1,47 @@
+"""Chat completions router — OpenAI-compatible, supports SSE streaming."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+from providers import get_provider
+
+router = APIRouter()
+
+
+class Message(BaseModel):
+    role: str
+    content: str
+    name: str | None = None
+
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: list[Message]
+    stream: bool = False
+    temperature: float | None = None
+    max_tokens: int | None = None
+    provider: str | None = None
+
+
+@router.post("/chat/completions")
+async def chat_completions(req: ChatCompletionRequest):
+    body = req.model_dump(exclude_none=True)
+    try:
+        provider = get_provider(body.get("provider"))
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    if body.get("stream"):
+        async def gen():
+            async for chunk in provider.chat_stream(body):
+                yield chunk
+        return StreamingResponse(gen(), media_type="text/event-stream")
+
+    try:
+        return await provider.chat(body)
+    except HTTPException:
+        raise
+    except Exception as e:  # upstream error
+        raise HTTPException(status_code=502, detail=f"upstream error: {e}")

package/templates/apps/ai-server/routers/embeddings.py

@@ -0,0 +1,30 @@
+"""Embeddings router — OpenAI-compatible."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from providers import get_provider
+
+router = APIRouter()
+
+
+class EmbeddingRequest(BaseModel):
+    model: str
+    input: str | list[str]
+    provider: str | None = None
+
+
+@router.post("/embeddings")
+async def create_embeddings(req: EmbeddingRequest):
+    body = req.model_dump(exclude_none=True)
+    try:
+        provider = get_provider(body.get("provider"))
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    try:
+        return await provider.embed(body)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=502, detail=f"upstream error: {e}")