fixes to db connections going stale

apps/hosting-service/src/index.ts

···
 import { createLogger, initializeGrafanaExporters } from '@wisp/observability';
 import { mkdirSync, existsSync } from 'fs';
 import { backfillCache } from './lib/backfill';
-import { startDomainCacheCleanup, stopDomainCacheCleanup, setCacheOnlyMode } from './lib/db';
+import { startDomainCacheCleanup, stopDomainCacheCleanup, setCacheOnlyMode, closeDatabase } from './lib/db';
 
 // Initialize Grafana exporters if configured
 initializeGrafanaExporters({
···
   console.log('\n🛑 Shutting down...');
   firehose.stop();
   stopDomainCacheCleanup();
+  await closeDatabase();
   server.close();
   process.exit(0);
 });
···
   console.log('\n🛑 Shutting down...');
   firehose.stop();
   stopDomainCacheCleanup();
+  await closeDatabase();
   server.close();
   process.exit(0);
 });

apps/hosting-service/src/lib/db.ts

···
   return hashNum & 0x7FFFFFFFFFFFFFFFn;
 }
 
+// Track active locks for cleanup on shutdown
+const activeLocks = new Set<string>();
+
 /**
  * Acquire a distributed lock using PostgreSQL advisory locks
  * Returns true if lock was acquired, false if already held by another instance
···
 
   try {
     const result = await sql`SELECT pg_try_advisory_lock(${Number(lockId)}) as acquired`;
-    return result[0]?.acquired === true;
+    const acquired = result[0]?.acquired === true;
+    if (acquired) {
+      activeLocks.add(key);
+    }
+    return acquired;
   } catch (err) {
     console.error('Failed to acquire lock', { key, error: err });
     return false;
···
 
   try {
     await sql`SELECT pg_advisory_unlock(${Number(lockId)})`;
+    activeLocks.delete(key);
   } catch (err) {
     console.error('Failed to release lock', { key, error: err });
+    // Still remove from tracking even if unlock fails
+    activeLocks.delete(key);
+  }
+}
+
+/**
+ * Close all database connections
+ * Call this during graceful shutdown
+ */
+export async function closeDatabase(): Promise<void> {
+  try {
+    // Release all active advisory locks before closing connections
+    if (activeLocks.size > 0) {
+      console.log(`[DB] Releasing ${activeLocks.size} active advisory locks before shutdown`);
+      for (const key of activeLocks) {
+        await releaseLock(key);
+      }
+    }
+
+    await sql.end({ timeout: 5 });
+    console.log('[DB] Database connections closed');
+  } catch (err) {
+    console.error('[DB] Error closing database connections:', err);
   }
 }
 

apps/main-app/src/index.ts

···
 	cleanupExpiredSessions,
 	rotateKeysIfNeeded
 } from './lib/oauth-client'
-import { getCookieSecret } from './lib/db'
+import { getCookieSecret, closeDatabase } from './lib/db'
 import { authRoutes } from './routes/auth'
 import { wispRoutes } from './routes/wisp'
 import { domainRoutes } from './routes/domain'
···
 console.log(
 	`🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
 )
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+	console.log('\n🛑 Shutting down...')
+	dnsVerifier.stop()
+	await closeDatabase()
+	process.exit(0)
+})
+
+process.on('SIGTERM', async () => {
+	console.log('\n🛑 Shutting down...')
+	dnsVerifier.stop()
+	await closeDatabase()
+	process.exit(0)
+})

apps/main-app/src/lib/db.ts

···
     console.log('[CookieSecret] Generated new cookie signing secret');
     return secret;
 };
+
+/**
+ * Close database connection
+ * Call this during graceful shutdown
+ */
+export const closeDatabase = async (): Promise<void> => {
+    try {
+        await db.end();
+        console.log('[DB] Database connection closed');
+    } catch (err) {
+        console.error('[DB] Error closing database connection:', err);
+    }
+};

apps/main-app/src/routes/wisp.ts

···
 
 const logger = createLogger('main-app')
 
-function isValidSiteName(siteName: string): boolean {
+export function isValidSiteName(siteName: string): boolean {
     if (!siteName || typeof siteName !== 'string') return false;
 
     // Length check (AT Protocol rkey limit)
···
             }
 
             // Use webkitRelativePath when available (directory uploads), fallback to name for regular file uploads
-            const filePath = (file as any).webkitRelativePath || file.name;
+            const webkitPath = 'webkitRelativePath' in file ? String(file.webkitRelativePath) : '';
+            const filePath = webkitPath || file.name;
 
             updateJobProgress(jobId, {
                 filesProcessed: i + 1,