@hachej/boring-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 boringdata
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# @boring/core
+
+Database, auth, and app factory for boring-ui apps.
+
+```bash
+pnpm add @boring/core
+```
+
+---
+
+## What it provides
+
+- **Database** — Drizzle ORM schema for users, workspaces, sessions, invites
+- **Auth** — better-auth with workspace support, invite flows, email verification
+- **App factory** — Fastify app with auth routes, middleware, and CORS wired in
+- **Frontend shell** — `<BoringApp>` React provider with auth pages and workspace switcher
+
+---
+
+## Quickstart
+
+Server:
+
+```ts
+import { createCoreApp, loadConfig } from "@boring/core/server"
+
+const config = await loadConfig()
+const app = await createCoreApp(config)
+await app.listen({ port: config.port })
+```
+
+Frontend:
+
+```tsx
+import { BoringApp } from "@boring/core/front"
+import { WorkspaceProvider, IdeLayout } from "@boring/workspace"
+
+export function App() {
+  return (
+    <BoringApp>
+      <Route path="/" element={<WorkspaceProvider><IdeLayout /></WorkspaceProvider>} />
+    </BoringApp>
+  )
+}
+```
+
+---
+
+## Config
+
+Minimum `.env` to get started:
+
+```bash
+DATABASE_URL=postgres://postgres:postgres@localhost:5432/boring
+BETTER_AUTH_SECRET=<any 64-char hex string>
+ANTHROPIC_API_KEY=sk-ant-...
+```
+
+Run migrations:
+
+```bash
+pnpm --filter @boring/core drizzle:migrate
+```
+
+---
+
+## Package surfaces
+
+```ts
+import { ... } from "@boring/core/server"   // Fastify app factory, config
+import { ... } from "@boring/core/front"    // React shell, auth pages
+import { ... } from "@boring/core/db"       // Drizzle schema and client
+```
+
+---
+
+## Part of [boring-ui](https://github.com/hachej/boring-ui)
+
+| Package | Role |
+|---|---|
+| `@boring/core` | DB, auth, app factory |
+| `@boring/workspace` | Plugin system, layouts |
+| `@boring/agent` | Agent runtime + tools |

package/dist/CoreFront-CDeLdfb0.d.ts

@@ -0,0 +1,19 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+interface CoreFrontAuthPagesOverride {
+    signIn?: React.FC;
+    signUp?: React.FC;
+    forgotPassword?: React.FC;
+    resetPassword?: React.FC;
+    verifyEmail?: React.FC;
+    userSettings?: React.FC;
+}
+interface CoreFrontProps {
+    children?: ReactNode;
+    authPages?: CoreFrontAuthPagesOverride;
+    cspNonce?: string;
+}
+declare function CoreFront({ children, authPages, cspNonce }: CoreFrontProps): react_jsx_runtime.JSX.Element;
+
+export { type CoreFrontAuthPagesOverride as C, CoreFront as a, type CoreFrontProps as b };

package/dist/app/front/index.d.ts

@@ -0,0 +1,18 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { C as CoreFrontAuthPagesOverride } from '../../CoreFront-CDeLdfb0.js';
+import { WorkspaceAgentSession, WorkspaceAgentFrontProps } from '@hachej/boring-workspace/app/front';
+
+interface CoreWorkspaceAgentFrontProps<TSession extends WorkspaceAgentSession = WorkspaceAgentSession> extends Omit<WorkspaceAgentFrontProps<TSession>, 'workspaceId'> {
+    authPages?: CoreFrontAuthPagesOverride;
+    cspNonce?: string;
+    children?: ReactNode;
+    workspaceRoute?: string;
+    workspaceIdParam?: string;
+    workspaceHref?: (workspaceId: string) => string;
+    loadingFallback?: ReactNode;
+    bootPreloadPaths?: string[];
+}
+declare function CoreWorkspaceAgentFront<TSession extends WorkspaceAgentSession = WorkspaceAgentSession>({ authPages, cspNonce, children, workspaceRoute, workspaceIdParam, workspaceHref, loadingFallback, bootPreloadPaths, topBarLeft, topBarRight, appTitle, bridgeEndpoint, ...workspaceProps }: CoreWorkspaceAgentFrontProps<TSession>): react_jsx_runtime.JSX.Element;
+
+export { CoreWorkspaceAgentFront, type CoreWorkspaceAgentFrontProps };

package/dist/app/front/index.js

@@ -0,0 +1,162 @@
+import {
+  CoreFront,
+  UserMenu,
+  WorkspaceSwitcher,
+  useCurrentWorkspace
+} from "../../chunk-VTOS4C7B.js";
+import "../../chunk-HYNKZSTF.js";
+import "../../chunk-H5KU6R6Y.js";
+import "../../chunk-MLKGABMK.js";
+
+// src/app/front/CoreWorkspaceAgentFront.tsx
+import { useMemo } from "react";
+import { Navigate, Route, useParams } from "react-router-dom";
+import {
+  WorkspaceAgentFront,
+  WorkspaceBootGate
+} from "@hachej/boring-workspace/app/front";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_WORKSPACE_ROUTE = "/workspace/:id";
+var DEFAULT_WORKSPACE_ID_PARAM = "id";
+function DefaultTopBarRight() {
+  return /* @__PURE__ */ jsx(UserMenu, {});
+}
+function WorkspaceLoadingPage({
+  appTitle,
+  topBarLeft,
+  topBarRight
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex h-screen min-h-0 flex-col bg-background text-foreground", children: [
+    /* @__PURE__ */ jsxs("header", { className: "flex h-12 shrink-0 items-center justify-between border-b border-border bg-card px-3", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 items-center gap-3", children: [
+        /* @__PURE__ */ jsx("div", { className: "text-sm font-semibold", children: appTitle }),
+        topBarLeft
+      ] }),
+      topBarRight
+    ] }),
+    /* @__PURE__ */ jsx("main", { className: "flex min-h-0 flex-1 items-center justify-center px-6", children: /* @__PURE__ */ jsxs("div", { className: "w-full max-w-md rounded-2xl border border-border bg-card p-6 text-center shadow-sm", children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          "aria-hidden": "true",
+          className: "mx-auto mb-4 h-8 w-8 rounded-full border-2 border-muted-foreground/20 border-t-foreground animate-spin will-change-transform"
+        }
+      ),
+      /* @__PURE__ */ jsx("h1", { className: "text-lg font-semibold", children: "Switching workspace" }),
+      /* @__PURE__ */ jsx("p", { className: "mt-2 text-sm text-muted-foreground", children: "Restoring files, sessions, and saved layout." }),
+      /* @__PURE__ */ jsx("p", { className: "mt-4 text-xs uppercase tracking-[0.18em] text-muted-foreground", children: "Loading workspace" })
+    ] }) })
+  ] });
+}
+function HomeRedirect({
+  loadingFallback,
+  workspaceHref
+}) {
+  const workspace = useCurrentWorkspace();
+  if (!workspace) return /* @__PURE__ */ jsx(Fragment, { children: loadingFallback });
+  return /* @__PURE__ */ jsx(Navigate, { to: workspaceHref(workspace.id), replace: true });
+}
+function WorkspaceRoute({
+  workspaceIdParam,
+  loadingFallback,
+  bootPreloadPaths,
+  workspaceProps
+}) {
+  const params = useParams();
+  const currentWorkspace = useCurrentWorkspace();
+  const workspaceId = params[workspaceIdParam]?.trim() ?? "";
+  const requestHeaders = useMemo(
+    () => ({ ...workspaceProps.requestHeaders, "x-boring-workspace-id": workspaceId }),
+    [workspaceId, workspaceProps.requestHeaders]
+  );
+  const authHeaders = useMemo(
+    () => ({ ...workspaceProps.authHeaders, "x-boring-workspace-id": workspaceId }),
+    [workspaceId, workspaceProps.authHeaders]
+  );
+  if (!workspaceId) return /* @__PURE__ */ jsx(Fragment, { children: loadingFallback });
+  if (currentWorkspace?.id !== workspaceId) return /* @__PURE__ */ jsx(Fragment, { children: loadingFallback });
+  return /* @__PURE__ */ jsx(
+    WorkspaceBootGate,
+    {
+      workspaceId,
+      requestHeaders,
+      apiBaseUrl: workspaceProps.apiBaseUrl,
+      preloadPaths: bootPreloadPaths,
+      loadingFallback,
+      children: /* @__PURE__ */ jsx(
+        WorkspaceAgentFront,
+        {
+          ...workspaceProps,
+          workspaceId,
+          requestHeaders,
+          authHeaders
+        }
+      )
+    }
+  );
+}
+function CoreWorkspaceAgentFront({
+  authPages,
+  cspNonce,
+  children,
+  workspaceRoute = DEFAULT_WORKSPACE_ROUTE,
+  workspaceIdParam = DEFAULT_WORKSPACE_ID_PARAM,
+  workspaceHref = (workspaceId) => `/workspace/${workspaceId}`,
+  loadingFallback,
+  bootPreloadPaths,
+  topBarLeft = /* @__PURE__ */ jsx(WorkspaceSwitcher, {}),
+  topBarRight = /* @__PURE__ */ jsx(DefaultTopBarRight, {}),
+  appTitle = "Boring",
+  bridgeEndpoint = "/api/v1/ui",
+  ...workspaceProps
+}) {
+  const resolvedLoadingFallback = loadingFallback ?? /* @__PURE__ */ jsx(
+    WorkspaceLoadingPage,
+    {
+      appTitle,
+      topBarLeft,
+      topBarRight
+    }
+  );
+  const resolvedWorkspaceProps = {
+    ...workspaceProps,
+    appTitle,
+    topBarLeft,
+    topBarRight,
+    bridgeEndpoint
+  };
+  return /* @__PURE__ */ jsxs(CoreFront, { authPages, cspNonce, children: [
+    /* @__PURE__ */ jsx(
+      Route,
+      {
+        path: "/",
+        element: /* @__PURE__ */ jsx(
+          HomeRedirect,
+          {
+            loadingFallback: resolvedLoadingFallback,
+            workspaceHref
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Route,
+      {
+        path: workspaceRoute,
+        element: /* @__PURE__ */ jsx(
+          WorkspaceRoute,
+          {
+            workspaceIdParam,
+            loadingFallback: resolvedLoadingFallback,
+            bootPreloadPaths,
+            workspaceProps: resolvedWorkspaceProps
+          }
+        )
+      }
+    ),
+    children
+  ] });
+}
+export {
+  CoreWorkspaceAgentFront
+};

package/dist/app/front/styles.css

@@ -0,0 +1,6 @@
+@import "tailwindcss" source(none);
+@source "../..";
+
+@import "../../front/theme.css";
+@import "@hachej/boring-workspace/globals.css";
+@import "@hachej/boring-agent/front/styles.css";

package/dist/app/server/index.d.ts

@@ -0,0 +1,96 @@
+import { RuntimeProvisioningContribution, RegisterAgentRoutesOptions } from '@hachej/boring-agent/server';
+import { CreateWorkspaceAgentServerOptions } from '@hachej/boring-workspace/app/server';
+import { FastifyInstance } from 'fastify';
+import { C as CoreConfig } from '../../index-COZa03RP.js';
+import { B as BetterAuthInstance, L as LoadConfigOptions } from '../../authHook-vsRhOvnh.js';
+import { D as Database, U as UserStore, W as WorkspaceStore } from '../../connection-CE7z-wBp.js';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import 'better-auth';
+import 'drizzle-orm/postgres-js';
+import 'postgres';
+
+type CoreWorkspaceAgentServer = FastifyInstance & {
+    auth: BetterAuthInstance;
+    db: Database;
+    userStore: UserStore;
+    workspaceStore: WorkspaceStore;
+};
+type CoreWorkspaceAgentServerPlugin = NonNullable<CreateWorkspaceAgentServerOptions['plugins']>[number] & {
+    provisioning?: RuntimeProvisioningContribution;
+};
+interface CreateCoreWorkspaceAgentServerOptions extends Omit<RegisterAgentRoutesOptions, 'extraTools'> {
+    appRoot?: string;
+    config?: CoreConfig;
+    loadConfigOptions?: LoadConfigOptions;
+    plugins?: CoreWorkspaceAgentServerPlugin[];
+    excludeDefaults?: CreateWorkspaceAgentServerOptions['excludeDefaults'];
+    forceProvisioning?: boolean;
+    extraTools?: RegisterAgentRoutesOptions['extraTools'];
+    systemPromptAppend?: string;
+    serveFrontend?: boolean;
+}
+declare function createCoreWorkspaceAgentServer(options?: CreateCoreWorkspaceAgentServerOptions): Promise<CoreWorkspaceAgentServer>;
+
+interface StartCoreWorkspaceAgentDevServerOptions {
+    appRoot: string;
+    buildServer: (options: {
+        appRoot: string;
+        serveFrontend: false;
+    }) => Promise<CoreWorkspaceAgentServer>;
+    frontendPort?: number;
+    eventPrefix?: string;
+}
+interface CoreWorkspaceAgentDevServerHandle {
+    app: CoreWorkspaceAgentServer;
+    address: string;
+    apiTarget: string;
+}
+declare function startCoreWorkspaceAgentDevServer({ appRoot, buildServer, frontendPort, eventPrefix, }: StartCoreWorkspaceAgentDevServerOptions): Promise<CoreWorkspaceAgentDevServerHandle>;
+interface StartCoreWorkspaceAgentDevServerFromMetaOptions {
+    frontendPort?: number;
+    eventPrefix?: string;
+    levelsUp?: number;
+}
+declare function startCoreWorkspaceAgentDevServerFromMeta(importMetaUrl: string, opts?: StartCoreWorkspaceAgentDevServerFromMetaOptions): Promise<CoreWorkspaceAgentDevServerHandle>;
+
+interface VercelFastifyLikeServer {
+    ready(): PromiseLike<void> | void;
+    server: {
+        emit(event: 'request', req: IncomingMessage, res: ServerResponse): boolean;
+    };
+}
+type VercelFastifyHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+interface CreateVercelFastifyHandlerOptions<TServer extends VercelFastifyLikeServer> {
+    createServer: () => Promise<TServer> | TServer;
+}
+/**
+ * Adapt a Fastify server factory to Vercel's Node function signature.
+ *
+ * The Fastify instance is created once per warm function process and reused for
+ * subsequent invocations. App-specific policy (runtime mode, workspace root,
+ * appRoot, etc.) belongs in the caller's `createServer` factory.
+ */
+declare function createVercelFastifyHandler<TServer extends VercelFastifyLikeServer>({ createServer, }: CreateVercelFastifyHandlerOptions<TServer>): VercelFastifyHandler;
+
+declare function appRootFromImportMeta(importMetaUrl: string, levelsUp?: number): string;
+
+interface RunCoreWorkspaceAgentServerOptions {
+    workspaceRoot?: string;
+    /** How many directory levels up from the entry file is the app root. Default: 2 (src/server → app). */
+    levelsUp?: number;
+}
+declare function runCoreWorkspaceAgentServer(importMetaUrl: string, opts?: RunCoreWorkspaceAgentServerOptions): Promise<void>;
+
+interface CreateCoreVercelEntryOptions {
+    workspaceRoot?: string;
+}
+/**
+ * Creates a Vercel Function handler.
+ * Sets BORING_AGENT_MODE and BORING_AGENT_WORKSPACE_ROOT defaults for Vercel.
+ *
+ * Usage in vercel-entry.ts:
+ *   export default createCoreVercelEntry(import.meta.url)
+ */
+declare function createCoreVercelEntry(_importMetaUrl: string, opts?: CreateCoreVercelEntryOptions): VercelFastifyHandler;
+
+export { type CoreWorkspaceAgentDevServerHandle, type CoreWorkspaceAgentServer, type CoreWorkspaceAgentServerPlugin, type CreateCoreVercelEntryOptions, type CreateCoreWorkspaceAgentServerOptions, type CreateVercelFastifyHandlerOptions, type RunCoreWorkspaceAgentServerOptions, type StartCoreWorkspaceAgentDevServerFromMetaOptions, type StartCoreWorkspaceAgentDevServerOptions, type VercelFastifyHandler, type VercelFastifyLikeServer, appRootFromImportMeta, createCoreVercelEntry, createCoreWorkspaceAgentServer, createVercelFastifyHandler, runCoreWorkspaceAgentServer, startCoreWorkspaceAgentDevServer, startCoreWorkspaceAgentDevServerFromMeta };