minutework 0.1.40 → 0.1.42

package/assets/templates/vuilder-shell/src/app/api/auth/logout/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server";
+
+import { hasTrustedBrowserOrigin } from "@/lib/http/same-origin";
+import { revokeVuilderShellSession } from "@/lib/platform/client.server";
+import {
+  clearPlatformSessionFromResponse,
+  readPlatformAuthState,
+} from "@/lib/platform/session.server";
+
+export async function POST(request: Request) {
+  if (!hasTrustedBrowserOrigin(request)) {
+    return NextResponse.json(
+      { detail: "Same-origin browser submission required." },
+      { status: 403 },
+    );
+  }
+
+  const authState = await readPlatformAuthState();
+  await revokeVuilderShellSession(authState).catch(() => null);
+  const response = new NextResponse(null, { status: 204 });
+  response.headers.set("Cache-Control", "no-store");
+  clearPlatformSessionFromResponse(response);
+  return response;
+}

package/assets/templates/vuilder-shell/src/app/api/auth/session/route.test.ts

@@ -0,0 +1,70 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  loadCurrentSession: vi.fn(),
+  readPlatformAuthState: vi.fn(),
+  syncPlatformAuthStateToResponse: vi.fn(),
+  toPlatformErrorResponse: vi.fn(),
+}));
+
+vi.mock("@/lib/platform/client.server", () => ({
+  loadCurrentSession: mocks.loadCurrentSession,
+}));
+
+vi.mock("@/lib/platform/route-response", () => ({
+  toPlatformErrorResponse: mocks.toPlatformErrorResponse,
+}));
+
+vi.mock("@/lib/platform/session.server", () => ({
+  readPlatformAuthState: mocks.readPlatformAuthState,
+  syncPlatformAuthStateToResponse: mocks.syncPlatformAuthStateToResponse,
+}));
+
+import { GET } from "./route";
+
+describe("GET /api/auth/session", () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns the current session with no-store cache headers", async () => {
+    const authState = { shellSessionToken: "shell-token-1" };
+    const nextAuthState = { shellSessionToken: "shell-token-2" };
+    mocks.readPlatformAuthState.mockResolvedValue(authState);
+    mocks.loadCurrentSession.mockResolvedValue({
+      authState: nextAuthState,
+      data: { authenticated: true },
+    });
+
+    const response = await GET();
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Cache-Control")).toBe("no-store");
+    await expect(response.json()).resolves.toEqual({ authenticated: true });
+    expect(mocks.syncPlatformAuthStateToResponse).toHaveBeenCalledWith(
+      expect.any(Response),
+      authState,
+      nextAuthState,
+    );
+  });
+
+  it("returns platform errors with no-store cache headers", async () => {
+    const authState = { shellSessionToken: "shell-token-1" };
+    const error = new Error("platform failed");
+    mocks.readPlatformAuthState.mockResolvedValue(authState);
+    mocks.loadCurrentSession.mockRejectedValue(error);
+    mocks.toPlatformErrorResponse.mockReturnValue(
+      Response.json({ detail: "Platform error" }, { status: 503 }),
+    );
+
+    const response = await GET();
+
+    expect(response.status).toBe(503);
+    expect(response.headers.get("Cache-Control")).toBe("no-store");
+    expect(mocks.toPlatformErrorResponse).toHaveBeenCalledWith(
+      error,
+      "Unable to load the current platform session.",
+      authState,
+    );
+  });
+});

package/assets/templates/vuilder-shell/src/app/api/auth/session/route.ts

@@ -0,0 +1,27 @@
+import { NextResponse } from "next/server";
+
+import { loadCurrentSession } from "@/lib/platform/client.server";
+import { toPlatformErrorResponse } from "@/lib/platform/route-response";
+import {
+  readPlatformAuthState,
+  syncPlatformAuthStateToResponse,
+} from "@/lib/platform/session.server";
+
+export async function GET() {
+  const authState = await readPlatformAuthState();
+  try {
+    const result = await loadCurrentSession(authState);
+    const response = NextResponse.json(result.data, { status: 200 });
+    response.headers.set("Cache-Control", "no-store");
+    syncPlatformAuthStateToResponse(response, authState, result.authState);
+    return response;
+  } catch (error) {
+    const response = toPlatformErrorResponse(
+      error,
+      "Unable to load the current platform session.",
+      authState,
+    );
+    response.headers.set("Cache-Control", "no-store");
+    return response;
+  }
+}

package/assets/templates/vuilder-shell/src/app/app/layout.tsx

@@ -0,0 +1,17 @@
+import type { Metadata } from "next";
+import type { ReactNode } from "react";
+
+export const metadata: Metadata = {
+  robots: {
+    index: false,
+    follow: false,
+  },
+};
+
+export default function AuthenticatedAppLayout({
+  children,
+}: {
+  children: ReactNode;
+}) {
+  return children;
+}

package/assets/templates/vuilder-shell/src/app/app/page.tsx

@@ -0,0 +1,30 @@
+import { notFound, redirect } from "next/navigation";
+
+import { appRoutes } from "@/lib/app-routes";
+import { loadCurrentWorkspaceShellSession } from "@/lib/platform/client.server";
+import { readPlatformAuthState } from "@/lib/platform/session.server";
+
+export const metadata = {
+  title: "Workspace",
+};
+
+export default async function AppHomePage() {
+  const authState = await readPlatformAuthState();
+  const shellSession = (await loadCurrentWorkspaceShellSession(authState)).data;
+  const { membership, session, workspaceCanOpen, workspaceCanView } =
+    shellSession;
+
+  if (!session.authenticated) {
+    redirect(appRoutes.login);
+  }
+
+  if (!membership || !workspaceCanView) {
+    notFound();
+  }
+
+  if (!workspaceCanOpen) {
+    redirect(appRoutes.workspaceConnect(membership.workspace_slug));
+  }
+
+  redirect(appRoutes.workspaceShell(membership.workspace_slug));
+}

package/assets/templates/vuilder-shell/src/app/blog/[slug]/page.tsx

@@ -0,0 +1,15 @@
+import { StaticPublicPage } from "@/features/public-shell/components/static-public-page";
+
+export const metadata = {
+  title: "Blog",
+};
+
+export default function BlogPostPage() {
+  return (
+    <StaticPublicPage
+      eyebrow="Blog"
+      title="Update"
+      body="A customer-facing update."
+    />
+  );
+}

package/assets/templates/vuilder-shell/src/app/blog/page.tsx

@@ -0,0 +1,15 @@
+import { StaticPublicPage } from "@/features/public-shell/components/static-public-page";
+
+export const metadata = {
+  title: "Blog",
+};
+
+export default function BlogIndexPage() {
+  return (
+    <StaticPublicPage
+      eyebrow="Blog"
+      title="Updates"
+      body="News, releases, and customer notes."
+    />
+  );
+}

package/assets/templates/vuilder-shell/src/app/docs/[...slug]/page.tsx

@@ -0,0 +1,15 @@
+import { StaticPublicPage } from "@/features/public-shell/components/static-public-page";
+
+export const metadata = {
+  title: "Docs",
+};
+
+export default function DocsPage() {
+  return (
+    <StaticPublicPage
+      eyebrow="Docs"
+      title="Documentation page"
+      body="Helpful context for customer workflows."
+    />
+  );
+}

package/assets/templates/vuilder-shell/src/app/docs/page.tsx

@@ -0,0 +1,15 @@
+import { StaticPublicPage } from "@/features/public-shell/components/static-public-page";
+
+export const metadata = {
+  title: "Docs",
+};
+
+export default function DocsIndexPage() {
+  return (
+    <StaticPublicPage
+      eyebrow="Docs"
+      title="Customer documentation"
+      body="Guides, onboarding notes, and product documentation."
+    />
+  );
+}

package/assets/templates/vuilder-shell/src/app/globals.css

@@ -0,0 +1,70 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+@import "../design-system/tokens/index.css";
+
+@layer base {
+  html {
+    height: 100%;
+  }
+
+  body {
+    min-height: 100%;
+    margin: 0;
+  }
+
+  * {
+    @apply border-border outline-ring/50;
+    box-sizing: border-box;
+  }
+
+  body {
+    @apply bg-background text-foreground antialiased;
+  }
+
+  a {
+    color: inherit;
+  }
+}
+
+@layer components {
+  .public-site-background {
+    background:
+      linear-gradient(
+        180deg,
+        var(--color-background) 0%,
+        color-mix(in oklab, var(--color-surface-raised) 68%, white) 100%
+      );
+  }
+
+  .public-site-orb {
+    background:
+      radial-gradient(
+        circle at top left,
+        color-mix(in oklab, var(--color-primary) 28%, white) 0%,
+        transparent 48%
+      ),
+      radial-gradient(
+        circle at top right,
+        color-mix(in oklab, var(--color-chart-2) 18%, white) 0%,
+        transparent 42%
+      );
+  }
+
+  .marketing-hero-surface {
+    background:
+      linear-gradient(
+        135deg,
+        color-mix(in oklab, var(--color-surface) 78%, white) 0%,
+        color-mix(in oklab, var(--color-primary) 8%, white) 100%
+      );
+  }
+
+  .marketing-hero-orb {
+    background:
+      radial-gradient(
+        circle at center,
+        color-mix(in oklab, var(--color-chart-2) 14%, white) 0%,
+        transparent 70%
+      );
+  }
+}

package/assets/templates/vuilder-shell/src/app/layout.tsx

@@ -0,0 +1,69 @@
+import "./globals.css";
+import type { Metadata } from "next";
+import { Geist, Geist_Mono } from "next/font/google";
+import { cookies } from "next/headers";
+import type { ReactNode } from "react";
+
+import { AppProviders } from "./providers";
+import { resolvePublicMetadataBase } from "@/lib/public-site";
+import {
+  isThemeMode,
+  THEME_COOKIE_NAME,
+  type ThemeMode,
+} from "@/lib/theme-config";
+
+const geistSans = Geist({
+  subsets: ["latin"],
+  variable: "--font-sans",
+});
+
+const geistMono = Geist_Mono({
+  subsets: ["latin"],
+  variable: "--font-mono",
+});
+
+export function generateMetadata(): Metadata {
+  const metadataBase = resolvePublicMetadataBase();
+  const appName = process.env.MW_TEMPLATE_APP_NAME || "Vuilder Shell";
+
+  return {
+    ...(metadataBase ? { metadataBase } : {}),
+    title: {
+      default: appName,
+      template: `%s | ${appName}`,
+    },
+    description: "Customer-facing branded tenant shell.",
+    openGraph: {
+      title: appName,
+      description: "Customer-facing branded tenant shell.",
+      siteName: appName,
+      type: "website",
+      ...(process.env.MW_PUBLIC_BASE_URL ? { url: process.env.MW_PUBLIC_BASE_URL } : {}),
+    },
+  };
+}
+
+export default async function RootLayout({ children }: { children: ReactNode }) {
+  const cookieStore = await cookies();
+  const themeCookie = cookieStore.get(THEME_COOKIE_NAME)?.value;
+  const initialTheme: ThemeMode = isThemeMode(themeCookie) ? themeCookie : "system";
+  const resolvedThemeClass =
+    initialTheme === "light" || initialTheme === "dark" ? initialTheme : undefined;
+  const colorScheme =
+    initialTheme === "light" || initialTheme === "dark" ? initialTheme : undefined;
+
+  return (
+    <html
+      lang="en"
+      suppressHydrationWarning
+      className={resolvedThemeClass}
+      style={colorScheme ? { colorScheme } : undefined}
+    >
+      <body
+        className={`${geistSans.variable} ${geistMono.variable} bg-background font-sans text-foreground antialiased`}
+      >
+        <AppProviders initialTheme={initialTheme}>{children}</AppProviders>
+      </body>
+    </html>
+  );
+}

package/assets/templates/vuilder-shell/src/app/login/route.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  applyVuilderShellHandoffStateToResponse: vi.fn(),
+  createVuilderShellHandoffState: vi.fn(() => "state-1"),
+}));
+
+vi.mock("@/lib/platform/session.server", () => ({
+  applyVuilderShellHandoffStateToResponse:
+    mocks.applyVuilderShellHandoffStateToResponse,
+  createVuilderShellHandoffState: mocks.createVuilderShellHandoffState,
+}));
+
+import { GET } from "./route";
+
+describe("GET /login", () => {
+  it("sets shell handoff state and redirects to central SSO", () => {
+    const response = GET(
+      new Request("https://shell.example.com/login?return_to=%2Fw%2Ffleet-alpha"),
+    );
+
+    expect(response.status).toBe(307);
+    expect(response.headers.get("location")).toBe(
+      "http://127.0.0.1:3400/login?returnTo=http%3A%2F%2F127.0.0.1%3A3301%2Fw%2Ffleet-alpha%2Fconnect%3Fmw_shell_state%3Dstate-1",
+    );
+    expect(response.headers.get("cache-control")).toBe("no-store");
+    expect(response.headers.get("referrer-policy")).toBe("no-referrer");
+    expect(mocks.applyVuilderShellHandoffStateToResponse).toHaveBeenCalledWith(
+      expect.any(Response),
+      "state-1",
+    );
+  });
+});

package/assets/templates/vuilder-shell/src/app/login/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from "next/server";
+
+import { buildCentralSsoLoginUrl } from "@/lib/auth-routes.server";
+import {
+  applyVuilderShellHandoffStateToResponse,
+  createVuilderShellHandoffState,
+} from "@/lib/platform/session.server";
+
+export function GET(request: Request) {
+  const url = new URL(request.url);
+  const returnPath =
+    url.searchParams.get("return_to") ?? url.searchParams.get("returnTo");
+  const handoffState = createVuilderShellHandoffState();
+  const response = NextResponse.redirect(
+    buildCentralSsoLoginUrl(returnPath, handoffState),
+  );
+  response.headers.set("Cache-Control", "no-store");
+  response.headers.set("Referrer-Policy", "no-referrer");
+  applyVuilderShellHandoffStateToResponse(response, handoffState);
+  return response;
+}

package/assets/templates/vuilder-shell/src/app/page.tsx

@@ -0,0 +1,16 @@
+import { StaticPublicPage } from "@/features/public-shell/components/static-public-page";
+
+export const metadata = {
+  title: "Vuilder Shell",
+  description: "Customer-facing branded tenant shell.",
+};
+
+export default function HomePage() {
+  return (
+    <StaticPublicPage
+      eyebrow="Vuilder Shell"
+      title="A branded customer workspace connected to MinuteWork"
+      body="Customer workspace routes stay branded while identity, provisioning, and app-pack install authority stay on the platform."
+    />
+  );
+}

package/assets/templates/vuilder-shell/src/app/pricing/page.tsx

@@ -0,0 +1,15 @@
+import { StaticPublicPage } from "@/features/public-shell/components/static-public-page";
+
+export const metadata = {
+  title: "Pricing",
+};
+
+export default function PricingPage() {
+  return (
+    <StaticPublicPage
+      eyebrow="Pricing"
+      title="Plans for customer access"
+      body="Clear plan options for customer workspaces."
+    />
+  );
+}

package/assets/templates/vuilder-shell/src/app/providers.tsx

@@ -0,0 +1,25 @@
+"use client";
+
+import type { ReactNode } from "react";
+
+import { ThemeProvider } from "@/lib/theme";
+import type { ThemeMode } from "@/lib/theme-config";
+
+export function AppProviders({
+  children,
+  initialTheme,
+}: {
+  children: ReactNode;
+  initialTheme: ThemeMode;
+}) {
+  return (
+    <ThemeProvider
+      attribute="class"
+      defaultTheme={initialTheme}
+      enableSystem
+      disableTransitionOnChange
+    >
+      {children}
+    </ThemeProvider>
+  );
+}

package/assets/templates/vuilder-shell/src/app/robots.ts

@@ -0,0 +1,21 @@
+import type { MetadataRoute } from "next";
+
+import { resolvePublicMetadataBase } from "@/lib/public-site";
+
+export default function robots(): MetadataRoute.Robots {
+  const metadataBase = resolvePublicMetadataBase();
+  return {
+    rules: [
+      {
+        userAgent: "*",
+        allow: "/",
+      },
+    ],
+    ...(metadataBase
+      ? {
+          sitemap: new URL("/sitemap.xml", metadataBase).toString(),
+          host: metadataBase.host,
+        }
+      : {}),
+  };
+}

package/assets/templates/vuilder-shell/src/app/sitemap.ts

@@ -0,0 +1,33 @@
+import type { MetadataRoute } from "next";
+
+import { appRoutes } from "@/lib/app-routes";
+import { resolvePublicSiteUrl } from "@/lib/public-site";
+
+function buildSitemapUrl(pathname: string) {
+  return resolvePublicSiteUrl(pathname)?.toString() ?? pathname;
+}
+
+export default function sitemap(): MetadataRoute.Sitemap {
+  return [
+    {
+      url: buildSitemapUrl(appRoutes.publicHome),
+      changeFrequency: "weekly",
+      priority: 1,
+    },
+    {
+      url: buildSitemapUrl(appRoutes.pricing),
+      changeFrequency: "monthly",
+      priority: 0.8,
+    },
+    {
+      url: buildSitemapUrl(appRoutes.docsIndex),
+      changeFrequency: "weekly",
+      priority: 0.8,
+    },
+    {
+      url: buildSitemapUrl(appRoutes.blogIndex),
+      changeFrequency: "weekly",
+      priority: 0.8,
+    },
+  ];
+}

package/assets/templates/vuilder-shell/src/app/w/[workspace_slug]/connect/page.tsx

@@ -0,0 +1,31 @@
+import { notFound } from "next/navigation";
+
+import { VuilderConnectScreen } from "@/features/vuilder-shell/components/vuilder-connect-screen";
+import { loadWorkspaceShellSession } from "@/lib/platform/client.server";
+import { readPlatformAuthState } from "@/lib/platform/session.server";
+
+type WorkspaceConnectPageProps = {
+  params: Promise<{
+    workspace_slug: string;
+  }>;
+};
+
+export const metadata = {
+  title: "Connect Workspace",
+};
+
+export default async function WorkspaceConnectPage({
+  params,
+}: WorkspaceConnectPageProps) {
+  const { workspace_slug: workspaceSlug } = await params;
+  const authState = await readPlatformAuthState();
+  const shellSession = (await loadWorkspaceShellSession(authState, workspaceSlug))
+    .data;
+  const { membership, session, workspaceCanView } = shellSession;
+
+  if (session.authenticated && (!membership || !workspaceCanView)) {
+    notFound();
+  }
+
+  return <VuilderConnectScreen session={session} workspaceSlug={workspaceSlug} />;
+}

package/assets/templates/vuilder-shell/src/app/w/[workspace_slug]/page.tsx

@@ -0,0 +1,54 @@
+import { notFound, redirect } from "next/navigation";
+
+import { AuthenticatedAppLayoutShell } from "@/features/shell/components/authenticated-app-layout-shell";
+import { VuilderWorkspaceScreen } from "@/features/vuilder-shell/components/vuilder-workspace-screen";
+import { loadWorkspaceShellSession } from "@/lib/platform/client.server";
+import { appRoutes } from "@/lib/app-routes";
+import { readPlatformAuthState } from "@/lib/platform/session.server";
+
+type WorkspacePageProps = {
+  params: Promise<{
+    workspace_slug: string;
+  }>;
+};
+
+export const metadata = {
+  title: "Workspace",
+};
+
+export default async function WorkspacePage({ params }: WorkspacePageProps) {
+  const { workspace_slug: workspaceSlug } = await params;
+  const appName = process.env.MW_TEMPLATE_APP_NAME || "Vuilder Shell";
+  const authState = await readPlatformAuthState();
+  const shellSession = (await loadWorkspaceShellSession(authState, workspaceSlug))
+    .data;
+  const { membership, session, workspaceCanOpen, workspaceCanView } =
+    shellSession;
+
+  if (!session.authenticated) {
+    redirect(appRoutes.loginForWorkspace(workspaceSlug));
+  }
+
+  if (!membership || !workspaceCanView) {
+    notFound();
+  }
+
+  if (!workspaceCanOpen) {
+    redirect(appRoutes.workspaceConnect(workspaceSlug));
+  }
+
+  return (
+    <AuthenticatedAppLayoutShell
+      appName={appName}
+      membership={membership}
+      session={session}
+    >
+      <VuilderWorkspaceScreen
+        appName={appName}
+        membership={membership}
+        session={session}
+        workspaceSlug={workspaceSlug}
+      />
+    </AuthenticatedAppLayoutShell>
+  );
+}