Add first-time artist setup flow for album + publisher feeds

api/_utils/authUtils.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { userBlobPath, userBlobPrefix, buildStoredKeyRecord } from './authUtils';
+
+const GOOGLE_ID = '110248495921238986420';
+
+describe('userBlobPath / userBlobPrefix', () => {
+  it('userBlobPath is the full .json object name used for put()', () => {
+    const path = userBlobPath(GOOGLE_ID);
+    expect(path.startsWith('auth/users/')).toBe(true);
+    expect(path.endsWith('.json')).toBe(true);
+  });
+
+  it('userBlobPrefix has no extension so it matches addRandomSuffix output on list()', () => {
+    const prefix = userBlobPrefix(GOOGLE_ID);
+    expect(prefix.startsWith('auth/users/')).toBe(true);
+    expect(prefix.endsWith('.json')).toBe(false);
+  });
+
+  it('the prefix is a prefix of the deterministic path', () => {
+    expect(userBlobPath(GOOGLE_ID).startsWith(userBlobPrefix(GOOGLE_ID))).toBe(true);
+  });
+
+  it('the prefix matches a random-suffixed blob name (the list() lookup invariant)', () => {
+    // Vercel Blob addRandomSuffix inserts `-<random>` before the extension.
+    const prefix = userBlobPrefix(GOOGLE_ID);
+    const suffixed = `${prefix}-aB3xZ9.json`;
+    expect(suffixed.startsWith(prefix)).toBe(true);
+  });
+
+  it('is deterministic for the same id and distinct across ids', () => {
+    expect(userBlobPrefix(GOOGLE_ID)).toBe(userBlobPrefix(GOOGLE_ID));
+    expect(userBlobPrefix(GOOGLE_ID)).not.toBe(userBlobPrefix('999999999999999999999'));
+  });
+});
+
+describe('buildStoredKeyRecord', () => {
+  it('stores only non-PII key material', () => {
+    const record = buildStoredKeyRecord('pubkeyhex', 'encryptednsec', '2026-06-19T00:00:00.000Z');
+    expect(record).toEqual({
+      pubkey: 'pubkeyhex',
+      encryptedNsec: 'encryptednsec',
+      createdAt: '2026-06-19T00:00:00.000Z',
+    });
+  });
+
+  it('never includes PII fields (email / displayName / picture)', () => {
+    const record = buildStoredKeyRecord('pubkeyhex', 'encryptednsec', '2026-06-19T00:00:00.000Z') as Record<string, unknown>;
+    expect(Object.keys(record)).not.toContain('email');
+    expect(Object.keys(record)).not.toContain('displayName');
+    expect(Object.keys(record)).not.toContain('picture');
+  });
+});

api/_utils/authUtils.ts

@@ -0,0 +1,136 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+import type { VercelRequest } from '@vercel/node';
+
+async function deriveEncryptionKey(userId: string): Promise<CryptoKey> {
+  const secret = process.env.AUTH_SECRET;
+  if (!secret) throw new Error('AUTH_SECRET is not configured');
+  const enc = new TextEncoder();
+  const keyMaterial = await crypto.subtle.importKey(
+    'raw', enc.encode(secret), 'HKDF', false, ['deriveKey']
+  );
+  return crypto.subtle.deriveKey(
+    {
+      name: 'HKDF',
+      hash: 'SHA-256',
+      salt: enc.encode(userId),
+      info: enc.encode('msp-managed-keypair-v1'),
+    },
+    keyMaterial,
+    { name: 'AES-GCM', length: 256 },
+    false,
+    ['encrypt', 'decrypt']
+  );
+}
+
+export async function encryptNsec(sk: Uint8Array, userId: string): Promise<string> {
+  const key = await deriveEncryptionKey(userId);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const ciphertext = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, sk);
+  const combined = new Uint8Array(12 + ciphertext.byteLength);
+  combined.set(iv, 0);
+  combined.set(new Uint8Array(ciphertext), 12);
+  return Buffer.from(combined).toString('base64');
+}
+
+export async function decryptNsec(encrypted: string, userId: string): Promise<Uint8Array> {
+  const key = await deriveEncryptionKey(userId);
+  const combined = Buffer.from(encrypted, 'base64');
+  const iv = combined.subarray(0, 12);
+  const ciphertext = combined.subarray(12);
+  const plaintext = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, ciphertext);
+  return new Uint8Array(plaintext);
+}
+
+// Unguessable prefix used to list() a user's keypair blob. Has no `.json`
+// extension so it still matches the name produced by put(addRandomSuffix: true),
+// which inserts `-<random>` before the extension.
+export function userBlobPrefix(googleId: string): string {
+  const hash = bytesToHex(sha256(new TextEncoder().encode(googleId)));
+  return `auth/users/${hash}`;
+}
+
+// Deterministic object name passed to put(). With addRandomSuffix the stored
+// name becomes `${userBlobPath}` with `-<random>` inserted before `.json`.
+export function userBlobPath(googleId: string): string {
+  return `${userBlobPrefix(googleId)}.json`;
+}
+
+// The record persisted to Blob. Intentionally excludes PII (email / displayName
+// / picture): those are carried in the signed session JWT and re-fetched fresh
+// from Google on each login, so they must never sit in a public blob.
+export interface StoredKeyRecord {
+  pubkey: string;
+  encryptedNsec: string;
+  createdAt: string;
+}
+
+export function buildStoredKeyRecord(
+  pubkey: string,
+  encryptedNsec: string,
+  createdAt: string
+): StoredKeyRecord {
+  return { pubkey, encryptedNsec, createdAt };
+}
+
+async function hmacKey(secret: string): Promise<CryptoKey> {
+  return crypto.subtle.importKey(
+    'raw',
+    new TextEncoder().encode(secret),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign', 'verify']
+  );
+}
+
+export async function signJwt(payload: Record<string, unknown>, expiresInSeconds = 30 * 86400): Promise<string> {
+  const secret = process.env.AUTH_SECRET;
+  if (!secret) throw new Error('AUTH_SECRET is not configured');
+  const now = Math.floor(Date.now() / 1000);
+  const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' })).toString('base64url');
+  const body = Buffer.from(JSON.stringify({ ...payload, iat: now, exp: now + expiresInSeconds })).toString('base64url');
+  const signingInput = `${header}.${body}`;
+  const key = await hmacKey(secret);
+  const sig = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(signingInput));
+  return `${signingInput}.${Buffer.from(sig).toString('base64url')}`;
+}
+
+export async function verifyJwt(token: string): Promise<Record<string, unknown>> {
+  const secret = process.env.AUTH_SECRET;
+  if (!secret) throw new Error('AUTH_SECRET is not configured');
+  const parts = token.split('.');
+  if (parts.length !== 3) throw new Error('Invalid JWT format');
+  const [header, body, sig] = parts;
+  const signingInput = `${header}.${body}`;
+  const key = await hmacKey(secret);
+  const valid = await crypto.subtle.verify(
+    'HMAC', key,
+    Buffer.from(sig, 'base64url'),
+    new TextEncoder().encode(signingInput)
+  );
+  if (!valid) throw new Error('Invalid JWT signature');
+  const payload = JSON.parse(Buffer.from(body, 'base64url').toString()) as Record<string, unknown>;
+  const exp = typeof payload.exp === 'number' ? payload.exp : 0;
+  if (exp < Math.floor(Date.now() / 1000)) throw new Error('JWT expired');
+  return payload;
+}
+
+export function getSessionToken(req: VercelRequest): string | null {
+  const cookieHeader = req.headers.cookie;
+  if (!cookieHeader) return null;
+  const cookies: Record<string, string> = {};
+  for (const part of cookieHeader.split(';')) {
+    const eqIdx = part.indexOf('=');
+    if (eqIdx < 0) continue;
+    cookies[part.slice(0, eqIdx).trim()] = part.slice(eqIdx + 1).trim();
+  }
+  return cookies['msp-session'] ?? null;
+}
+
+export function sessionCookie(jwt: string, maxAgeSeconds = 30 * 86400): string {
+  return `msp-session=${jwt}; HttpOnly; Secure; SameSite=Lax; Max-Age=${maxAgeSeconds}; Path=/`;
+}
+
+export function clearSessionCookie(): string {
+  return 'msp-session=; HttpOnly; Secure; SameSite=Lax; Max-Age=0; Path=/';
+}

api/_utils/feedUtils.ts

@@ -1,5 +1,4 @@
 // Shared API utilities for hosted feed endpoints
-import type { VercelRequest } from '@vercel/node';
 import { createHash } from 'crypto';
 import { getAuthHeaders } from './podcastIndex.js';
 
@@ -172,16 +171,12 @@ export async function lookupPodcastIndexId(podcastGuid: string): Promise<number
  * Get base URL from request headers
  * Falls back to canonical URL for localhost (PI can't reach local dev servers)
  */
-export function getBaseUrl(req: VercelRequest): string {
-  const host = req.headers['x-forwarded-host'] || req.headers.host || 'localhost';
-
-  // Use canonical URL for localhost since PI can't reach local dev servers
-  if (host.startsWith('localhost') || host.startsWith('127.0.0.1')) {
-    return process.env.CANONICAL_URL || 'https://msp.podtards.com';
-  }
-
-  const proto = req.headers['x-forwarded-proto'] || 'https';
-  return `${proto}://${host}`;
+export function getBaseUrl(): string {
+  // Always use the canonical domain for hosted feed URLs so every feed (album,
+  // video, publisher) is stable regardless of which alias/preview host served the
+  // request. msp.podtards.com is a legacy alias and must never appear in newly
+  // generated feed URLs.
+  return (process.env.CANONICAL_URL || 'https://musicsideproject.com').replace(/\/$/, '');
 }
 
 /**

api/auth/google-callback.ts

@@ -0,0 +1,119 @@
+import type { VercelRequest, VercelResponse } from '@vercel/node';
+import { generateSecretKey, getPublicKey } from 'nostr-tools/pure';
+import { npubEncode } from 'nostr-tools/nip19';
+import { list, put } from '@vercel/blob';
+import { encryptNsec, decryptNsec, userBlobPath, userBlobPrefix, buildStoredKeyRecord, signJwt, sessionCookie } from '../_utils/authUtils.js';
+
+interface GoogleTokenPayload {
+  sub: string;
+  email: string;
+  name?: string;
+  picture?: string;
+}
+
+// Only the non-PII fields are read back; PII lives in the session JWT, not the blob.
+interface StoredKeyData {
+  pubkey: string;
+  encryptedNsec: string;
+}
+
+async function exchangeCodeForUser(
+  code: string,
+  redirectUri: string
+): Promise<GoogleTokenPayload> {
+  const res = await fetch('https://oauth2.googleapis.com/token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      code,
+      client_id: process.env.GOOGLE_CLIENT_ID!,
+      client_secret: process.env.GOOGLE_CLIENT_SECRET!,
+      redirect_uri: redirectUri,
+      grant_type: 'authorization_code',
+    }),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Google token exchange failed: ${text}`);
+  }
+  const data = await res.json() as { id_token?: string };
+  if (!data.id_token) throw new Error('No id_token returned by Google');
+  // Decode payload (trusted — received directly from Google's token endpoint over HTTPS)
+  const [, payloadB64] = data.id_token.split('.');
+  return JSON.parse(Buffer.from(payloadB64, 'base64url').toString()) as GoogleTokenPayload;
+}
+
+export default async function handler(req: VercelRequest, res: VercelResponse) {
+  const { code, state, error } = req.query as Record<string, string>;
+
+  if (error) {
+    return res.redirect(302, `/?auth_error=${encodeURIComponent(error)}`);
+  }
+  if (!code || !state) {
+    return res.redirect(302, '/?auth_error=missing_params');
+  }
+
+  // Validate CSRF state from cookie
+  const cookieHeader = req.headers.cookie ?? '';
+  const cookies: Record<string, string> = {};
+  for (const part of cookieHeader.split(';')) {
+    const eqIdx = part.indexOf('=');
+    if (eqIdx < 0) continue;
+    cookies[part.slice(0, eqIdx).trim()] = part.slice(eqIdx + 1).trim();
+  }
+  if (!cookies['msp-oauth-state'] || cookies['msp-oauth-state'] !== state) {
+    return res.redirect(302, '/?auth_error=csrf_mismatch');
+  }
+
+  try {
+    const proto = (req.headers['x-forwarded-proto'] as string) ?? 'https';
+    const host = req.headers['host'] as string;
+    const redirectUri = `${proto}://${host}/api/auth/google-callback`;
+
+    const { sub: googleId, email, name: displayName, picture } = await exchangeCodeForUser(code, redirectUri);
+
+    const blobPrefix = userBlobPrefix(googleId);
+    let pubkey: string;
+    let sk: Uint8Array | null = null;
+
+    const { blobs } = await list({ prefix: blobPrefix });
+
+    if (blobs.length > 0) {
+      const blobRes = await fetch(blobs[0].url);
+      const stored = await blobRes.json() as StoredKeyData;
+      pubkey = stored.pubkey;
+      sk = await decryptNsec(stored.encryptedNsec, googleId);
+    } else {
+      sk = generateSecretKey();
+      pubkey = getPublicKey(sk);
+      const encryptedNsec = await encryptNsec(sk, googleId);
+      const data = buildStoredKeyRecord(pubkey, encryptedNsec, new Date().toISOString());
+      // Vercel Blob v2 only serves public blobs; addRandomSuffix gives the object
+      // an unguessable name so the keypair can't be fetched from a derived URL.
+      await put(userBlobPath(googleId), JSON.stringify(data), {
+        access: 'public',
+        contentType: 'application/json',
+        addRandomSuffix: true,
+      });
+    }
+
+    const npub = npubEncode(pubkey);
+    const jwt = await signJwt({
+      sub: googleId,
+      email,
+      pubkey,
+      npub,
+      displayName: displayName ?? email,
+      picture: picture ?? null,
+    });
+
+    res.setHeader('Set-Cookie', [
+      sessionCookie(jwt),
+      'msp-oauth-state=; HttpOnly; Secure; SameSite=Lax; Max-Age=0; Path=/',
+    ]);
+    res.redirect(302, '/?auth=success');
+  } catch (err) {
+    console.error('[auth/google-callback]', err);
+    res.redirect(302, '/?auth_error=server_error');
+  }
+}

api/auth/google-start.ts

@@ -0,0 +1,25 @@
+import type { VercelRequest, VercelResponse } from '@vercel/node';
+
+export default async function handler(req: VercelRequest, res: VercelResponse) {
+  const clientId = process.env.GOOGLE_CLIENT_ID;
+  if (!clientId) {
+    return res.status(503).send('Google sign-in is not configured');
+  }
+
+  const state = crypto.randomUUID();
+  const proto = (req.headers['x-forwarded-proto'] as string) ?? 'https';
+  const host = req.headers['host'] as string;
+  const redirectUri = `${proto}://${host}/api/auth/google-callback`;
+
+  const params = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    response_type: 'code',
+    scope: 'openid email profile',
+    state,
+    prompt: 'select_account',
+  });
+
+  res.setHeader('Set-Cookie', `msp-oauth-state=${state}; HttpOnly; Secure; SameSite=Lax; Max-Age=600; Path=/`);
+  res.redirect(302, `https://accounts.google.com/o/oauth2/v2/auth?${params}`);
+}