@useatlas/create 0.0.1

package/templates/nextjs-standalone/src/api/server.ts

@@ -0,0 +1,226 @@
+/**
+ * Standalone Hono server entry point.
+ *
+ * Run with: bun run dev:api (from repo root)
+ *
+ * This enables headless API deployment without Next.js — useful for
+ * Slack bots, CLI tools, SDK consumers, or any non-browser client.
+ *
+ * On startup, loads `atlas.config.ts` (if present) and wires datasources
+ * into the ConnectionRegistry. When no config file exists, the existing
+ * env-var behavior is preserved.
+ */
+
+import { app } from "./index";
+import { createLogger } from "@atlas/api/lib/logger";
+import { initializeConfig } from "@atlas/api/lib/config";
+import { migrateAuthTables } from "@atlas/api/lib/auth/migrate";
+import { connections } from "@atlas/api/lib/db/connection";
+import { closeInternalDB } from "@atlas/api/lib/db/internal";
+import { plugins, type PluginContextLike } from "@atlas/api/lib/plugins/registry";
+import { wireDatasourcePlugins, wireActionPlugins, wireInteractionPlugins, wireContextPlugins } from "@atlas/api/lib/plugins/wiring";
+import { setPluginTools, setContextFragments, setDialectHints } from "@atlas/api/lib/plugins/tools";
+
+const log = createLogger("server");
+const port = Number(process.env.PORT ?? 3001);
+
+if (!Number.isFinite(port) || port < 0 || port > 65535) {
+  log.error({ raw: process.env.PORT }, "Invalid PORT — must be 0–65535");
+  process.exit(1);
+}
+
+process.on("unhandledRejection", (reason) => {
+  log.error({ err: reason }, "Unhandled rejection");
+});
+
+process.on("uncaughtException", (err) => {
+  log.error({ err }, "Uncaught exception");
+});
+
+// Load atlas.config.ts (if present) and wire datasources/tools.
+// Blocks startup so the server never serves requests with stale config.
+const config = await initializeConfig().catch((err) => {
+  log.error(
+    { err: err instanceof Error ? err : new Error(String(err)) },
+    "Config initialization failed — check your atlas.config.ts",
+  );
+  process.exit(1);
+});
+
+// Register, initialize, and wire plugins (only when config contains plugins).
+if (config.plugins?.length) {
+  let registrationFailed = false;
+  for (const raw of config.plugins) {
+    try {
+      plugins.register(raw as Parameters<typeof plugins.register>[0]);
+    } catch (err) {
+      log.error(
+        { err: err instanceof Error ? err : new Error(String(err)) },
+        "Plugin registration failed",
+      );
+      registrationFailed = true;
+    }
+  }
+
+  if (registrationFailed) {
+    log.error("Aborting startup — one or more plugins failed to register. Fix your atlas.config.ts plugins array.");
+    process.exit(1);
+  }
+
+  // Build plugin context — gives plugins typed access to Atlas internals
+  // via dependency injection (db, connections, tools, logger, config).
+  const { connections } = await import("@atlas/api/lib/db/connection");
+  const { ToolRegistry } = await import("@atlas/api/lib/tools/registry");
+  const { hasInternalDB, internalQuery, getInternalDB } = await import("@atlas/api/lib/db/internal");
+  const { getLogger } = await import("@atlas/api/lib/logger");
+
+  // Create an unfrozen registry for plugin tools
+  const pluginToolRegistry = new ToolRegistry();
+
+  const pluginContext: PluginContextLike = {
+    db: hasInternalDB()
+      ? {
+          async query(sql: string, params?: unknown[]) {
+            const rows = await internalQuery(sql, params);
+            return { rows };
+          },
+          async execute(sql: string, params?: unknown[]) {
+            const pool = getInternalDB();
+            await pool.query(sql, params);
+          },
+        }
+      : null,
+    connections: { get: (id: string) => connections.get(id), list: () => connections.list() },
+    tools: { register: (tool) => pluginToolRegistry.register(tool as Parameters<typeof pluginToolRegistry.register>[0]) },
+    logger: getLogger() as unknown as Record<string, unknown>,
+    config: config as unknown as Record<string, unknown>,
+  };
+
+  const { succeeded, failed } = await plugins.initializeAll(pluginContext);
+  if (failed.length > 0) {
+    log.error({ succeeded, failed }, `Plugin initialization completed with ${failed.length} failure(s)`);
+  } else {
+    log.info({ succeeded }, "All plugins initialized successfully");
+  }
+
+  const dsResult = await wireDatasourcePlugins(plugins);
+  if (dsResult.failed.length > 0) {
+    log.error({ failed: dsResult.failed }, "Some datasource plugins failed to wire");
+  }
+  if (dsResult.entityFailures.length > 0) {
+    log.error({ entityFailures: dsResult.entityFailures }, "Some plugin entities failed to load");
+  }
+  if (dsResult.dialectHints.length > 0) {
+    setDialectHints(dsResult.dialectHints);
+  }
+
+  const actionResult = await wireActionPlugins(plugins, pluginToolRegistry);
+  if (actionResult.failed.length > 0) {
+    log.error({ failed: actionResult.failed }, "Some action plugins failed to wire");
+  }
+
+  // Store plugin tools for chat route merging (if any tools were registered)
+  if (pluginToolRegistry.size > 0) {
+    pluginToolRegistry.freeze();
+    setPluginTools(pluginToolRegistry);
+  }
+
+  const ctxResult = await wireContextPlugins(plugins);
+  if (ctxResult.failed.length > 0) {
+    log.error({ failed: ctxResult.failed }, "Some context plugins failed to load");
+  }
+  if (ctxResult.fragments.length > 0) {
+    setContextFragments(ctxResult.fragments);
+  }
+
+  const intResult = await wireInteractionPlugins(plugins, app);
+  if (intResult.failed.length > 0) {
+    log.error({ failed: intResult.failed }, "Some interaction plugins failed to wire");
+  }
+
+  // Graceful shutdown: teardown plugins on SIGTERM
+  process.on("SIGTERM", async () => {
+    log.info("SIGTERM received — tearing down plugins");
+    const timeout = setTimeout(() => {
+      log.error("Plugin teardown timed out after 10s — forcing exit");
+      process.exit(1);
+    }, 10_000);
+    timeout.unref();
+    try {
+      await plugins.teardownAll();
+      log.info("Plugin teardown complete");
+    } catch (err) {
+      log.error(
+        { err: err instanceof Error ? err : new Error(String(err)) },
+        "Unexpected error during plugin teardown",
+      );
+    }
+    process.exit(0);
+  });
+}
+
+// Run migrations once at boot — blocks until complete, but does not prevent startup on failure.
+await migrateAuthTables().catch((err) => {
+  log.error({ err: err instanceof Error ? err : new Error(String(err)) }, "Boot migration failed");
+});
+
+// Start scheduler if configured with "bun" backend
+if (config.scheduler?.backend === "bun") {
+  const { getScheduler } = await import("@atlas/api/lib/scheduler/engine");
+  getScheduler().start();
+} else if (config.scheduler?.backend === "vercel") {
+  log.info("Scheduler backend is 'vercel' — tick endpoint active, no in-process loop");
+}
+
+const server = Bun.serve({
+  port,
+  fetch: app.fetch,
+});
+
+async function shutdown(signal: string) {
+  log.info({ signal }, "Graceful shutdown initiated");
+
+  try {
+    server.stop();
+  } catch (err) {
+    log.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to stop HTTP server");
+  }
+
+  // Stop scheduler if running
+  if (config.scheduler?.backend === "bun") {
+    try {
+      const { getScheduler } = await import("@atlas/api/lib/scheduler/engine");
+      getScheduler().stop();
+    } catch (err) {
+      log.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to stop scheduler");
+    }
+  }
+
+  try {
+    await connections.shutdown();
+  } catch (err) {
+    log.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to shut down connections");
+  }
+
+  try {
+    await closeInternalDB();
+  } catch (err) {
+    log.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to close internal DB");
+  }
+
+  log.info("Shutdown complete");
+  process.exit(0);
+}
+
+process.on("SIGTERM", () => shutdown("SIGTERM").catch((err) => {
+  log.error({ err: err instanceof Error ? err.message : String(err) }, "Shutdown handler failed");
+  process.exit(1);
+}));
+process.on("SIGINT", () => shutdown("SIGINT").catch((err) => {
+  log.error({ err: err instanceof Error ? err.message : String(err) }, "Shutdown handler failed");
+  process.exit(1);
+}));
+
+log.info({ port }, "Atlas API server starting");
+
+export default server;

package/templates/nextjs-standalone/src/app/api/[...route]/route.ts

@@ -0,0 +1,33 @@
+// If the Hono app fails to initialise (e.g. missing env vars),
+// every request to API routes will return a Next.js 500 until the issue is resolved.
+import { app } from "@atlas/api/app";
+
+// Default 60s. Increase based on your Vercel plan:
+// https://vercel.com/docs/functions/configuring-functions/duration
+export const maxDuration = 60;
+
+async function handler(req: Request): Promise<Response> {
+  try {
+    return await app.fetch(req);
+  } catch (err) {
+    console.error("[atlas] Unhandled error in API route:", err);
+    return Response.json(
+      {
+        error: "internal_error",
+        message:
+          "An unexpected server error occurred. Check the Vercel function logs for details.",
+      },
+      { status: 500 },
+    );
+  }
+}
+
+export {
+  handler as GET,
+  handler as POST,
+  handler as PUT,
+  handler as DELETE,
+  handler as PATCH,
+  handler as HEAD,
+  handler as OPTIONS,
+};

package/templates/nextjs-standalone/src/app/error.tsx

@@ -0,0 +1,24 @@
+"use client";
+
+export default function Error({
+  error,
+  reset,
+}: {
+  error: Error & { digest?: string };
+  reset: () => void;
+}) {
+  return (
+    <div className="flex h-dvh flex-col items-center justify-center gap-4 bg-zinc-950 p-4 text-zinc-100">
+      <h2 className="text-lg font-semibold">Something went wrong</h2>
+      <p className="max-w-md text-center text-sm text-zinc-400">
+        {error.message || "An unexpected error occurred."}
+      </p>
+      <button
+        onClick={reset}
+        className="rounded-lg bg-blue-600 px-4 py-2 text-sm font-medium text-white transition-colors hover:bg-blue-500"
+      >
+        Try again
+      </button>
+    </div>
+  );
+}

package/templates/nextjs-standalone/src/app/global-error.tsx

@@ -0,0 +1,68 @@
+"use client";
+
+/**
+ * Catches errors thrown in the root layout.
+ * Must provide its own <html> and <body> tags since the layout itself may have failed.
+ * Uses inline styles because Tailwind CSS may not load if the layout errored.
+ */
+export default function GlobalError({
+  error,
+  reset,
+}: {
+  error: Error & { digest?: string };
+  reset: () => void;
+}) {
+  return (
+    <html lang="en">
+      <body
+        style={{
+          margin: 0,
+          minHeight: "100dvh",
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "center",
+          justifyContent: "center",
+          gap: "1rem",
+          backgroundColor: "#09090b",
+          color: "#f4f4f5",
+          fontFamily: "system-ui, sans-serif",
+          padding: "1rem",
+        }}
+      >
+        <h2 style={{ fontSize: "1.125rem", fontWeight: 600 }}>
+          Something went wrong
+        </h2>
+        <p
+          style={{
+            maxWidth: "28rem",
+            textAlign: "center",
+            fontSize: "0.875rem",
+            color: "#a1a1aa",
+          }}
+        >
+          {error.message || "An unexpected error occurred."}
+        </p>
+        {error.digest && (
+          <p style={{ fontSize: "0.75rem", color: "#71717a" }}>
+            Reference: {error.digest}
+          </p>
+        )}
+        <button
+          onClick={reset}
+          style={{
+            borderRadius: "0.5rem",
+            backgroundColor: "#2563eb",
+            padding: "0.5rem 1rem",
+            fontSize: "0.875rem",
+            fontWeight: 500,
+            color: "white",
+            border: "none",
+            cursor: "pointer",
+          }}
+        >
+          Try again
+        </button>
+      </body>
+    </html>
+  );
+}

package/templates/nextjs-standalone/src/app/globals.css

@@ -0,0 +1,126 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+@import "shadcn/tailwind.css";
+
+@custom-variant dark (&:is(.dark *));
+@source "../ui";
+@source "../components";
+
+@theme inline {
+    --radius-sm: calc(var(--radius) - 4px);
+    --radius-md: calc(var(--radius) - 2px);
+    --radius-lg: var(--radius);
+    --radius-xl: calc(var(--radius) + 4px);
+    --radius-2xl: calc(var(--radius) + 8px);
+    --radius-3xl: calc(var(--radius) + 12px);
+    --radius-4xl: calc(var(--radius) + 16px);
+    --color-background: var(--background);
+    --color-foreground: var(--foreground);
+    --color-card: var(--card);
+    --color-card-foreground: var(--card-foreground);
+    --color-popover: var(--popover);
+    --color-popover-foreground: var(--popover-foreground);
+    --color-primary: var(--primary);
+    --color-primary-foreground: var(--primary-foreground);
+    --color-secondary: var(--secondary);
+    --color-secondary-foreground: var(--secondary-foreground);
+    --color-muted: var(--muted);
+    --color-muted-foreground: var(--muted-foreground);
+    --color-accent: var(--accent);
+    --color-accent-foreground: var(--accent-foreground);
+    --color-destructive: var(--destructive);
+    --color-border: var(--border);
+    --color-input: var(--input);
+    --color-ring: var(--ring);
+    --color-chart-1: var(--chart-1);
+    --color-chart-2: var(--chart-2);
+    --color-chart-3: var(--chart-3);
+    --color-chart-4: var(--chart-4);
+    --color-chart-5: var(--chart-5);
+    --color-sidebar: var(--sidebar);
+    --color-sidebar-foreground: var(--sidebar-foreground);
+    --color-sidebar-primary: var(--sidebar-primary);
+    --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+    --color-sidebar-accent: var(--sidebar-accent);
+    --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+    --color-sidebar-border: var(--sidebar-border);
+    --color-sidebar-ring: var(--sidebar-ring);
+}
+
+:root {
+    --radius: 0.625rem;
+    --background: oklch(1 0 0);
+    --foreground: oklch(0.145 0 0);
+    --card: oklch(1 0 0);
+    --card-foreground: oklch(0.145 0 0);
+    --popover: oklch(1 0 0);
+    --popover-foreground: oklch(0.145 0 0);
+    --primary: oklch(0.205 0 0);
+    --primary-foreground: oklch(0.985 0 0);
+    --secondary: oklch(0.97 0 0);
+    --secondary-foreground: oklch(0.205 0 0);
+    --muted: oklch(0.97 0 0);
+    --muted-foreground: oklch(0.556 0 0);
+    --accent: oklch(0.97 0 0);
+    --accent-foreground: oklch(0.205 0 0);
+    --destructive: oklch(0.577 0.245 27.325);
+    --border: oklch(0.922 0 0);
+    --input: oklch(0.922 0 0);
+    --ring: oklch(0.708 0 0);
+    --chart-1: oklch(0.646 0.222 41.116);
+    --chart-2: oklch(0.6 0.118 184.704);
+    --chart-3: oklch(0.398 0.07 227.392);
+    --chart-4: oklch(0.828 0.189 84.429);
+    --chart-5: oklch(0.769 0.188 70.08);
+    --sidebar: oklch(0.985 0 0);
+    --sidebar-foreground: oklch(0.145 0 0);
+    --sidebar-primary: oklch(0.205 0 0);
+    --sidebar-primary-foreground: oklch(0.985 0 0);
+    --sidebar-accent: oklch(0.97 0 0);
+    --sidebar-accent-foreground: oklch(0.205 0 0);
+    --sidebar-border: oklch(0.922 0 0);
+    --sidebar-ring: oklch(0.708 0 0);
+}
+
+.dark {
+    --background: oklch(0.145 0 0);
+    --foreground: oklch(0.985 0 0);
+    --card: oklch(0.205 0 0);
+    --card-foreground: oklch(0.985 0 0);
+    --popover: oklch(0.205 0 0);
+    --popover-foreground: oklch(0.985 0 0);
+    --primary: oklch(0.922 0 0);
+    --primary-foreground: oklch(0.205 0 0);
+    --secondary: oklch(0.269 0 0);
+    --secondary-foreground: oklch(0.985 0 0);
+    --muted: oklch(0.269 0 0);
+    --muted-foreground: oklch(0.708 0 0);
+    --accent: oklch(0.269 0 0);
+    --accent-foreground: oklch(0.985 0 0);
+    --destructive: oklch(0.704 0.191 22.216);
+    --border: oklch(1 0 0 / 10%);
+    --input: oklch(1 0 0 / 15%);
+    --ring: oklch(0.556 0 0);
+    --chart-1: oklch(0.488 0.243 264.376);
+    --chart-2: oklch(0.696 0.17 162.48);
+    --chart-3: oklch(0.769 0.188 70.08);
+    --chart-4: oklch(0.627 0.265 303.9);
+    --chart-5: oklch(0.645 0.246 16.439);
+    --sidebar: oklch(0.205 0 0);
+    --sidebar-foreground: oklch(0.985 0 0);
+    --sidebar-primary: oklch(0.488 0.243 264.376);
+    --sidebar-primary-foreground: oklch(0.985 0 0);
+    --sidebar-accent: oklch(0.269 0 0);
+    --sidebar-accent-foreground: oklch(0.985 0 0);
+    --sidebar-border: oklch(1 0 0 / 10%);
+    --sidebar-ring: oklch(0.556 0 0);
+}
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+    }
+  body {
+    @apply bg-background text-foreground;
+    }
+}

package/templates/nextjs-standalone/src/app/layout.tsx

@@ -0,0 +1,19 @@
+import type { Metadata } from "next";
+import "./globals.css";
+
+export const metadata: Metadata = {
+  title: "Atlas",
+  description: "Ask your data anything",
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en">
+      <body className="bg-white text-zinc-900 antialiased dark:bg-zinc-950 dark:text-zinc-100">{children}</body>
+    </html>
+  );
+}

package/templates/nextjs-standalone/src/app/page.tsx

@@ -0,0 +1,14 @@
+"use client";
+
+import { AtlasUIProvider } from "@/ui/context";
+import { AtlasChat } from "@/ui/components/atlas-chat";
+import { authClient } from "@/lib/auth/client";
+import { API_URL, IS_CROSS_ORIGIN } from "@/lib/api-url";
+
+export default function Home() {
+  return (
+    <AtlasUIProvider config={{ apiUrl: API_URL, isCrossOrigin: IS_CROSS_ORIGIN, authClient }}>
+      <AtlasChat />
+    </AtlasUIProvider>
+  );
+}