create-fedi-app 0.1.0

package/dist/templates/base/lib/nostr/hooks.ts

@@ -0,0 +1,52 @@
+import { useContext, useState } from 'react';
+import { bech32 } from '@scure/base';
+import { NostrContext } from './provider';
+import type { UnsignedNostrEvent, NostrEvent } from '../fedi-types';
+
+function pubkeyToNpub(hex: string): string {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return bech32.encodeFromBytes('npub', bytes);
+}
+
+export function useNostr() {
+  const ctx = useContext(NostrContext);
+  if (ctx === null) {
+    throw new Error('useNostr must be used within a NostrProvider');
+  }
+  const npub = ctx.pubkey ? pubkeyToNpub(ctx.pubkey) : null;
+  return {
+    provider: ctx.provider,
+    pubkey: ctx.pubkey,
+    npub,
+    isLoading: ctx.isLoading,
+    error: ctx.error,
+    isConnected: ctx.provider !== null,
+  };
+}
+
+export function useIdentity() {
+  const { provider, pubkey, npub } = useNostr();
+  const [isConnecting, setIsConnecting] = useState(false);
+
+  const displayNpub = npub ? npub.slice(0, 8) + '...' + npub.slice(-4) : null;
+
+  async function getPublicKey(): Promise<string | null> {
+    if (!provider) return null;
+    return provider.getPublicKey();
+  }
+
+  async function signEvent(event: UnsignedNostrEvent): Promise<NostrEvent | null> {
+    if (!provider) return null;
+    setIsConnecting(true);
+    try {
+      return await provider.signEvent(event);
+    } finally {
+      setIsConnecting(false);
+    }
+  }
+
+  return { pubkey, npub, displayNpub, getPublicKey, signEvent, isConnecting };
+}

package/dist/templates/base/lib/nostr/index.ts

@@ -0,0 +1,9 @@
+export type {
+  NostrEvent,
+  UnsignedNostrEvent,
+  Nip04,
+} from '../fedi-types';
+
+export { NostrContext, NostrProvider } from './provider';
+export { MockNostrProvider } from './mock';
+export { useNostr, useIdentity } from './hooks';

package/dist/templates/base/lib/nostr/mock.ts

@@ -0,0 +1,60 @@
+// WARNING: Test keypair only. NEVER use in production
+import { schnorr } from '@noble/curves/secp256k1.js';
+import { sha256 } from '@noble/hashes/sha256';
+import type { NostrProvider, NostrEvent, UnsignedNostrEvent, Nip04 } from '../fedi-types';
+
+function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+// Lowest valid secp256k1 private key, famous test vector, NOT for production
+const TEST_PRIVKEY = new Uint8Array(32);
+TEST_PRIVKEY[31] = 1;
+
+const TEST_PUBKEY_BYTES = schnorr.getPublicKey(TEST_PRIVKEY);
+const TEST_PUBKEY_HEX = bytesToHex(TEST_PUBKEY_BYTES);
+
+export class MockNostrProvider implements NostrProvider {
+  readonly nip04: Nip04 = {
+    async encrypt(_pubkey: string, plaintext: string): Promise<string> {
+      return Buffer.from(plaintext).toString('base64') + '?iv=fakefakefakefake';
+    },
+    async decrypt(_pubkey: string, ciphertext: string): Promise<string> {
+      const [b64] = ciphertext.split('?iv=');
+      return Buffer.from(b64, 'base64').toString('utf-8');
+    },
+  };
+
+  async getPublicKey(): Promise<string> {
+    return TEST_PUBKEY_HEX;
+  }
+
+  async signEvent(event: UnsignedNostrEvent): Promise<NostrEvent> {
+    const serialized = JSON.stringify([
+      0,
+      TEST_PUBKEY_HEX,
+      event.created_at,
+      event.kind,
+      event.tags,
+      event.content,
+    ]);
+    const idBytes = sha256(new TextEncoder().encode(serialized));
+    const idHex = bytesToHex(idBytes);
+    const sigBytes = schnorr.sign(idBytes, TEST_PRIVKEY);
+    return {
+      ...event,
+      pubkey: TEST_PUBKEY_HEX,
+      id: idHex,
+      sig: bytesToHex(sigBytes),
+    };
+  }
+
+  async getRelays(): Promise<Record<string, { read: boolean; write: boolean }>> {
+    return {
+      'wss://relay.damus.io': { read: true, write: true },
+      'wss://nos.lol': { read: true, write: false },
+    };
+  }
+}

package/dist/templates/base/lib/nostr/provider.tsx

@@ -0,0 +1,64 @@
+import { createContext, useEffect, useState, type ReactNode } from 'react';
+import type { NostrProvider as NostrProviderInterface } from '../fedi-types';
+
+interface NostrContextValue {
+  provider: NostrProviderInterface | null;
+  pubkey: string | null;
+  isLoading: boolean;
+  error: Error | null;
+}
+
+export const NostrContext = createContext<NostrContextValue | null>(null);
+
+interface NostrProviderProps {
+  children: ReactNode;
+  mockProvider?: NostrProviderInterface;
+}
+
+export function NostrProvider({ children, mockProvider }: NostrProviderProps) {
+  const [provider, setProvider] = useState<NostrProviderInterface | null>(null);
+  const [pubkey, setPubkey] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function init() {
+      let activeProvider: NostrProviderInterface | null = null;
+
+      if (typeof window !== 'undefined' && window.nostr) {
+        activeProvider = window.nostr;
+      } else if (mockProvider !== undefined && process.env.NODE_ENV === 'development') {
+        activeProvider = mockProvider;
+      }
+
+      if (activeProvider) {
+        try {
+          const pk = await activeProvider.getPublicKey();
+          if (!cancelled) {
+            setProvider(activeProvider);
+            setPubkey(pk);
+          }
+        } catch (err) {
+          if (!cancelled) {
+            setError(err instanceof Error ? err : new Error('Failed to connect Nostr'));
+          }
+        }
+      }
+
+      if (!cancelled) setIsLoading(false);
+    }
+
+    init();
+    return () => {
+      cancelled = true;
+    };
+  }, [mockProvider]);
+
+  return (
+    <NostrContext.Provider value={{ provider, pubkey, isLoading, error }}>
+      {children}
+    </NostrContext.Provider>
+  );
+}

package/dist/templates/base/lib/utils.ts

@@ -0,0 +1,3 @@
+import { clsx, type ClassValue } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs: ClassValue[]) { return twMerge(clsx(inputs)); }

package/dist/templates/base/lib/webln/hooks.ts

@@ -0,0 +1,67 @@
+import { useContext, useState } from 'react';
+import { WebLNContext } from './provider';
+import type { RequestInvoiceArgs } from '../fedi-types';
+
+export function useWebLN() {
+  const ctx = useContext(WebLNContext);
+  if (ctx === null) {
+    throw new Error('useWebLN must be used within a WebLNProvider');
+  }
+  return {
+    provider: ctx.provider,
+    isLoading: ctx.isLoading,
+    error: ctx.error,
+    isConnected: ctx.provider !== null,
+  };
+}
+
+export function usePayment() {
+  const { provider } = useWebLN();
+  const [isPaying, setIsPaying] = useState(false);
+  const [isCreatingInvoice, setIsCreatingInvoice] = useState(false);
+  const [paymentError, setPaymentError] = useState<Error | null>(null);
+  const [lastPreimage, setLastPreimage] = useState<string | null>(null);
+  const [lastInvoice, setLastInvoice] = useState<string | null>(null);
+
+  async function sendPayment(paymentRequest: string) {
+    if (!provider) return null;
+    setIsPaying(true);
+    setPaymentError(null);
+    try {
+      const result = await provider.sendPayment(paymentRequest);
+      setLastPreimage(result.preimage);
+      return result;
+    } catch (err) {
+      setPaymentError(err instanceof Error ? err : new Error('Payment failed'));
+      return null;
+    } finally {
+      setIsPaying(false);
+    }
+  }
+
+  async function makeInvoice(args: RequestInvoiceArgs | string | number) {
+    if (!provider) return null;
+    setIsCreatingInvoice(true);
+    setPaymentError(null);
+    try {
+      const result = await provider.makeInvoice(args);
+      setLastInvoice(result.paymentRequest);
+      return result;
+    } catch (err) {
+      setPaymentError(err instanceof Error ? err : new Error('Failed to create invoice'));
+      return null;
+    } finally {
+      setIsCreatingInvoice(false);
+    }
+  }
+
+  return {
+    sendPayment,
+    makeInvoice,
+    isPaying,
+    isCreatingInvoice,
+    paymentError,
+    lastPreimage,
+    lastInvoice,
+  };
+}

package/dist/templates/base/lib/webln/index.ts

@@ -0,0 +1,12 @@
+export type {
+  RequestInvoiceArgs,
+  RequestInvoiceResponse,
+  SendPaymentResponse,
+  KeysendArgs,
+  SignMessageResponse,
+  GetInfoResponse,
+} from '../fedi-types';
+
+export { WebLNContext, WebLNProvider } from './provider';
+export { MockWebLNProvider } from './mock';
+export { useWebLN, usePayment } from './hooks';

package/dist/templates/base/lib/webln/mock.ts

@@ -0,0 +1,96 @@
+import type {
+  WebLNProvider,
+  GetInfoResponse,
+  RequestInvoiceArgs,
+  RequestInvoiceResponse,
+  SendPaymentResponse,
+  KeysendArgs,
+  SignMessageResponse,
+} from '../fedi-types';
+
+function randomHex(bytes: number): string {
+  let result = '';
+  for (let i = 0; i < bytes * 2; i++) {
+    result += Math.floor(Math.random() * 16).toString(16);
+  }
+  return result;
+}
+
+function randomAlphanumeric(length: number): string {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return result;
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+interface MockWebLNOptions {
+  paymentDelay?: number;
+  shouldFail?: boolean;
+  failureMessage?: string;
+  autoEnable?: boolean;
+}
+
+export class MockWebLNProvider implements WebLNProvider {
+  private readonly paymentDelay: number;
+  private readonly shouldFail: boolean;
+  private readonly failureMessage: string;
+
+  constructor({
+    paymentDelay = 600,
+    shouldFail = false,
+    failureMessage,
+    autoEnable: _autoEnable = true,
+  }: MockWebLNOptions = {}) {
+    this.paymentDelay = paymentDelay;
+    this.shouldFail = shouldFail;
+    this.failureMessage = failureMessage ?? 'Payment failed';
+  }
+
+  async enable(): Promise<void> {
+    if (this.shouldFail) throw new Error(this.failureMessage);
+  }
+
+  async getInfo(): Promise<GetInfoResponse> {
+    return {
+      node: {
+        alias: 'Fedi Dev Node',
+        pubkey: '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+        color: '#FF6B35',
+      },
+      methods: ['sendPayment', 'makeInvoice', 'getInfo', 'signMessage'],
+    };
+  }
+
+  async makeInvoice(args: RequestInvoiceArgs | string | number): Promise<RequestInvoiceResponse> {
+    const amount = typeof args === 'object' ? (args.amount ?? args.defaultAmount ?? 0) : args;
+    await delay(this.paymentDelay);
+    return {
+      paymentRequest: `lnbc${amount}n1p${randomAlphanumeric(100)}`,
+    };
+  }
+
+  async sendPayment(paymentRequest: string): Promise<SendPaymentResponse> {
+    if (!paymentRequest.startsWith('lnbc')) {
+      throw new Error('Invalid payment request: must start with lnbc');
+    }
+    if (this.shouldFail) throw new Error(this.failureMessage);
+    await delay(this.paymentDelay);
+    return { preimage: randomHex(32) };
+  }
+
+  async signMessage(message: string): Promise<SignMessageResponse> {
+    return { message, signature: randomHex(64) };
+  }
+
+  async verifyMessage(): Promise<void> {}
+
+  async sendKeysend(_args: KeysendArgs): Promise<SendPaymentResponse> {
+    return { preimage: randomHex(32) };
+  }
+}

package/dist/templates/base/lib/webln/provider.tsx

@@ -0,0 +1,52 @@
+import { createContext, useEffect, useState, type ReactNode } from 'react';
+import type { WebLNProvider as WebLNProviderInterface } from '../fedi-types';
+
+interface WebLNContextValue {
+  provider: WebLNProviderInterface | null;
+  isLoading: boolean;
+  error: Error | null;
+}
+
+export const WebLNContext = createContext<WebLNContextValue | null>(null);
+
+interface WebLNProviderProps {
+  children: ReactNode;
+  mockProvider?: WebLNProviderInterface;
+}
+
+export function WebLNProvider({ children, mockProvider }: WebLNProviderProps) {
+  const [provider, setProvider] = useState<WebLNProviderInterface | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function init() {
+      if (typeof window !== 'undefined' && window.webln) {
+        try {
+          await window.webln.enable();
+          if (!cancelled) setProvider(window.webln);
+        } catch (err) {
+          if (!cancelled) {
+            setError(err instanceof Error ? err : new Error('Failed to enable WebLN'));
+          }
+        }
+      } else if (mockProvider !== undefined && process.env.NODE_ENV !== 'production') {
+        if (!cancelled) setProvider(mockProvider);
+      }
+      if (!cancelled) setIsLoading(false);
+    }
+
+    init();
+    return () => {
+      cancelled = true;
+    };
+  }, [mockProvider]);
+
+  return (
+    <WebLNContext.Provider value={{ provider, isLoading, error }}>
+      {children}
+    </WebLNContext.Provider>
+  );
+}

package/dist/templates/base/next.config.ts

@@ -0,0 +1,3 @@
+import type { NextConfig } from 'next';
+const config: NextConfig = {};
+export default config;

package/dist/templates/base/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev --turbopack",
+    "build": "next build",
+    "start": "next start",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:e2e": "playwright test"
+  },
+  "dependencies": {
+    "next": "^16.2.6",
+    "react": "^19",
+    "react-dom": "^19",
+    "@noble/curves": "^2.2.0",
+    "@noble/hashes": "^1.7.1",
+    "@scure/base": "^2.2.0",
+    "@t3-oss/env-nextjs": "^0.12",
+    "zod": "^3",
+    "clsx": "^2",
+    "tailwind-merge": "^2",
+    "qrcode.react": "^4"
+  },
+  "devDependencies": {
+    "typescript": "^5",
+    "@types/react": "^19",
+    "@types/node": "^22",
+    "tailwindcss": "^4",
+    "@tailwindcss/typography": "^0.5",
+    "vitest": "^2",
+    "jsdom": "^26",
+    "@testing-library/react": "^16",
+    "@testing-library/jest-dom": "^6",
+    "@testing-library/user-event": "^14",
+    "@vitejs/plugin-react": "^4",
+    "@playwright/test": "^1.45"
+  }
+}

package/dist/templates/base/proxy.ts

@@ -0,0 +1,8 @@
+import { NextRequest, NextResponse } from 'next/server';
+export default function proxy(request: NextRequest) {
+  // Base: pass-through. payment-gated-content module extends this.
+  return NextResponse.next();
+}
+export const config = {
+  matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
+};

package/dist/templates/base/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "ESNext",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }]
+  },
+  "include": ["**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/dist/templates/base/vitest.config.ts

@@ -0,0 +1,6 @@
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+export default defineConfig({
+  plugins: [react()],
+  test: { environment: 'jsdom', globals: true, setupFiles: ['./vitest.setup.ts'] },
+});

package/dist/templates/base/vitest.setup.ts

@@ -0,0 +1,40 @@
+import '@testing-library/jest-dom';
+
+/** Node's experimental localStorage lacks Storage methods. Use an in-memory store in tests. */
+class MemoryStorage implements Storage {
+  private store = new Map<string, string>();
+
+  get length(): number {
+    return this.store.size;
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+
+  getItem(key: string): string | null {
+    return this.store.get(key) ?? null;
+  }
+
+  key(index: number): string | null {
+    return [...this.store.keys()][index] ?? null;
+  }
+
+  removeItem(key: string): void {
+    this.store.delete(key);
+  }
+
+  setItem(key: string, value: string): void {
+    this.store.set(key, value);
+  }
+}
+
+if (typeof window !== 'undefined') {
+  const storage = window.localStorage;
+  if (!storage || typeof storage.setItem !== 'function') {
+    Object.defineProperty(window, 'localStorage', {
+      value: new MemoryStorage(),
+      writable: true,
+    });
+  }
+}

package/dist/templates/modules/ai-assistant/app/api/assistant/route.ts

@@ -0,0 +1,45 @@
+import { convertToModelMessages, streamText, type UIMessage } from 'ai';
+import { getLanguageModel } from '../../../lib/ai/providers';
+
+export const maxDuration = 60;
+
+const DEFAULT_SYSTEM_PROMPT =
+  'You are a helpful assistant inside a Fedi Mini App. Keep answers concise and practical.';
+
+type TAssistantRequestBody = {
+  messages?: UIMessage[];
+  systemPrompt?: string;
+};
+
+/**
+ * Streaming AI assistant endpoint. No payment gating, available to all users.
+ */
+export async function POST(request: Request) {
+  let body: TAssistantRequestBody;
+
+  try {
+    body = (await request.json()) as TAssistantRequestBody;
+  } catch {
+    return new Response('Invalid JSON body', { status: 400 });
+  }
+
+  const messages = body.messages;
+  if (!messages || !Array.isArray(messages) || messages.length === 0) {
+    return new Response('messages array is required', { status: 400 });
+  }
+
+  const system = body.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
+
+  try {
+    const result = streamText({
+      model: getLanguageModel(),
+      messages: await convertToModelMessages(messages),
+      system,
+    });
+
+    return result.toUIMessageStreamResponse();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'AI request failed';
+    return new Response(message, { status: 500 });
+  }
+}

package/dist/templates/modules/ai-assistant/app/demo/assistant/AssistantDemoClient.tsx

@@ -0,0 +1,70 @@
+'use client';
+
+import Link from 'next/link';
+import { useState } from 'react';
+import { Assistant } from '../../../components/ai/Assistant';
+import { AssistantProvider } from '../../../components/ai/AssistantProvider';
+
+const DEFAULT_SYSTEM_PROMPT =
+  'You are a helpful assistant inside a Fedi Mini App. Keep answers concise and practical.';
+
+export function AssistantDemoClient() {
+  const [systemPrompt, setSystemPrompt] = useState(DEFAULT_SYSTEM_PROMPT);
+
+  return (
+    <div className="min-h-dvh bg-[var(--color-bg)] font-[family-name:var(--font-body)] text-[var(--color-text)]">
+      <div
+        className="mx-auto w-full max-w-[390px] px-4 pt-6"
+        style={{ paddingBottom: 'max(5rem, env(safe-area-inset-bottom, 20px))' }}
+      >
+        <Link
+          href="/demo"
+          className="mb-6 inline-block text-xs text-[var(--color-text-muted)] transition-opacity duration-200 ease-[cubic-bezier(0.25,1,0.5,1)] hover:opacity-80"
+        >
+          ← back
+        </Link>
+
+        <header className="mb-8 space-y-2">
+          <h1 className="font-[family-name:var(--font-display)] text-2xl font-bold leading-tight text-[var(--color-text)]">
+            AI assistant
+          </h1>
+          <p className="max-w-[75ch] text-sm leading-[1.65] text-[var(--color-text-muted)]">
+            Free chat powered by the Vercel AI SDK. Configure the system prompt below. It is sent
+            with every request to <code className="font-mono text-xs">/api/assistant</code> via{' '}
+            <code className="font-mono text-xs">streamText()</code>.
+          </p>
+        </header>
+
+        <div className="mb-6 space-y-2">
+          <label
+            htmlFor="system-prompt"
+            className="block text-xs font-semibold text-[var(--color-text-muted)]"
+          >
+            System prompt
+          </label>
+          <textarea
+            id="system-prompt"
+            value={systemPrompt}
+            onChange={(event) => setSystemPrompt(event.target.value)}
+            rows={4}
+            className="w-full resize-y rounded-lg px-3 py-2.5 font-mono text-xs leading-[1.65] outline-none"
+            style={{
+              background: 'var(--color-surface-2)',
+              color: 'var(--color-text)',
+              border: '1px solid var(--color-border)',
+              borderRadius: 'var(--radius-md)',
+            }}
+          />
+          <p className="text-xs leading-[1.65] text-[var(--color-text-subtle)]">
+            Changing the prompt starts a fresh context on the next message. Clear the chat if you
+            want a clean thread.
+          </p>
+        </div>
+
+        <AssistantProvider systemPrompt={systemPrompt}>
+          <Assistant />
+        </AssistantProvider>
+      </div>
+    </div>
+  );
+}