Monorepo for wisp.place. A static site hosting service built on top of the AT Protocol.
wisp.place
nekomimi.pet
1import { NodeOAuthClient, type ClientMetadata } from "@atproto/oauth-client-node";
2import { SQL } from "bun";
3import { JoseKey } from "@atproto/jwk-jose";
4import { BASE_HOST } from "./constants";
5
6export const db = new SQL(
7 process.env.NODE_ENV === 'production'
8 ? process.env.DATABASE_URL || (() => {
9 throw new Error('DATABASE_URL environment variable is required in production');
10 })()
11 : process.env.DATABASE_URL || "postgres://postgres:postgres@localhost:5432/wisp"
12);
13
14await db`
15 CREATE TABLE IF NOT EXISTS oauth_states (
16 key TEXT PRIMARY KEY,
17 data TEXT NOT NULL,
18 created_at BIGINT DEFAULT EXTRACT(EPOCH FROM NOW())
19 )
20`;
21
22await db`
23 CREATE TABLE IF NOT EXISTS oauth_sessions (
24 sub TEXT PRIMARY KEY,
25 data TEXT NOT NULL,
26 updated_at BIGINT DEFAULT EXTRACT(EPOCH FROM NOW()),
27 expires_at BIGINT NOT NULL DEFAULT EXTRACT(EPOCH FROM NOW()) + 2592000
28 )
29`;
30
31await db`
32 CREATE TABLE IF NOT EXISTS oauth_keys (
33 kid TEXT PRIMARY KEY,
34 jwk TEXT NOT NULL,
35 created_at BIGINT DEFAULT EXTRACT(EPOCH FROM NOW())
36 )
37`;
38
39// Domains table maps subdomain -> DID
40await db`
41 CREATE TABLE IF NOT EXISTS domains (
42 domain TEXT PRIMARY KEY,
43 did TEXT UNIQUE NOT NULL,
44 rkey TEXT,
45 created_at BIGINT DEFAULT EXTRACT(EPOCH FROM NOW())
46 )
47`;
48
49// Add columns if they don't exist (for existing databases)
50try {
51 await db`ALTER TABLE domains ADD COLUMN IF NOT EXISTS rkey TEXT`;
52} catch (err) {
53 // Column might already exist, ignore
54}
55
56try {
57 await db`ALTER TABLE oauth_sessions ADD COLUMN IF NOT EXISTS expires_at BIGINT NOT NULL DEFAULT EXTRACT(EPOCH FROM NOW()) + 2592000`;
58} catch (err) {
59 // Column might already exist, ignore
60}
61
62try {
63 await db`ALTER TABLE oauth_keys ADD COLUMN IF NOT EXISTS created_at BIGINT DEFAULT EXTRACT(EPOCH FROM NOW())`;
64} catch (err) {
65 // Column might already exist, ignore
66}
67
68try {
69 await db`ALTER TABLE oauth_states ADD COLUMN IF NOT EXISTS expires_at BIGINT DEFAULT EXTRACT(EPOCH FROM NOW()) + 3600`;
70} catch (err) {
71 // Column might already exist, ignore
72}
73
74// Custom domains table for BYOD (bring your own domain)
75await db`
76 CREATE TABLE IF NOT EXISTS custom_domains (
77 id TEXT PRIMARY KEY,
78 domain TEXT UNIQUE NOT NULL,
79 did TEXT NOT NULL,
80 rkey TEXT,
81 verified BOOLEAN DEFAULT false,
82 last_verified_at BIGINT,
83 created_at BIGINT DEFAULT EXTRACT(EPOCH FROM NOW())
84 )
85`;
86
87// Migrate existing tables to make rkey nullable and remove default
88try {
89 await db`ALTER TABLE custom_domains ALTER COLUMN rkey DROP NOT NULL`;
90} catch (err) {
91 // Column might already be nullable, ignore
92}
93try {
94 await db`ALTER TABLE custom_domains ALTER COLUMN rkey DROP DEFAULT`;
95} catch (err) {
96 // Default might already be removed, ignore
97}
98
99// Sites table - cache of place.wisp.fs records from PDS
100await db`
101 CREATE TABLE IF NOT EXISTS sites (
102 did TEXT NOT NULL,
103 rkey TEXT NOT NULL,
104 display_name TEXT,
105 created_at BIGINT DEFAULT EXTRACT(EPOCH FROM NOW()),
106 updated_at BIGINT DEFAULT EXTRACT(EPOCH FROM NOW()),
107 PRIMARY KEY (did, rkey)
108 )
109`;
110
111const RESERVED_HANDLES = new Set([
112 "www",
113 "api",
114 "admin",
115 "static",
116 "public",
117 "preview"
118]);
119
120export const isValidHandle = (handle: string): boolean => {
121 const h = handle.trim().toLowerCase();
122 if (h.length < 3 || h.length > 63) return false;
123 if (!/^[a-z0-9-]+$/.test(h)) return false;
124 if (h.startsWith('-') || h.endsWith('-')) return false;
125 if (h.includes('--')) return false;
126 if (RESERVED_HANDLES.has(h)) return false;
127 return true;
128};
129
130export const toDomain = (handle: string): string => `${handle.toLowerCase()}.${BASE_HOST}`;
131
132export const getDomainByDid = async (did: string): Promise<string | null> => {
133 const rows = await db`SELECT domain FROM domains WHERE did = ${did}`;
134 return rows[0]?.domain ?? null;
135};
136
137export const getWispDomainInfo = async (did: string) => {
138 const rows = await db`SELECT domain, rkey FROM domains WHERE did = ${did}`;
139 return rows[0] ?? null;
140};
141
142export const getDidByDomain = async (domain: string): Promise<string | null> => {
143 const rows = await db`SELECT did FROM domains WHERE domain = ${domain.toLowerCase()}`;
144 return rows[0]?.did ?? null;
145};
146
147export const isDomainAvailable = async (handle: string): Promise<boolean> => {
148 const h = handle.trim().toLowerCase();
149 if (!isValidHandle(h)) return false;
150 const domain = toDomain(h);
151 const rows = await db`SELECT 1 FROM domains WHERE domain = ${domain} LIMIT 1`;
152 return rows.length === 0;
153};
154
155export const isDomainRegistered = async (domain: string) => {
156 const domainLower = domain.toLowerCase().trim();
157
158 // Check wisp.place subdomains
159 const wispDomain = await db`
160 SELECT did, domain, rkey FROM domains WHERE domain = ${domainLower}
161 `;
162
163 if (wispDomain.length > 0) {
164 return {
165 registered: true,
166 type: 'wisp' as const,
167 domain: wispDomain[0].domain,
168 did: wispDomain[0].did,
169 rkey: wispDomain[0].rkey
170 };
171 }
172
173 // Check custom domains
174 const customDomain = await db`
175 SELECT id, domain, did, rkey, verified FROM custom_domains WHERE domain = ${domainLower}
176 `;
177
178 if (customDomain.length > 0) {
179 return {
180 registered: true,
181 type: 'custom' as const,
182 domain: customDomain[0].domain,
183 did: customDomain[0].did,
184 rkey: customDomain[0].rkey,
185 verified: customDomain[0].verified
186 };
187 }
188
189 return { registered: false };
190};
191
192export const claimDomain = async (did: string, handle: string): Promise<string> => {
193 const h = handle.trim().toLowerCase();
194 if (!isValidHandle(h)) throw new Error('invalid_handle');
195 const domain = toDomain(h);
196 try {
197 await db`
198 INSERT INTO domains (domain, did)
199 VALUES (${domain}, ${did})
200 `;
201 } catch (err) {
202 // Unique constraint violations -> already taken or DID already claimed
203 throw new Error('conflict');
204 }
205 return domain;
206};
207
208export const updateDomain = async (did: string, handle: string): Promise<string> => {
209 const h = handle.trim().toLowerCase();
210 if (!isValidHandle(h)) throw new Error('invalid_handle');
211 const domain = toDomain(h);
212 try {
213 const rows = await db`
214 UPDATE domains SET domain = ${domain}
215 WHERE did = ${did}
216 RETURNING domain
217 `;
218 if (rows.length > 0) return rows[0].domain as string;
219 // No existing row, behave like claim
220 return await claimDomain(did, handle);
221 } catch (err) {
222 // Unique constraint violations -> already taken by someone else
223 throw new Error('conflict');
224 }
225};
226
227export const updateWispDomainSite = async (did: string, siteRkey: string | null): Promise<void> => {
228 await db`
229 UPDATE domains
230 SET rkey = ${siteRkey}
231 WHERE did = ${did}
232 `;
233};
234
235export const getWispDomainSite = async (did: string): Promise<string | null> => {
236 const rows = await db`SELECT rkey FROM domains WHERE did = ${did}`;
237 return rows[0]?.rkey ?? null;
238};
239
240// Session timeout configuration (30 days in seconds)
241const SESSION_TIMEOUT = 30 * 24 * 60 * 60; // 2592000 seconds
242// OAuth state timeout (1 hour in seconds)
243const STATE_TIMEOUT = 60 * 60; // 3600 seconds
244
245const stateStore = {
246 async set(key: string, data: any) {
247 console.debug('[stateStore] set', key)
248 const expiresAt = Math.floor(Date.now() / 1000) + STATE_TIMEOUT;
249 await db`
250 INSERT INTO oauth_states (key, data, created_at, expires_at)
251 VALUES (${key}, ${JSON.stringify(data)}, EXTRACT(EPOCH FROM NOW()), ${expiresAt})
252 ON CONFLICT (key) DO UPDATE SET data = EXCLUDED.data, expires_at = ${expiresAt}
253 `;
254 },
255 async get(key: string) {
256 console.debug('[stateStore] get', key)
257 const now = Math.floor(Date.now() / 1000);
258 const result = await db`
259 SELECT data, expires_at
260 FROM oauth_states
261 WHERE key = ${key}
262 `;
263 if (!result[0]) return undefined;
264
265 // Check if expired
266 const expiresAt = Number(result[0].expires_at);
267 if (expiresAt && now > expiresAt) {
268 console.debug('[stateStore] State expired, deleting', key);
269 await db`DELETE FROM oauth_states WHERE key = ${key}`;
270 return undefined;
271 }
272
273 return JSON.parse(result[0].data);
274 },
275 async del(key: string) {
276 console.debug('[stateStore] del', key)
277 await db`DELETE FROM oauth_states WHERE key = ${key}`;
278 }
279};
280
281const sessionStore = {
282 async set(sub: string, data: any) {
283 console.debug('[sessionStore] set', sub)
284 const expiresAt = Math.floor(Date.now() / 1000) + SESSION_TIMEOUT;
285 await db`
286 INSERT INTO oauth_sessions (sub, data, updated_at, expires_at)
287 VALUES (${sub}, ${JSON.stringify(data)}, EXTRACT(EPOCH FROM NOW()), ${expiresAt})
288 ON CONFLICT (sub) DO UPDATE SET
289 data = EXCLUDED.data,
290 updated_at = EXTRACT(EPOCH FROM NOW()),
291 expires_at = ${expiresAt}
292 `;
293 },
294 async get(sub: string) {
295 console.debug('[sessionStore] get', sub)
296 const now = Math.floor(Date.now() / 1000);
297 const result = await db`
298 SELECT data, expires_at
299 FROM oauth_sessions
300 WHERE sub = ${sub}
301 `;
302 if (!result[0]) return undefined;
303
304 // Check if expired
305 const expiresAt = Number(result[0].expires_at);
306 if (expiresAt && now > expiresAt) {
307 console.log('[sessionStore] Session expired, deleting', sub);
308 await db`DELETE FROM oauth_sessions WHERE sub = ${sub}`;
309 return undefined;
310 }
311
312 return JSON.parse(result[0].data);
313 },
314 async del(sub: string) {
315 console.debug('[sessionStore] del', sub)
316 await db`DELETE FROM oauth_sessions WHERE sub = ${sub}`;
317 }
318};
319
320export { sessionStore };
321
322// Cleanup expired sessions and states
323export const cleanupExpiredSessions = async () => {
324 const now = Math.floor(Date.now() / 1000);
325 try {
326 const sessionsDeleted = await db`
327 DELETE FROM oauth_sessions WHERE expires_at < ${now}
328 `;
329 const statesDeleted = await db`
330 DELETE FROM oauth_states WHERE expires_at IS NOT NULL AND expires_at < ${now}
331 `;
332 console.log(`[Cleanup] Deleted ${sessionsDeleted.length} expired sessions and ${statesDeleted.length} expired states`);
333 return { sessions: sessionsDeleted.length, states: statesDeleted.length };
334 } catch (err) {
335 console.error('[Cleanup] Failed to cleanup expired data:', err);
336 return { sessions: 0, states: 0 };
337 }
338};
339
340export const createClientMetadata = (config: { domain: `https://${string}`, clientName: string }): ClientMetadata => ({
341 client_id: `${config.domain}/client-metadata.json`,
342 client_name: config.clientName,
343 client_uri: config.domain,
344 logo_uri: `${config.domain}/logo.png`,
345 tos_uri: `${config.domain}/tos`,
346 policy_uri: `${config.domain}/policy`,
347 redirect_uris: [`${config.domain}/api/auth/callback`],
348 grant_types: ['authorization_code', 'refresh_token'],
349 response_types: ['code'],
350 application_type: 'web',
351 token_endpoint_auth_method: 'private_key_jwt',
352 token_endpoint_auth_signing_alg: "ES256",
353 scope: "atproto transition:generic",
354 dpop_bound_access_tokens: true,
355 jwks_uri: `${config.domain}/jwks.json`,
356 subject_type: 'public',
357 authorization_signed_response_alg: 'ES256'
358});
359
360const persistKey = async (key: JoseKey) => {
361 const priv = key.privateJwk;
362 if (!priv) return;
363 const kid = key.kid ?? crypto.randomUUID();
364 await db`
365 INSERT INTO oauth_keys (kid, jwk, created_at)
366 VALUES (${kid}, ${JSON.stringify(priv)}, EXTRACT(EPOCH FROM NOW()))
367 ON CONFLICT (kid) DO UPDATE SET jwk = EXCLUDED.jwk
368 `;
369};
370
371const loadPersistedKeys = async (): Promise<JoseKey[]> => {
372 const rows = await db`SELECT kid, jwk, created_at FROM oauth_keys ORDER BY kid`;
373 const keys: JoseKey[] = [];
374 for (const row of rows) {
375 try {
376 const obj = JSON.parse(row.jwk);
377 const key = await JoseKey.fromImportable(obj as any, (obj as any).kid);
378 keys.push(key);
379 } catch (err) {
380 console.error('Could not parse stored JWK', err);
381 }
382 }
383 return keys;
384};
385
386const ensureKeys = async (): Promise<JoseKey[]> => {
387 let keys = await loadPersistedKeys();
388 const needed: string[] = [];
389 for (let i = 1; i <= 3; i++) {
390 const kid = `key${i}`;
391 if (!keys.some(k => k.kid === kid)) needed.push(kid);
392 }
393 for (const kid of needed) {
394 const newKey = await JoseKey.generate(['ES256'], kid);
395 await persistKey(newKey);
396 keys.push(newKey);
397 }
398 keys.sort((a, b) => (a.kid ?? '').localeCompare(b.kid ?? ''));
399 return keys;
400};
401
402// Load keys from database every time (stateless - safe for horizontal scaling)
403export const getCurrentKeys = async (): Promise<JoseKey[]> => {
404 return await loadPersistedKeys();
405};
406
407// Key rotation - rotate keys older than 30 days (monthly rotation)
408const KEY_MAX_AGE = 30 * 24 * 60 * 60; // 30 days in seconds
409
410export const rotateKeysIfNeeded = async (): Promise<boolean> => {
411 const now = Math.floor(Date.now() / 1000);
412 const cutoffTime = now - KEY_MAX_AGE;
413
414 try {
415 // Find keys older than 30 days
416 const oldKeys = await db`
417 SELECT kid, created_at FROM oauth_keys
418 WHERE created_at IS NOT NULL AND created_at < ${cutoffTime}
419 ORDER BY created_at ASC
420 `;
421
422 if (oldKeys.length === 0) {
423 console.log('[KeyRotation] No keys need rotation');
424 return false;
425 }
426
427 console.log(`[KeyRotation] Found ${oldKeys.length} key(s) older than 30 days, rotating oldest key`);
428
429 // Rotate the oldest key
430 const oldestKey = oldKeys[0];
431 const oldKid = oldestKey.kid;
432
433 // Generate new key with same kid
434 const newKey = await JoseKey.generate(['ES256'], oldKid);
435 await persistKey(newKey);
436
437 console.log(`[KeyRotation] Rotated key ${oldKid}`);
438
439 return true;
440 } catch (err) {
441 console.error('[KeyRotation] Failed to rotate keys:', err);
442 return false;
443 }
444};
445
446export const getOAuthClient = async (config: { domain: `https://${string}`, clientName: string }) => {
447 const keys = await ensureKeys();
448
449 return new NodeOAuthClient({
450 clientMetadata: createClientMetadata(config),
451 keyset: keys,
452 stateStore,
453 sessionStore
454 });
455};
456
457export const getCustomDomainsByDid = async (did: string) => {
458 const rows = await db`SELECT * FROM custom_domains WHERE did = ${did} ORDER BY created_at DESC`;
459 return rows;
460};
461
462export const getCustomDomainInfo = async (domain: string) => {
463 const rows = await db`SELECT * FROM custom_domains WHERE domain = ${domain.toLowerCase()}`;
464 return rows[0] ?? null;
465};
466
467export const getCustomDomainByHash = async (hash: string) => {
468 const rows = await db`SELECT * FROM custom_domains WHERE id = ${hash}`;
469 return rows[0] ?? null;
470};
471
472export const getCustomDomainById = async (id: string) => {
473 const rows = await db`SELECT * FROM custom_domains WHERE id = ${id}`;
474 return rows[0] ?? null;
475};
476
477export const claimCustomDomain = async (did: string, domain: string, hash: string, rkey: string | null = null) => {
478 const domainLower = domain.toLowerCase();
479 try {
480 await db`
481 INSERT INTO custom_domains (id, domain, did, rkey, verified, created_at)
482 VALUES (${hash}, ${domainLower}, ${did}, ${rkey}, false, EXTRACT(EPOCH FROM NOW()))
483 `;
484 return { success: true, hash };
485 } catch (err) {
486 console.error('Failed to claim custom domain', err);
487 throw new Error('conflict');
488 }
489};
490
491export const updateCustomDomainRkey = async (id: string, rkey: string | null) => {
492 const rows = await db`
493 UPDATE custom_domains
494 SET rkey = ${rkey}
495 WHERE id = ${id}
496 RETURNING *
497 `;
498 return rows[0] ?? null;
499};
500
501export const updateCustomDomainVerification = async (id: string, verified: boolean) => {
502 const rows = await db`
503 UPDATE custom_domains
504 SET verified = ${verified}, last_verified_at = EXTRACT(EPOCH FROM NOW())
505 WHERE id = ${id}
506 RETURNING *
507 `;
508 return rows[0] ?? null;
509};
510
511export const deleteCustomDomain = async (id: string) => {
512 await db`DELETE FROM custom_domains WHERE id = ${id}`;
513};
514
515export const getSitesByDid = async (did: string) => {
516 const rows = await db`SELECT * FROM sites WHERE did = ${did} ORDER BY created_at DESC`;
517 return rows;
518};
519
520export const upsertSite = async (did: string, rkey: string, displayName?: string) => {
521 try {
522 // Only set display_name if provided (not undefined/null/empty)
523 const cleanDisplayName = displayName && displayName.trim() ? displayName.trim() : null;
524
525 await db`
526 INSERT INTO sites (did, rkey, display_name, created_at, updated_at)
527 VALUES (${did}, ${rkey}, ${cleanDisplayName}, EXTRACT(EPOCH FROM NOW()), EXTRACT(EPOCH FROM NOW()))
528 ON CONFLICT (did, rkey)
529 DO UPDATE SET
530 display_name = CASE
531 WHEN EXCLUDED.display_name IS NOT NULL THEN EXCLUDED.display_name
532 ELSE sites.display_name
533 END,
534 updated_at = EXTRACT(EPOCH FROM NOW())
535 `;
536 return { success: true };
537 } catch (err) {
538 console.error('Failed to upsert site', err);
539 return { success: false, error: err };
540 }
541};
542
543export const deleteSite = async (did: string, rkey: string) => {
544 try {
545 await db`DELETE FROM sites WHERE did = ${did} AND rkey = ${rkey}`;
546 return { success: true };
547 } catch (err) {
548 console.error('Failed to delete site', err);
549 return { success: false, error: err };
550 }
551};