@useatlas/create 0.0.6 → 0.0.7

package/templates/docker/src/api/server.ts

@@ -9,19 +9,38 @@
  * 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.
+ *
+ * Effect migration (P6):
+ * Server boot expressed as an Effect Layer DAG. Startup validation runs
+ * eagerly during Layer construction. Shutdown is automatic via Scope
+ * cleanup — no manual SIGTERM handler ordering.
  */
 
+import { Effect, ManagedRuntime } from "effect";
 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";
+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";
+import { buildAppLayer } from "@atlas/api/lib/effect/layers";
 
 const log = createLogger("server");
+
 const port = Number(process.env.PORT ?? 3001);
 
 if (!Number.isFinite(port) || port < 0 || port > 65535) {
@@ -37,8 +56,10 @@ 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.
+// ── Config + Plugin wiring (imperative, pre-Layer) ──────────────────
+// Config and plugin wiring stay imperative because they produce the
+// config object that the Layer DAG needs as input.
+
 const config = await initializeConfig().catch((err) => {
   log.error(
     { err: err instanceof Error ? err : new Error(String(err)) },
@@ -63,18 +84,20 @@ if (config.plugins?.length) {
   }
 
   if (registrationFailed) {
-    log.error("Aborting startup — one or more plugins failed to register. Fix your atlas.config.ts plugins array.");
+    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 { 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 = {
@@ -90,23 +113,37 @@ if (config.plugins?.length) {
           },
         }
       : null,
-    connections: { get: (id: string) => connections.get(id), list: () => connections.list() },
-    tools: { register: (tool) => pluginToolRegistry.register(tool as Parameters<typeof pluginToolRegistry.register>[0]) },
+    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>,
   };
 
-  // Run plugin schema migrations before initialize() so plugins can use
-  // their tables in initialize(). Schema is declared at plugin creation
-  // time, so it is readable before initialize() runs.
+  // Run plugin schema migrations before initialize()
   const pluginsWithSchema = plugins.getAll().filter((p) => p.schema != null);
   if (pluginsWithSchema.length > 0) {
     if (hasInternalDB()) {
       try {
-        const { runPluginMigrations } = await import("@atlas/api/lib/plugins/migrate");
-        const migrationResult = await runPluginMigrations(getInternalDB(), plugins.getAll());
+        const { runPluginMigrations } = await import(
+          "@atlas/api/lib/plugins/migrate"
+        );
+        const migrationResult = await runPluginMigrations(
+          getInternalDB(),
+          plugins.getAll(),
+        );
         if (migrationResult.applied.length > 0) {
-          log.info({ applied: migrationResult.applied }, "Plugin schema migrations applied");
+          log.info(
+            { applied: migrationResult.applied },
+            "Plugin schema migrations applied",
+          );
         }
       } catch (err) {
         log.error(
@@ -125,17 +162,26 @@ if (config.plugins?.length) {
 
   const { succeeded, failed } = await plugins.initializeAll(pluginContext);
   if (failed.length > 0) {
-    log.error({ succeeded, failed }, `Plugin initialization completed with ${failed.length} failure(s)`);
+    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");
+    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");
+    log.error(
+      { entityFailures: dsResult.entityFailures },
+      "Some plugin entities failed to load",
+    );
   }
   if (dsResult.dialectHints.length > 0) {
     setDialectHints(dsResult.dialectHints);
@@ -143,10 +189,12 @@ if (config.plugins?.length) {
 
   const actionResult = await wireActionPlugins(plugins, pluginToolRegistry);
   if (actionResult.failed.length > 0) {
-    log.error({ failed: actionResult.failed }, "Some action plugins failed to wire");
+    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);
@@ -154,7 +202,10 @@ if (config.plugins?.length) {
 
   const ctxResult = await wireContextPlugins(plugins);
   if (ctxResult.failed.length > 0) {
-    log.error({ failed: ctxResult.failed }, "Some context plugins failed to load");
+    log.error(
+      { failed: ctxResult.failed },
+      "Some context plugins failed to load",
+    );
   }
   if (ctxResult.fragments.length > 0) {
     setContextFragments(ctxResult.fragments);
@@ -162,91 +213,158 @@ if (config.plugins?.length) {
 
   const intResult = await wireInteractionPlugins(plugins, app);
   if (intResult.failed.length > 0) {
-    log.error({ failed: intResult.failed }, "Some interaction plugins failed to wire");
+    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",
-      );
+  // Wire plugin cache backend if any plugin provides one
+  for (const plugin of plugins.getAll()) {
+    if (plugin.cacheBackend) {
+      try {
+        const { setCacheBackend } = await import(
+          "@atlas/api/lib/cache/index"
+        );
+        setCacheBackend(
+          plugin.cacheBackend as import("@atlas/api/lib/cache/index").CacheBackend,
+        );
+        log.info(
+          { pluginId: plugin.id },
+          "Plugin-provided cache backend registered",
+        );
+      } catch (err) {
+        log.error(
+          {
+            err: err instanceof Error ? err.message : String(err),
+            pluginId: plugin.id,
+          },
+          "Failed to wire plugin cache backend — falling back to in-memory LRU",
+        );
+      }
+      break;
     }
-    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");
+// Pre-warm connection pools after all datasources (config + plugins) are registered.
+await connections.warmup().catch((err) => {
+  log.error(
+    { err: err instanceof Error ? err.message : String(err) },
+    "Pool warmup failed — datasource may be unreachable",
+  );
+});
+
+// ── Effect Layer DAG (P6) ───────────────────────────────────────────
+// Remaining startup steps (telemetry, migrations, semantic sync, settings,
+// schedulers) run as an Effect Layer DAG. Shutdown is automatic via Scope.
+
+const appLayer = buildAppLayer(config);
+const runtime = ManagedRuntime.make(appLayer);
+
+// Eagerly boot the Layer DAG — startup errors surface here, not on first request.
+await Effect.runPromise(runtime.runtimeEffect).catch((err) => {
+  log.error(
+    { err: err instanceof Error ? err : new Error(String(err)) },
+    "Server startup failed — Layer DAG could not initialize",
+  );
+  process.exit(1);
 });
 
-// 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");
-}
+// ── HTTP Server ─────────────────────────────────────────────────────
 
 const server = Bun.serve({
   port,
   fetch: app.fetch,
 });
 
+// ── Graceful shutdown ───────────────────────────────────────────────
+// Effect runtime disposal tears down scoped Layers via their finalizers.
+// We also clean up the imperative singletons (connections, internal DB).
+
 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");
+    log.error(
+      { err: err instanceof Error ? err.message : String(err) },
+      "Failed to stop HTTP server",
+    );
+  }
+
+  // Dispose the Effect runtime — tears down schedulers, telemetry via finalizers
+  try {
+    await runtime.dispose();
+  } catch (err) {
+    log.error(
+      { err: err instanceof Error ? err.message : String(err) },
+      "Effect runtime disposal failed",
+    );
   }
 
-  // Stop scheduler if running
-  if (config.scheduler?.backend === "bun") {
+  // Teardown plugin lifecycle (still imperative pending full P5 wiring integration)
+  if (config.plugins?.length) {
+    const timeout = setTimeout(() => {
+      log.error("Plugin teardown timed out after 10s — forcing exit");
+      process.exit(1);
+    }, 10_000);
+    timeout.unref();
     try {
-      const { getScheduler } = await import("@atlas/api/lib/scheduler/engine");
-      getScheduler().stop();
+      await plugins.teardownAll();
+      log.info("Plugin teardown complete");
     } catch (err) {
-      log.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to stop scheduler");
+      log.error(
+        { err: err instanceof Error ? err : new Error(String(err)) },
+        "Unexpected error during plugin teardown",
+      );
+    } finally {
+      clearTimeout(timeout);
     }
   }
 
+  // Imperative singleton cleanup
   try {
     await connections.shutdown();
   } catch (err) {
-    log.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to shut down connections");
+    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.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);
-}));
+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");
 

package/templates/docker/src/app/error.tsx

@@ -9,10 +9,13 @@ export default function Error({
 }) {
   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>
+      <h2 className="text-lg font-semibold">An unexpected error occurred</h2>
       <p className="max-w-md text-center text-sm text-zinc-400">
-        {error.message || "An unexpected error occurred."}
+        {error.message || "Please try again or contact your admin if the problem persists."}
       </p>
+      {error.digest && (
+        <p className="text-xs text-zinc-500">Ref: {error.digest}</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"

package/templates/docker/src/app/globals.css

@@ -1,7 +1,7 @@
 @import "tailwindcss";
 @import "tw-animate-css";
 @import "shadcn/tailwind.css";
-@import "../../../../brand.css";
+@import "../../brand.css";
 
 @custom-variant dark (&:is(.dark *));
 @source "../ui";

package/templates/docker/src/app/layout.tsx

@@ -1,5 +1,6 @@
 import type { Metadata } from "next";
 import { NuqsAdapter } from "nuqs/adapters/next/app";
+import { buildThemeInitScript } from "@/ui/hooks/theme-init-script";
 import "./globals.css";
 
 export const metadata: Metadata = {
@@ -15,10 +16,14 @@ export default function RootLayout({
   return (
     <html lang="en" suppressHydrationWarning>
       <head>
-        {/* Inline script to set dark class before first paint — prevents flash */}
-        <script dangerouslySetInnerHTML={{ __html: `try{if(window.matchMedia("(prefers-color-scheme:dark)").matches)document.documentElement.classList.add("dark")}catch(e){}` }} />
+        {/* Inline script to set dark class before first paint — prevents flash.
+            Reads atlas-theme from localStorage: "dark" → always dark, "light" → always light,
+            "system" or missing → follows prefers-color-scheme.
+            Generated by buildThemeInitScript() to stay in sync with use-dark-mode.ts. */}
+        <script dangerouslySetInnerHTML={{ __html: buildThemeInitScript() }} />
       </head>
       <body className="bg-white text-zinc-900 antialiased dark:bg-zinc-950 dark:text-zinc-100">
+        <a href="#main" className="sr-only focus:not-sr-only focus:absolute focus:z-50 focus:p-4 focus:bg-background focus:text-foreground">Skip to content</a>
         <NuqsAdapter>{children}</NuqsAdapter>
       </body>
     </html>

package/templates/docker/src/app/page.tsx

@@ -1,14 +1,48 @@
 "use client";
 
-import { AtlasUIProvider } from "@/ui/context";
-import { AtlasChat } from "@/ui/components/atlas-chat";
+import dynamic from "next/dynamic";
+import { AtlasChat } from "@useatlas/react";
 import { authClient } from "@/lib/auth/client";
 import { API_URL, IS_CROSS_ORIGIN } from "@/lib/api-url";
+import { NavBar } from "@/ui/components/tour/nav-bar";
+
+const GuidedTour = dynamic(
+  () => import("@/ui/components/tour/guided-tour").then((m) => m.GuidedTour),
+  { ssr: false },
+);
 
 export default function Home() {
+  const session = authClient.useSession();
+  const user = session.data?.user as
+    | { email?: string; role?: string }
+    | undefined;
+  // User-level role check for nav bar display only — actual admin access
+  // is gated by the backend (which resolves org member roles too).
+  const isAdmin = user?.role === "admin" || user?.role === "owner" || user?.role === "platform_admin";
+  const isSignedIn = !!user;
+
+  // Server tracking requires managed auth (signed-in user)
+  const serverTrackingEnabled = isSignedIn;
+
   return (
-    <AtlasUIProvider config={{ apiUrl: API_URL, isCrossOrigin: IS_CROSS_ORIGIN, authClient }}>
-      <AtlasChat />
-    </AtlasUIProvider>
+    <GuidedTour
+      apiUrl={API_URL}
+      isCrossOrigin={IS_CROSS_ORIGIN}
+      isAdmin={isAdmin}
+      serverTrackingEnabled={serverTrackingEnabled}
+    >
+      <div className="flex h-dvh flex-col">
+        <NavBar isAdmin={isAdmin} />
+        {/* Override AtlasChat's h-dvh so it fills remaining space below the NavBar */}
+        <div className="flex-1 overflow-hidden [&_.atlas-root]:h-full">
+          <AtlasChat
+            apiUrl={API_URL}
+            sidebar
+            schemaExplorer
+            authClient={authClient}
+          />
+        </div>
+      </div>
+    </GuidedTour>
   );
 }

package/templates/docker/src/components/data-table/data-table-column-header.tsx

@@ -0,0 +1,99 @@
+"use client";
+
+import type { Column } from "@tanstack/react-table";
+import {
+  ChevronDown,
+  ChevronsUpDown,
+  ChevronUp,
+  EyeOff,
+  X,
+} from "lucide-react";
+
+import {
+  DropdownMenu,
+  DropdownMenuCheckboxItem,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { cn } from "@/lib/utils";
+
+interface DataTableColumnHeaderProps<TData, TValue>
+  extends React.ComponentProps<typeof DropdownMenuTrigger> {
+  column: Column<TData, TValue>;
+  label: string;
+}
+
+export function DataTableColumnHeader<TData, TValue>({
+  column,
+  label,
+  className,
+  ...props
+}: DataTableColumnHeaderProps<TData, TValue>) {
+  if (!column.getCanSort() && !column.getCanHide()) {
+    return <div className={cn(className)}>{label}</div>;
+  }
+
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger
+        className={cn(
+          "-ml-1.5 flex h-8 items-center gap-1.5 rounded-md px-2 py-1.5 hover:bg-accent focus:outline-none focus:ring-1 focus:ring-ring data-[state=open]:bg-accent [&_svg]:size-4 [&_svg]:shrink-0 [&_svg]:text-muted-foreground",
+          className,
+        )}
+        {...props}
+      >
+        {label}
+        {column.getCanSort() &&
+          (column.getIsSorted() === "desc" ? (
+            <ChevronDown />
+          ) : column.getIsSorted() === "asc" ? (
+            <ChevronUp />
+          ) : (
+            <ChevronsUpDown />
+          ))}
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="start" className="w-28">
+        {column.getCanSort() && (
+          <>
+            <DropdownMenuCheckboxItem
+              className="relative pr-8 pl-2 [&>span:first-child]:right-2 [&>span:first-child]:left-auto [&_svg]:text-muted-foreground"
+              checked={column.getIsSorted() === "asc"}
+              onClick={() => column.toggleSorting(false)}
+            >
+              <ChevronUp />
+              Asc
+            </DropdownMenuCheckboxItem>
+            <DropdownMenuCheckboxItem
+              className="relative pr-8 pl-2 [&>span:first-child]:right-2 [&>span:first-child]:left-auto [&_svg]:text-muted-foreground"
+              checked={column.getIsSorted() === "desc"}
+              onClick={() => column.toggleSorting(true)}
+            >
+              <ChevronDown />
+              Desc
+            </DropdownMenuCheckboxItem>
+            {column.getIsSorted() && (
+              <DropdownMenuItem
+                className="pl-2 [&_svg]:text-muted-foreground"
+                onClick={() => column.clearSorting()}
+              >
+                <X />
+                Reset
+              </DropdownMenuItem>
+            )}
+          </>
+        )}
+        {column.getCanHide() && (
+          <DropdownMenuCheckboxItem
+            className="relative pr-8 pl-2 [&>span:first-child]:right-2 [&>span:first-child]:left-auto [&_svg]:text-muted-foreground"
+            checked={!column.getIsVisible()}
+            onClick={() => column.toggleVisibility(false)}
+          >
+            <EyeOff />
+            Hide
+          </DropdownMenuCheckboxItem>
+        )}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}