@roboticela/devkit 4.0.0 → 4.1.0

package/dist/lib/bundled-registry.d.ts

@@ -0,0 +1,18 @@
+import type { ComponentEntry } from "./component-entry.js";
+/** Directory containing `dist/` (the published CLI package root). */
+export declare function getCliPackageRoot(fromImportMetaUrl?: string): string;
+/**
+ * On-disk component payloads: either shipped inside the npm package (`cli/registry/components`)
+ * or the monorepo sibling (`DevKit/registry/components`).
+ */
+export declare function getBundledComponentsDir(fromImportMetaUrl?: string): string | null;
+export declare function listBundledComponents(template: string | undefined, fromImportMetaUrl?: string): ComponentEntry[] | null;
+export declare function getBundledComponentMeta(name: string, fromImportMetaUrl?: string): Record<string, unknown> | null;
+export declare function resolveBundledVersion(name: string, requested: string, fromImportMetaUrl?: string): string | null;
+export declare function getBundledManifest(name: string, template: string, version: string, variant: string | undefined, fromImportMetaUrl?: string): {
+    name: string;
+    template: string;
+    version: string;
+    variant: string | null;
+    manifest: Record<string, unknown>;
+} | null;

package/dist/lib/bundled-registry.js

@@ -0,0 +1,82 @@
+import { readFileSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+/** Directory containing `dist/` (the published CLI package root). */
+export function getCliPackageRoot(fromImportMetaUrl = import.meta.url) {
+    return join(dirname(fileURLToPath(fromImportMetaUrl)), "..", "..");
+}
+/**
+ * On-disk component payloads: either shipped inside the npm package (`cli/registry/components`)
+ * or the monorepo sibling (`DevKit/registry/components`).
+ */
+export function getBundledComponentsDir(fromImportMetaUrl = import.meta.url) {
+    const pkgRoot = getCliPackageRoot(fromImportMetaUrl);
+    const nested = join(pkgRoot, "registry", "components");
+    const sibling = join(pkgRoot, "..", "registry", "components");
+    if (existsSync(join(nested, "registry.json")))
+        return nested;
+    if (existsSync(join(sibling, "registry.json")))
+        return sibling;
+    return null;
+}
+export function listBundledComponents(template, fromImportMetaUrl = import.meta.url) {
+    const root = getBundledComponentsDir(fromImportMetaUrl);
+    if (!root)
+        return null;
+    const index = JSON.parse(readFileSync(join(root, "registry.json"), "utf-8"));
+    const out = [];
+    for (const c of index.components) {
+        if (template && !c.templates.includes(template))
+            continue;
+        const metaPath = join(root, c.name, "component.json");
+        if (!existsSync(metaPath))
+            continue;
+        const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+        out.push({
+            name: meta.name,
+            displayName: meta.displayName,
+            description: meta.description,
+            category: meta.category,
+            templates: meta.templates,
+            platforms: meta.platforms,
+            hasVariants: meta.hasVariants,
+            variants: meta.variants,
+            latestVersion: meta.versions.latest,
+            tags: meta.tags,
+        });
+    }
+    return out;
+}
+export function getBundledComponentMeta(name, fromImportMetaUrl = import.meta.url) {
+    const root = getBundledComponentsDir(fromImportMetaUrl);
+    if (!root)
+        return null;
+    const path = join(root, name, "component.json");
+    if (!existsSync(path))
+        return null;
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+export function resolveBundledVersion(name, requested, fromImportMetaUrl = import.meta.url) {
+    const meta = getBundledComponentMeta(name, fromImportMetaUrl);
+    if (!meta)
+        return null;
+    const versions = meta["versions"];
+    if (requested === "latest")
+        return versions.latest;
+    const found = versions.history.find((h) => h.version === requested);
+    return found ? found.version : null;
+}
+export function getBundledManifest(name, template, version, variant, fromImportMetaUrl = import.meta.url) {
+    const root = getBundledComponentsDir(fromImportMetaUrl);
+    if (!root)
+        return null;
+    const resolved = resolveBundledVersion(name, version, fromImportMetaUrl);
+    if (!resolved)
+        return null;
+    const base = join(root, name, template, `v${resolved.split(".")[0]}`);
+    const manifestPath = variant ? join(base, "variants", variant, "manifest.json") : join(base, "manifest.json");
+    if (!existsSync(manifestPath))
+        return null;
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    return { name, template, version: resolved, variant: variant ?? null, manifest };
+}

package/dist/lib/component-entry.d.ts

@@ -0,0 +1,16 @@
+export interface ComponentEntry {
+    name: string;
+    displayName: string;
+    description: string;
+    category: string;
+    templates: string[];
+    platforms: string[];
+    hasVariants: boolean;
+    variants?: {
+        id: string;
+        label: string;
+        description: string;
+    }[];
+    latestVersion: string;
+    tags: string[];
+}

package/dist/lib/component-entry.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/config.d.ts

@@ -41,6 +41,8 @@ export interface DevKitLock {
         installedAt: string;
     }>;
 }
+/** Stable URL for editors (works before/without the public registry host). */
+export declare const DEVKIT_CONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/Roboticela/DevKit/main/cli/schemas/devkit-config.json";
 export declare function configExists(cwd?: string): boolean;
 export declare function readConfig(cwd?: string): DevKitConfig;
 export declare function writeConfig(config: DevKitConfig, cwd?: string): void;

package/dist/lib/config.js

@@ -2,6 +2,8 @@ import { readFileSync, writeFileSync, existsSync } from "fs";
 import { join } from "path";
 const CONFIG_FILE = "devkit.config.json";
 const LOCK_FILE = "devkit.lock.json";
+/** Stable URL for editors (works before/without the public registry host). */
+export const DEVKIT_CONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/Roboticela/DevKit/main/cli/schemas/devkit-config.json";
 export function configExists(cwd = process.cwd()) {
     return existsSync(join(cwd, CONFIG_FILE));
 }
@@ -32,7 +34,7 @@ export function isComponentInstalled(name, cwd = process.cwd()) {
 }
 export function defaultConfig(template, siteName, siteUrl) {
     return {
-        $schema: "https://registry.devkit.roboticela.com/schemas/devkit-config.json",
+        $schema: DEVKIT_CONFIG_SCHEMA_URL,
         devkit: "1.0",
         template,
         site: { name: siteName, url: siteUrl },

package/dist/lib/installer.js

@@ -4,6 +4,7 @@ import { execSync } from "child_process";
 import { createHash } from "crypto";
 import { x as extractTar } from "tar";
 import { pipeline } from "stream/promises";
+import { getBundledComponentsDir } from "./bundled-registry.js";
 import { getManifest } from "./registry.js";
 import { readLock, writeLock } from "./config.js";
 import { log } from "./logger.js";
@@ -127,14 +128,15 @@ export function removeComponent(name, cwd = process.cwd()) {
 }
 async function downloadComponentFiles(name, template, version, variant, tmpDir) {
     mkdirSync(tmpDir, { recursive: true });
-    // For local development with the registry server, we serve files directly.
-    // In production this would stream a tarball. For now we copy from local registry.
-    const registryDir = join(dirname(new URL(import.meta.url).pathname), "../../../registry/components");
+    // Prefer on-disk payloads (bundled in the npm package or monorepo sibling) before HTTP tarball.
+    const registryDir = getBundledComponentsDir();
     const major = `v${version.split(".")[0]}`;
-    const compDir = variant
-        ? join(registryDir, name, template, major, "variants", variant)
-        : join(registryDir, name, template, major);
-    if (existsSync(compDir)) {
+    const compDir = registryDir
+        ? variant
+            ? join(registryDir, name, template, major, "variants", variant)
+            : join(registryDir, name, template, major)
+        : "";
+    if (compDir && existsSync(compDir)) {
         cpSync(compDir, tmpDir, { recursive: true });
     }
     else {

package/dist/lib/registry.d.ts

@@ -1,19 +1,5 @@
-export interface ComponentEntry {
-    name: string;
-    displayName: string;
-    description: string;
-    category: string;
-    templates: string[];
-    platforms: string[];
-    hasVariants: boolean;
-    variants?: {
-        id: string;
-        label: string;
-        description: string;
-    }[];
-    latestVersion: string;
-    tags: string[];
-}
+import type { ComponentEntry } from "./component-entry.js";
+export type { ComponentEntry };
 export declare function listComponents(template?: string): Promise<ComponentEntry[]>;
 export declare function getComponentInfo(name: string): Promise<Record<string, unknown>>;
 export declare function getManifest(name: string, template: string, version?: string, variant?: string): Promise<{

package/dist/lib/registry.js

@@ -1,3 +1,4 @@
+import { getBundledComponentMeta, getBundledManifest, listBundledComponents, } from "./bundled-registry.js";
 const REGISTRY_URL = process.env.DEVKIT_REGISTRY ?? "https://registry.devkit.roboticela.com";
 async function get(path) {
     const res = await fetch(`${REGISTRY_URL}${path}`);
@@ -6,14 +7,23 @@ async function get(path) {
     return res.json();
 }
 export async function listComponents(template) {
+    const local = listBundledComponents(template);
+    if (local)
+        return local;
     const qs = template ? `?template=${template}` : "";
     const data = await get(`/api/v1/components${qs}`);
     return data.components;
 }
 export async function getComponentInfo(name) {
+    const local = getBundledComponentMeta(name);
+    if (local)
+        return local;
     return get(`/api/v1/components/${name}`);
 }
 export async function getManifest(name, template, version = "latest", variant) {
+    const local = getBundledManifest(name, template, version, variant);
+    if (local)
+        return local;
     const qs = new URLSearchParams({ template, version });
     if (variant)
         qs.set("variant", variant);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@roboticela/devkit",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "Roboticela DevKit CLI — scaffold, extend, and theme full-stack projects with one command",
   "type": "module",
   "bin": {
@@ -53,6 +53,8 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "registry",
+    "schemas"
   ]
 }

package/registry/components/auth/component.json

@@ -0,0 +1,29 @@
+{
+  "name": "auth",
+  "displayName": "Authentication",
+  "description": "Complete authentication system: email/password login, registration, email verification, forgot/reset password, and Google OAuth.",
+  "category": "authentication",
+  "icon": "lock",
+  "author": "Roboticela",
+  "license": "MIT",
+  "tags": ["auth", "login", "register", "oauth", "jwt", "email"],
+  "templates": ["nextjs-compact", "vite-express-tauri"],
+  "platforms": ["web", "desktop"],
+  "hasVariants": false,
+  "versions": {
+    "latest": "1.0.0",
+    "stable": "1.0.0",
+    "history": [
+      { "version": "1.0.0", "releaseDate": "2026-04-05", "breaking": false }
+    ]
+  },
+  "requiredConfig": ["site.name", "site.url"],
+  "optionalConfig": [
+    "auth.google.clientId",
+    "auth.google.clientSecret",
+    "auth.smtp.host",
+    "auth.smtp.port",
+    "auth.smtp.user",
+    "auth.smtp.password"
+  ]
+}

package/registry/components/auth/nextjs-compact/v1/files/app/api/auth/[...route]/route.ts

@@ -0,0 +1,140 @@
+import { NextRequest, NextResponse } from "next/server";
+import { signToken, verifyToken } from "@/lib/auth/authService";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function json(data: unknown, status = 200) {
+  return NextResponse.json(data, { status });
+}
+
+function err(message: string, status = 400) {
+  return json({ message }, status);
+}
+
+// ── Route dispatcher ─────────────────────────────────────────────────────────
+
+export async function POST(req: NextRequest, { params }: { params: Promise<{ route: string[] }> }) {
+  const { route } = await params;
+  const action = route.join("/");
+
+  if (action === "login") return handleLogin(req);
+  if (action === "register") return handleRegister(req);
+  if (action === "logout") return handleLogout();
+  if (action === "refresh") return handleRefresh(req);
+  if (action === "forgot-password") return handleForgotPassword(req);
+  if (action === "reset-password") return handleResetPassword(req);
+
+  return err("Not found", 404);
+}
+
+export async function GET(req: NextRequest, { params }: { params: Promise<{ route: string[] }> }) {
+  const { route } = await params;
+  const action = route.join("/");
+
+  if (action === "me") return handleMe(req);
+
+  return err("Not found", 404);
+}
+
+// ── Handlers ─────────────────────────────────────────────────────────────────
+
+async function handleLogin(req: NextRequest) {
+  const { email, password } = await req.json();
+  if (!email || !password) return err("Email and password are required");
+
+  // Replace with your real user lookup + bcrypt.compare
+  const user = await findUserByCredentials(email, password);
+  if (!user) return err("Invalid email or password", 401);
+
+  const token = await signToken({ sub: user.id, email: user.email });
+  return json({ user, token });
+}
+
+async function handleRegister(req: NextRequest) {
+  const { name, email, password } = await req.json();
+  if (!name || !email || !password) return err("Name, email, and password are required");
+  if (password.length < 8) return err("Password must be at least 8 characters");
+
+  // Replace with your real user creation logic
+  const user = await createUser(name, email, password);
+  const token = await signToken({ sub: user.id, email: user.email });
+  return json({ user, token }, 201);
+}
+
+async function handleLogout() {
+  const res = json({ ok: true });
+  res.cookies.delete("refresh_token");
+  return res;
+}
+
+async function handleRefresh(req: NextRequest) {
+  const refreshToken = req.cookies.get("refresh_token")?.value;
+  if (!refreshToken) return err("No refresh token", 401);
+  try {
+    const payload = await verifyToken(refreshToken);
+    const accessToken = await signToken({ sub: payload.sub, email: payload.email });
+    return json({ token: accessToken });
+  } catch {
+    return err("Invalid refresh token", 401);
+  }
+}
+
+async function handleForgotPassword(req: NextRequest) {
+  const { email } = await req.json();
+  if (!email) return err("Email is required");
+  // Replace: look up user, generate reset token, send email
+  await sendPasswordResetEmail(email);
+  return json({ ok: true });
+}
+
+async function handleResetPassword(req: NextRequest) {
+  const { token, password } = await req.json();
+  if (!token || !password) return err("Token and password are required");
+  // Replace: verify token, update user password
+  await resetUserPassword(token, password);
+  return json({ ok: true });
+}
+
+async function handleMe(req: NextRequest) {
+  const authHeader = req.headers.get("authorization");
+  const token = authHeader?.replace("Bearer ", "");
+  if (!token) return err("Unauthorized", 401);
+  try {
+    const payload = await verifyToken(token);
+    const user = await findUserById(payload.sub);
+    if (!user) return err("User not found", 404);
+    return json({ user });
+  } catch {
+    return err("Invalid token", 401);
+  }
+}
+
+// ── Stubs (replace with real DB calls) ───────────────────────────────────────
+
+async function findUserByCredentials(email: string, _password: string) {
+  // TODO: look up user in DB, compare password with bcrypt
+  void email;
+  return null as { id: string; name: string; email: string } | null;
+}
+
+async function createUser(name: string, email: string, _password: string) {
+  // TODO: hash password with bcrypt, insert into DB
+  void name; void email;
+  return { id: "stub", name, email };
+}
+
+async function findUserById(id: string) {
+  // TODO: look up user in DB by id
+  void id;
+  return null as { id: string; name: string; email: string } | null;
+}
+
+async function sendPasswordResetEmail(email: string) {
+  // TODO: generate token, store in DB, send via nodemailer
+  void email;
+}
+
+async function resetUserPassword(token: string, password: string) {
+  // TODO: verify token from DB, hash new password, update user
+  void token; void password;
+}

package/registry/components/auth/nextjs-compact/v1/files/app/auth/forgot-password/page.tsx

@@ -0,0 +1,150 @@
+"use client";
+
+import { useState } from "react";
+
+export default function ForgotPasswordPage() {
+  const [email, setEmail] = useState("");
+  const [submitted, setSubmitted] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState("");
+
+  async function handleSubmit(e: React.FormEvent) {
+    e.preventDefault();
+    setLoading(true);
+    setError("");
+    try {
+      const res = await fetch("/api/auth/forgot-password", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email }),
+      });
+      if (!res.ok) {
+        const d = await res.json();
+        throw new Error(d.message || "Failed to send reset email");
+      }
+      setSubmitted(true);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Something went wrong");
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return (
+    <main
+      style={{
+        minHeight: "100vh",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        background: "var(--color-bg-subtle)",
+        padding: "var(--space-4)",
+      }}
+    >
+      <div
+        style={{
+          width: "100%",
+          maxWidth: "420px",
+          background: "var(--color-bg)",
+          borderRadius: "var(--radius-xl)",
+          border: "1px solid var(--color-border)",
+          padding: "var(--space-8)",
+          boxShadow: "var(--shadow-lg)",
+        }}
+      >
+        {submitted ? (
+          <div style={{ textAlign: "center" }}>
+            <div style={{ fontSize: "3rem", marginBottom: "var(--space-4)" }}>📬</div>
+            <h1 style={{ fontSize: "var(--text-xl)", fontWeight: "var(--weight-bold)", color: "var(--color-text)" }}>
+              Check your email
+            </h1>
+            <p style={{ marginTop: "var(--space-2)", fontSize: "var(--text-sm)", color: "var(--color-text-muted)" }}>
+              We sent a password reset link to <strong>{email}</strong>
+            </p>
+            <a
+              href="/auth/login"
+              style={{
+                display: "inline-block",
+                marginTop: "var(--space-6)",
+                color: "var(--color-primary)",
+                fontSize: "var(--text-sm)",
+              }}
+            >
+              ← Back to sign in
+            </a>
+          </div>
+        ) : (
+          <>
+            <div style={{ textAlign: "center", marginBottom: "var(--space-8)" }}>
+              <h1 style={{ fontSize: "var(--text-2xl)", fontWeight: "var(--weight-bold)", color: "var(--color-text)" }}>
+                Forgot password?
+              </h1>
+              <p style={{ marginTop: "var(--space-2)", fontSize: "var(--text-sm)", color: "var(--color-text-muted)" }}>
+                Enter your email and we&apos;ll send you a reset link.
+              </p>
+            </div>
+
+            {error && (
+              <div
+                style={{
+                  marginBottom: "var(--space-4)",
+                  padding: "var(--space-3) var(--space-4)",
+                  borderRadius: "var(--radius-md)",
+                  background: "var(--color-error-subtle)",
+                  color: "var(--color-error-text)",
+                  fontSize: "var(--text-sm)",
+                }}
+              >
+                {error}
+              </div>
+            )}
+
+            <form onSubmit={handleSubmit} style={{ display: "flex", flexDirection: "column", gap: "var(--space-4)" }}>
+              <div style={{ display: "flex", flexDirection: "column", gap: "var(--space-2)" }}>
+                <label htmlFor="email" style={{ fontSize: "var(--text-sm)", fontWeight: "var(--weight-medium)", color: "var(--color-text)" }}>
+                  Email
+                </label>
+                <input
+                  id="email"
+                  type="email"
+                  required
+                  value={email}
+                  onChange={(e) => setEmail(e.target.value)}
+                  style={{
+                    padding: "var(--space-3) var(--space-4)",
+                    borderRadius: "var(--radius-md)",
+                    border: "1px solid var(--color-border)",
+                    background: "var(--color-bg)",
+                    color: "var(--color-text)",
+                    fontSize: "var(--text-base)",
+                  }}
+                />
+              </div>
+              <button
+                type="submit"
+                disabled={loading}
+                style={{
+                  padding: "var(--space-3) var(--space-4)",
+                  borderRadius: "var(--radius-md)",
+                  background: loading ? "var(--color-bg-muted)" : "var(--color-primary)",
+                  color: "var(--color-primary-text)",
+                  fontWeight: "var(--weight-semibold)",
+                  border: "none",
+                  cursor: loading ? "not-allowed" : "pointer",
+                }}
+              >
+                {loading ? "Sending…" : "Send reset link"}
+              </button>
+              <a
+                href="/auth/login"
+                style={{ textAlign: "center", fontSize: "var(--text-sm)", color: "var(--color-text-muted)" }}
+              >
+                ← Back to sign in
+              </a>
+            </form>
+          </>
+        )}
+      </div>
+    </main>
+  );
+}

package/registry/components/auth/nextjs-compact/v1/files/app/auth/login/page.tsx

@@ -0,0 +1,45 @@
+import { LoginForm } from "@/components/auth/LoginForm";
+
+export default function LoginPage() {
+  return (
+    <main
+      style={{
+        minHeight: "100vh",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        background: "var(--color-bg-subtle)",
+        padding: "var(--space-4)",
+      }}
+    >
+      <div
+        style={{
+          width: "100%",
+          maxWidth: "420px",
+          background: "var(--color-bg)",
+          borderRadius: "var(--radius-xl)",
+          border: "1px solid var(--color-border)",
+          padding: "var(--space-8)",
+          boxShadow: "var(--shadow-lg)",
+        }}
+      >
+        <div style={{ textAlign: "center", marginBottom: "var(--space-8)" }}>
+          <h1
+            style={{
+              fontSize: "var(--text-2xl)",
+              fontWeight: "var(--weight-bold)",
+              color: "var(--color-text)",
+              fontFamily: "var(--font-display)",
+            }}
+          >
+            Welcome back
+          </h1>
+          <p style={{ marginTop: "var(--space-2)", fontSize: "var(--text-sm)", color: "var(--color-text-muted)" }}>
+            Sign in to your account
+          </p>
+        </div>
+        <LoginForm />
+      </div>
+    </main>
+  );
+}

package/registry/components/auth/nextjs-compact/v1/files/app/auth/register/page.tsx

@@ -0,0 +1,45 @@
+import { RegisterForm } from "@/components/auth/RegisterForm";
+
+export default function RegisterPage() {
+  return (
+    <main
+      style={{
+        minHeight: "100vh",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        background: "var(--color-bg-subtle)",
+        padding: "var(--space-4)",
+      }}
+    >
+      <div
+        style={{
+          width: "100%",
+          maxWidth: "420px",
+          background: "var(--color-bg)",
+          borderRadius: "var(--radius-xl)",
+          border: "1px solid var(--color-border)",
+          padding: "var(--space-8)",
+          boxShadow: "var(--shadow-lg)",
+        }}
+      >
+        <div style={{ textAlign: "center", marginBottom: "var(--space-8)" }}>
+          <h1
+            style={{
+              fontSize: "var(--text-2xl)",
+              fontWeight: "var(--weight-bold)",
+              color: "var(--color-text)",
+              fontFamily: "var(--font-display)",
+            }}
+          >
+            Create an account
+          </h1>
+          <p style={{ marginTop: "var(--space-2)", fontSize: "var(--text-sm)", color: "var(--color-text-muted)" }}>
+            Get started for free
+          </p>
+        </div>
+        <RegisterForm />
+      </div>
+    </main>
+  );
+}