@primstack/cli 0.0.1

package/dist/integrations/analytics/providers/amplitude/templates/src/analytics/index.ts.template

@@ -0,0 +1,79 @@
+import { init, track, identify, groupIdentify as ampGroupIdentify, flush } from '@amplitude/analytics-node';
+import { Identify } from '@amplitude/analytics-node';
+import type { AnalyticsConfig, EventProperties, UserProperties } from './types.js';
+
+let initialized = false;
+
+export function initAnalytics(config?: Partial<AnalyticsConfig>): boolean {
+  const apiKey = config?.apiKey ?? process.env.AMPLITUDE_API_KEY;
+  if (!apiKey) {
+    console.warn('[analytics] AMPLITUDE_API_KEY not set — analytics disabled');
+    return false;
+  }
+
+  init(apiKey, {
+    logLevel: config?.debug ? 3 : 0,
+  });
+
+  initialized = true;
+
+  if (config?.debug) {
+    console.log('[analytics] Amplitude initialized');
+  }
+
+  return true;
+}
+
+export function trackEvent(
+  event: string,
+  properties?: EventProperties,
+  userId?: string,
+): void {
+  if (!initialized) return;
+
+  track(event, properties, {
+    user_id: userId ?? 'anonymous',
+  });
+}
+
+export function identifyUser(userId: string, properties?: UserProperties): void {
+  if (!initialized) return;
+
+  const identifyObj = new Identify();
+  if (properties) {
+    for (const [key, value] of Object.entries(properties)) {
+      if (value !== null && value !== undefined) {
+        identifyObj.set(key, value);
+      }
+    }
+  }
+
+  identify(identifyObj, { user_id: userId });
+}
+
+export function groupIdentify(
+  groupType: string,
+  groupId: string,
+  properties?: UserProperties,
+): void {
+  if (!initialized) return;
+
+  const identifyObj = new Identify();
+  if (properties) {
+    for (const [key, value] of Object.entries(properties)) {
+      if (value !== null && value !== undefined) {
+        identifyObj.set(key, value);
+      }
+    }
+  }
+
+  ampGroupIdentify(groupType, groupId, identifyObj);
+}
+
+export async function shutdownAnalytics(): Promise<void> {
+  if (!initialized) return;
+  await flush();
+  initialized = false;
+}
+
+export type { AnalyticsConfig, EventProperties, UserProperties } from './types.js';

package/dist/integrations/analytics/providers/amplitude/templates/src/analytics/types.ts.template

@@ -0,0 +1,12 @@
+export interface AnalyticsConfig {
+  apiKey?: string;
+  debug?: boolean;
+}
+
+export interface EventProperties {
+  [key: string]: string | number | boolean | null | undefined;
+}
+
+export interface UserProperties {
+  [key: string]: string | number | boolean | null | undefined;
+}

package/dist/integrations/analytics/providers/mixpanel/templates/src/analytics/index.ts.template

@@ -0,0 +1,62 @@
+import Mixpanel from 'mixpanel';
+import type { AnalyticsConfig, EventProperties, UserProperties } from './types.js';
+
+let client: Mixpanel.Mixpanel | null = null;
+
+export function initAnalytics(config?: Partial<AnalyticsConfig>): boolean {
+  const token = config?.apiKey ?? process.env.MIXPANEL_TOKEN;
+  if (!token) {
+    console.warn('[analytics] MIXPANEL_TOKEN not set — analytics disabled');
+    return false;
+  }
+
+  client = Mixpanel.init(token, {
+    debug: config?.debug ?? false,
+  });
+
+  if (config?.debug) {
+    console.log('[analytics] Mixpanel initialized');
+  }
+
+  return true;
+}
+
+export function trackEvent(
+  event: string,
+  properties?: EventProperties,
+  userId?: string,
+): void {
+  if (!client) return;
+
+  client.track(event, {
+    ...properties,
+    distinct_id: userId ?? 'anonymous',
+  });
+}
+
+export function identifyUser(userId: string, properties?: UserProperties): void {
+  if (!client) return;
+
+  client.people.set(userId, properties ?? {});
+}
+
+export function groupIdentify(
+  groupType: string,
+  groupId: string,
+  properties?: UserProperties,
+): void {
+  if (!client) return;
+
+  client.track('$group_identify', {
+    $group_type: groupType,
+    $group_id: groupId,
+    ...properties,
+  });
+}
+
+export async function shutdownAnalytics(): Promise<void> {
+  // Mixpanel Node SDK sends events immediately; no shutdown needed
+  client = null;
+}
+
+export type { AnalyticsConfig, EventProperties, UserProperties } from './types.js';

package/dist/integrations/analytics/providers/mixpanel/templates/src/analytics/types.ts.template

@@ -0,0 +1,12 @@
+export interface AnalyticsConfig {
+  apiKey?: string;
+  debug?: boolean;
+}
+
+export interface EventProperties {
+  [key: string]: string | number | boolean | null | undefined;
+}
+
+export interface UserProperties {
+  [key: string]: string | number | boolean | null | undefined;
+}

package/dist/integrations/analytics/providers/posthog/templates/src/analytics/index.ts.template

@@ -0,0 +1,67 @@
+import { PostHog } from 'posthog-node';
+import type { AnalyticsConfig, EventProperties, UserProperties } from './types.js';
+
+let client: PostHog | null = null;
+
+export function initAnalytics(config?: Partial<AnalyticsConfig>): boolean {
+  const apiKey = config?.apiKey ?? process.env.POSTHOG_API_KEY;
+  if (!apiKey) {
+    console.warn('[analytics] POSTHOG_API_KEY not set — analytics disabled');
+    return false;
+  }
+
+  const host = process.env.POSTHOG_HOST ?? 'https://us.i.posthog.com';
+
+  client = new PostHog(apiKey, { host });
+
+  if (config?.debug) {
+    console.log('[analytics] PostHog initialized');
+  }
+
+  return true;
+}
+
+export function trackEvent(
+  event: string,
+  properties?: EventProperties,
+  userId?: string,
+): void {
+  if (!client) return;
+
+  client.capture({
+    distinctId: userId ?? 'anonymous',
+    event,
+    properties,
+  });
+}
+
+export function identifyUser(userId: string, properties?: UserProperties): void {
+  if (!client) return;
+
+  client.identify({
+    distinctId: userId,
+    properties,
+  });
+}
+
+export function groupIdentify(
+  groupType: string,
+  groupId: string,
+  properties?: UserProperties,
+): void {
+  if (!client) return;
+
+  client.groupIdentify({
+    groupType,
+    groupKey: groupId,
+    properties,
+  });
+}
+
+export async function shutdownAnalytics(): Promise<void> {
+  if (!client) return;
+  await client.shutdown();
+  client = null;
+}
+
+export type { AnalyticsConfig, EventProperties, UserProperties } from './types.js';

package/dist/integrations/analytics/providers/posthog/templates/src/analytics/types.ts.template

@@ -0,0 +1,12 @@
+export interface AnalyticsConfig {
+  apiKey?: string;
+  debug?: boolean;
+}
+
+export interface EventProperties {
+  [key: string]: string | number | boolean | null | undefined;
+}
+
+export interface UserProperties {
+  [key: string]: string | number | boolean | null | undefined;
+}

package/dist/integrations/auth/providers/authjoy/templates/api/src/middleware/auth.ts.template

@@ -0,0 +1,89 @@
+import { FastifyRequest, FastifyReply } from 'fastify';
+
+// Extend FastifyRequest to include user
+declare module 'fastify' {
+  interface FastifyRequest {
+    user?: {
+      id: string;
+      email: string;
+      name?: string;
+      [key: string]: unknown;
+    };
+  }
+}
+
+const AUTHJOY_API_URL = process.env.AUTHJOY_API_URL || 'https://api.authjoy.io';
+
+/**
+ * Verify a token with AuthJoy
+ */
+async function verifyToken(token: string): Promise<Record<string, unknown> | null> {
+  try {
+    const response = await fetch(`${AUTHJOY_API_URL}/v1/verify`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    return await response.json() as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Require authentication - returns 401 if not authenticated
+ */
+export async function requireAuth(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<void> {
+  const token = request.headers.authorization?.replace('Bearer ', '');
+
+  if (!token) {
+    reply.status(401).send({ error: 'Unauthorized', message: 'No token provided' });
+    return;
+  }
+
+  const user = await verifyToken(token);
+
+  if (!user) {
+    reply.status(401).send({ error: 'Unauthorized', message: 'Invalid token' });
+    return;
+  }
+
+  request.user = user as FastifyRequest['user'];
+}
+
+/**
+ * Optional authentication - attaches user if token is valid, continues otherwise
+ */
+export async function optionalAuth(
+  request: FastifyRequest,
+  _reply: FastifyReply
+): Promise<void> {
+  const token = request.headers.authorization?.replace('Bearer ', '');
+
+  if (!token) {
+    return;
+  }
+
+  const user = await verifyToken(token);
+
+  if (user) {
+    request.user = user as FastifyRequest['user'];
+  }
+}
+
+/**
+ * Get the current user from request (after auth middleware)
+ */
+export function getCurrentUser(request: FastifyRequest) {
+  return request.user;
+}

package/dist/integrations/auth/providers/authjoy/templates/api/src/routes/auth.ts.template

@@ -0,0 +1,27 @@
+import { FastifyPluginAsync } from 'fastify';
+import { requireAuth, optionalAuth, getCurrentUser } from '../middleware/auth.js';
+
+export const authRoutes: FastifyPluginAsync = async (fastify) => {
+  /**
+   * Get current authenticated user
+   * GET /auth/me
+   */
+  fastify.get('/me', { preHandler: requireAuth }, async (request, reply) => {
+    const user = getCurrentUser(request);
+    return reply.send({ user });
+  });
+
+  /**
+   * Check authentication status
+   * GET /auth/status
+   */
+  fastify.get('/status', { preHandler: optionalAuth }, async (request, reply) => {
+    const user = getCurrentUser(request);
+    return reply.send({
+      authenticated: !!user,
+      user: user || null,
+    });
+  });
+};
+
+export default authRoutes;

package/dist/integrations/auth/providers/authjoy/templates/web/src/components/AuthProvider.tsx.template

@@ -0,0 +1,40 @@
+import { AuthJoyProvider } from '@authjoyio/react';
+import { ReactNode } from 'react';
+
+interface AuthProviderProps {
+  children: ReactNode;
+}
+
+/**
+ * AuthJoy authentication provider wrapper
+ *
+ * Wraps your app with AuthJoy context for authentication state management.
+ *
+ * Required environment variables:
+ * - VITE_AUTHJOY_CLIENT_ID: Your AuthJoy client ID
+ * - VITE_AUTHJOY_DOMAIN: Your AuthJoy domain (e.g., your-app.authjoy.io)
+ */
+export function AuthProvider({ children }: AuthProviderProps) {
+  const clientId = import.meta.env.VITE_AUTHJOY_CLIENT_ID;
+  const domain = import.meta.env.VITE_AUTHJOY_DOMAIN;
+
+  if (!clientId || !domain) {
+    console.warn(
+      'AuthJoy not configured. Set VITE_AUTHJOY_CLIENT_ID and VITE_AUTHJOY_DOMAIN environment variables.'
+    );
+  }
+
+  return (
+    <AuthJoyProvider
+      config={{
+        clientId: clientId || '',
+        domain: domain || '',
+        redirectUri: window.location.origin,
+      }}
+    >
+      {children}
+    </AuthJoyProvider>
+  );
+}
+
+export default AuthProvider;

package/dist/integrations/auth/providers/authjoy/templates/web/src/hooks/use-auth.ts.template

@@ -0,0 +1,71 @@
+import { useAuthJoy } from '@authjoyio/react';
+
+/**
+ * Authentication hook for accessing user state and auth actions
+ *
+ * @example
+ * ```tsx
+ * function ProfileButton() {
+ *   const { user, isAuthenticated, login, logout } = useAuth();
+ *
+ *   if (!isAuthenticated) {
+ *     return <button onClick={() => login()}>Sign In</button>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <span>{user?.name}</span>
+ *       <button onClick={() => logout()}>Sign Out</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useAuth() {
+  const authJoy = useAuthJoy();
+
+  return {
+    /**
+     * The authenticated user object, or null if not authenticated
+     */
+    user: authJoy.user,
+
+    /**
+     * Whether authentication state is still loading
+     */
+    isLoading: authJoy.isLoading,
+
+    /**
+     * Whether the user is authenticated
+     */
+    isAuthenticated: authJoy.isAuthenticated,
+
+    /**
+     * Trigger the login flow
+     * @param options Optional login options (e.g., { screen_hint: 'signup' })
+     */
+    login: authJoy.login,
+
+    /**
+     * Log out the current user
+     * @param options Optional logout options (e.g., { returnTo: '/goodbye' })
+     */
+    logout: authJoy.logout,
+
+    /**
+     * Get an access token for API calls
+     * @returns Promise<string> The access token
+     */
+    getToken: authJoy.getToken,
+
+    /**
+     * Check if the user has a specific permission/scope
+     * @param permission The permission to check
+     */
+    hasPermission: (permission: string) => {
+      return authJoy.user?.permissions?.includes(permission) ?? false;
+    },
+  };
+}
+
+export default useAuth;

package/dist/integrations/auth/providers/authjoy/templates/web/src/lib/auth.ts.template

@@ -0,0 +1,59 @@
+/**
+ * AuthJoy configuration and utilities
+ */
+
+export const authConfig = {
+  clientId: import.meta.env.VITE_AUTHJOY_CLIENT_ID || '',
+  domain: import.meta.env.VITE_AUTHJOY_DOMAIN || '',
+  redirectUri: typeof window !== 'undefined' ? window.location.origin : '',
+};
+
+/**
+ * Make an authenticated API request
+ *
+ * @param url The URL to fetch
+ * @param options Fetch options
+ * @param getToken Function to get the current access token
+ * @returns The fetch response
+ *
+ * @example
+ * ```ts
+ * const { getToken } = useAuth();
+ * const response = await authFetch('/api/users', { method: 'GET' }, getToken);
+ * ```
+ */
+export async function authFetch(
+  url: string,
+  options: RequestInit = {},
+  getToken: () => Promise<string>
+): Promise<Response> {
+  const token = await getToken();
+
+  return fetch(url, {
+    ...options,
+    headers: {
+      ...options.headers,
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+  });
+}
+
+/**
+ * Create an authenticated fetch wrapper
+ *
+ * @param getToken Function to get the current access token
+ * @returns A fetch function that automatically adds auth headers
+ *
+ * @example
+ * ```ts
+ * const { getToken } = useAuth();
+ * const api = createAuthFetch(getToken);
+ * const response = await api('/api/users');
+ * ```
+ */
+export function createAuthFetch(getToken: () => Promise<string>) {
+  return async (url: string, options: RequestInit = {}): Promise<Response> => {
+    return authFetch(url, options, getToken);
+  };
+}

package/dist/integrations/auth/providers/authjoy/templates/web/src/pages/account.tsx.template

@@ -0,0 +1,84 @@
+'use client';
+
+import { useAuth } from '../hooks/use-auth';
+import {
+  Card,
+  CardHeader,
+  CardTitle,
+  CardDescription,
+  CardContent,
+} from '@primstack/ui/card';
+import { Avatar, AvatarImage, AvatarFallback } from '@primstack/ui/avatar';
+import { Badge } from '@primstack/ui/badge';
+import { Button } from '@primstack/ui/button';
+import { Separator } from '@primstack/ui/separator';
+import { useEffect } from 'react';
+
+function getInitials(name?: string): string {
+  if (!name) return '?';
+  return name
+    .split(' ')
+    .map((part) => part[0])
+    .join('')
+    .toUpperCase()
+    .slice(0, 2);
+}
+
+export default function AccountPage() {
+  const { user, isAuthenticated, isLoading, logout } = useAuth();
+
+  useEffect(() => {
+    if (!isLoading && !isAuthenticated) {
+      window.location.href = '/login';
+    }
+  }, [isLoading, isAuthenticated]);
+
+  if (isLoading || !isAuthenticated) {
+    return null;
+  }
+
+  return (
+    <div className="flex min-h-screen items-center justify-center p-4">
+      <Card className="w-full max-w-md">
+        <CardHeader className="items-center text-center">
+          <Avatar className="h-20 w-20">
+            <AvatarImage src={user?.picture} alt={user?.name} />
+            <AvatarFallback className="text-lg">
+              {getInitials(user?.name)}
+            </AvatarFallback>
+          </Avatar>
+          <CardTitle className="mt-4">{user?.name}</CardTitle>
+          <CardDescription>{user?.email}</CardDescription>
+          <Badge variant="outline" className="mt-2">
+            Authenticated
+          </Badge>
+        </CardHeader>
+
+        <Separator />
+
+        <CardContent className="space-y-4 pt-6">
+          <div className="space-y-1">
+            <p className="text-sm font-medium text-muted-foreground">Email</p>
+            <p className="text-sm">{user?.email}</p>
+          </div>
+          {user?.name && (
+            <div className="space-y-1">
+              <p className="text-sm font-medium text-muted-foreground">Name</p>
+              <p className="text-sm">{user.name}</p>
+            </div>
+          )}
+
+          <Separator />
+
+          <Button
+            variant="destructive"
+            className="w-full"
+            onClick={() => logout({ returnTo: window.location.origin })}
+          >
+            Sign Out
+          </Button>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

package/dist/integrations/auth/providers/authjoy/templates/web/src/pages/login.tsx.template

@@ -0,0 +1,73 @@
+'use client';
+
+import { useAuth } from '../hooks/use-auth';
+import {
+  Card,
+  CardHeader,
+  CardTitle,
+  CardDescription,
+  CardContent,
+  CardFooter,
+} from '@primstack/ui/card';
+import { Button } from '@primstack/ui/button';
+import { Separator } from '@primstack/ui/separator';
+import { useEffect } from 'react';
+
+export default function LoginPage() {
+  const { login, isAuthenticated, isLoading } = useAuth();
+
+  useEffect(() => {
+    if (isAuthenticated) {
+      window.location.href = '/';
+    }
+  }, [isAuthenticated]);
+
+  if (isLoading || isAuthenticated) {
+    return null;
+  }
+
+  return (
+    <div className="flex min-h-screen items-center justify-center p-4">
+      <Card className="w-full max-w-md">
+        <CardHeader className="text-center">
+          <CardTitle className="text-2xl">Welcome back</CardTitle>
+          <CardDescription>
+            Sign in to your account to continue.
+          </CardDescription>
+        </CardHeader>
+
+        <CardContent className="space-y-4">
+          <Button
+            className="w-full"
+            size="lg"
+            onClick={() => login()}
+          >
+            Sign In
+          </Button>
+
+          <div className="relative">
+            <Separator />
+            <span className="absolute left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2 bg-card px-2 text-xs text-muted-foreground">
+              or
+            </span>
+          </div>
+
+          <Button
+            className="w-full"
+            variant="outline"
+            size="lg"
+            onClick={() => login({ screen_hint: 'signup' })}
+          >
+            Create Account
+          </Button>
+        </CardContent>
+
+        <CardFooter className="justify-center">
+          <p className="text-xs text-muted-foreground">
+            Secured by AuthJoy
+          </p>
+        </CardFooter>
+      </Card>
+    </div>
+  );
+}