582 lines
19 KiB
JavaScript
582 lines
19 KiB
JavaScript
require('dotenv').config();
|
|
const express = require('express');
|
|
const morgan = require('morgan');
|
|
const cors = require('cors');
|
|
const path = require('path');
|
|
const { resolveHandshake, clearCache, clearIpnsCache } = require('./lib/handshake');
|
|
const { fetchFromIpfs } = require('./lib/ipfs');
|
|
const { PORT } = require('./config');
|
|
|
|
const app = express();
|
|
|
|
// Middleware
|
|
app.use(cors());
|
|
app.use(morgan('dev'));
|
|
app.use(express.json());
|
|
|
|
// Add a request logger middleware at the very beginning
|
|
app.use((req, res, next) => {
|
|
console.log('\n----- NEW REQUEST -----');
|
|
console.log(`${req.method} ${req.url}`);
|
|
console.log(`Headers: ${JSON.stringify({
|
|
host: req.get('host'),
|
|
referer: req.get('referer'),
|
|
'user-agent': req.get('user-agent')
|
|
}, null, 2)}`);
|
|
next();
|
|
});
|
|
|
|
// Define the main dashboard host
|
|
// This should be configurable via environment variable
|
|
const DASHBOARD_HOST = process.env.DASHBOARD_HOST || '127.0.0.1:3000';
|
|
|
|
// Define reserved paths that should not be treated as Handshake domains
|
|
const RESERVED_PATHS = [
|
|
'api',
|
|
'hns',
|
|
'public',
|
|
'assets',
|
|
'static',
|
|
'images',
|
|
'css',
|
|
'js',
|
|
'favicon.ico'
|
|
];
|
|
|
|
// Helper function to normalize host strings for comparison
|
|
function normalizeHost(host) {
|
|
if (!host) return '';
|
|
// Remove port if present and convert to lowercase
|
|
const normalized = host.split(':')[0].toLowerCase();
|
|
console.log(`Normalizing host: ${host} -> ${normalized}`);
|
|
return normalized;
|
|
}
|
|
|
|
// IMPORTANT: Move direct domain access middleware before static file serving
|
|
// Middleware to check if request is for direct domain access
|
|
app.use(async (req, res, next) => {
|
|
const host = req.get('host');
|
|
const normalizedHost = normalizeHost(host);
|
|
const normalizedDashboardHost = normalizeHost(DASHBOARD_HOST);
|
|
|
|
console.log(`[HOST CHECK] Request host: ${host}, Normalized: ${normalizedHost}, Dashboard: ${normalizedDashboardHost}`);
|
|
|
|
// Special handling for curl requests with Host header
|
|
if (normalizedHost !== normalizedDashboardHost) {
|
|
console.log(`[HOST CHECK] Host ${normalizedHost} doesn't match dashboard ${normalizedDashboardHost}, treating as direct access`);
|
|
|
|
// Skip direct domain handling for API endpoints
|
|
if (req.path.startsWith('/api/')) {
|
|
console.log(`[HOST CHECK] Skipping direct domain handling for API endpoint: ${req.path}`);
|
|
return next();
|
|
}
|
|
|
|
// Extract domain from the hostname
|
|
const domain = normalizedHost;
|
|
console.log(`[DIRECT ACCESS] Using domain: ${domain} from host: ${host}`);
|
|
|
|
try {
|
|
return await handleDirectDomainAccess(req, res, domain);
|
|
} catch (error) {
|
|
console.error(`[HOST CHECK] Error handling direct access, falling back to normal processing: ${error}`);
|
|
// Fall back to normal processing if direct access fails
|
|
return next();
|
|
}
|
|
}
|
|
|
|
console.log(`[HOST CHECK] Host ${normalizedHost} matches dashboard ${normalizedDashboardHost}, continuing with normal processing`);
|
|
// Continue with normal processing for dashboard host
|
|
next();
|
|
});
|
|
|
|
// Serve static files AFTER checking for direct domain access
|
|
app.use(express.static(path.join(__dirname, 'public')));
|
|
|
|
// Helper function to inject tracking script into HTML content
|
|
function injectTrackingScript(content, mimeType) {
|
|
if (mimeType && mimeType.includes('text/html')) {
|
|
const trackingScript = '<script async src="https://umami.woodburn.au/script.js" data-website-id="2ced0833-1c76-4684-880d-65afb58f16f2"></script>';
|
|
|
|
let htmlContent = content.toString();
|
|
|
|
// Try to inject before </body>
|
|
if (htmlContent.includes('</body>')) {
|
|
return htmlContent.replace('</body>', `${trackingScript}</body>`);
|
|
}
|
|
// Or try to inject before </html> if no </body> found
|
|
else if (htmlContent.includes('</html>')) {
|
|
return htmlContent.replace('</html>', `${trackingScript}</html>`);
|
|
}
|
|
// Otherwise append to the end
|
|
else {
|
|
return htmlContent + trackingScript;
|
|
}
|
|
}
|
|
return content;
|
|
}
|
|
|
|
// Helper function to make links absolute in HTML content
|
|
function makeLinksAbsolute(content, mimeType, domain, subPath = '', isDirectAccess = false) {
|
|
if (!mimeType || !mimeType.includes('text/html')) {
|
|
return content;
|
|
}
|
|
|
|
let htmlContent = content.toString();
|
|
// If direct access (via subdomain), don't prefix links with domain
|
|
const baseUrl = isDirectAccess ? '' : `/${domain}`;
|
|
|
|
// Create base directory for proper path resolution
|
|
let basePath = '/';
|
|
if (subPath) {
|
|
// Improve directory path calculation
|
|
const lastSegmentHasExtension = subPath.split('/').pop().includes('.');
|
|
|
|
if (lastSegmentHasExtension) {
|
|
// If the current path is a file, use its directory
|
|
const pathParts = subPath.split('/');
|
|
pathParts.pop(); // Remove the file part
|
|
basePath = pathParts.length ? `/${pathParts.join('/')}/` : '/';
|
|
} else if (!subPath.endsWith('/')) {
|
|
// Ensure directory paths end with /
|
|
basePath = `/${subPath}/`;
|
|
} else {
|
|
basePath = `/${subPath}`;
|
|
}
|
|
}
|
|
|
|
// Function to resolve paths
|
|
const resolvePath = (href, isStylesheet = false) => {
|
|
// Don't modify stylesheet URLs - keep them relative to preserve internal references
|
|
if (isStylesheet) {
|
|
return href;
|
|
}
|
|
|
|
if (href.startsWith('/')) {
|
|
// Absolute path within the site - make it absolute to our gateway
|
|
return `${baseUrl}${href}`;
|
|
} else if (!href.match(/^(https?:|mailto:|tel:|#|javascript:|data:)/)) {
|
|
// Relative path - resolve it against current directory
|
|
return `${baseUrl}${basePath}${href}`;
|
|
}
|
|
return href; // Already absolute or special protocol
|
|
};
|
|
|
|
// Handle stylesheet links specially
|
|
htmlContent = htmlContent.replace(/<link\s+([^>]*rel=['"]stylesheet['"][^>]*)>/gi, (match, attrs) => {
|
|
// Don't modify the href in stylesheet links
|
|
return match;
|
|
});
|
|
|
|
// Replace href attributes in non-stylesheet elements
|
|
htmlContent = htmlContent.replace(/<a\s+([^>]*href=['"]([^'"]+)['"][^>]*)>/gi, (match, attrs, href) => {
|
|
return match.replace(`href="${href}"`, `href="${resolvePath(href)}"`)
|
|
.replace(`href='${href}'`, `href='${resolvePath(href)}'`);
|
|
});
|
|
|
|
// Replace src attributes carefully - don't touch CSS related ones
|
|
htmlContent = htmlContent.replace(/src=["'](.*?)["']/g, (match, src) => {
|
|
if (src.endsWith('.css')) {
|
|
return match; // Don't modify CSS srcs
|
|
}
|
|
return `src="${resolvePath(src)}"`;
|
|
});
|
|
|
|
return htmlContent;
|
|
}
|
|
|
|
// Helper function to handle direct domain access
|
|
async function handleDirectDomainAccess(req, res, domain) {
|
|
console.log(`[DIRECT ACCESS] Starting direct domain access handler for: ${domain}`);
|
|
try {
|
|
// Remove trailing slash from path for consistency
|
|
let subPath = req.path || '';
|
|
if (subPath === '/' || subPath === '') {
|
|
subPath = '';
|
|
}
|
|
|
|
console.log(`[DIRECT ACCESS] Domain: ${domain}, Path: '${subPath}'`);
|
|
|
|
// Resolve Handshake domain to get IPFS CID
|
|
console.log(`[DIRECT ACCESS] Resolving Handshake domain: ${domain}`);
|
|
const cid = await resolveHandshake(domain);
|
|
|
|
if (!cid) {
|
|
console.warn(`[DIRECT ACCESS] No IPFS CID found for domain: ${domain}`);
|
|
return res.status(404).json({
|
|
error: 'Domain not found or has no IPFS record',
|
|
domain: domain
|
|
});
|
|
}
|
|
|
|
console.log(`[DIRECT ACCESS] Resolved ${domain} to IPFS CID: ${cid}`);
|
|
|
|
// Fetch content from IPFS - handle root path specially
|
|
const path = subPath === '' ? '' : (subPath.startsWith('/') ? subPath.substring(1) : subPath);
|
|
console.log(`[DIRECT ACCESS] Fetching IPFS content for CID: ${cid}, path: '${path}'`);
|
|
let content = await fetchFromIpfs(cid, path);
|
|
|
|
if (!content) {
|
|
console.log(`[DIRECT ACCESS] No content found for path: '${path}'`);
|
|
// Try index.html for empty paths
|
|
if (path === '') {
|
|
console.log('[DIRECT ACCESS] Trying index.html for root path');
|
|
const indexContent = await fetchFromIpfs(cid, 'index.html');
|
|
if (indexContent) {
|
|
console.log('[DIRECT ACCESS] Found index.html content, using that instead');
|
|
content = indexContent;
|
|
} else {
|
|
console.log('[DIRECT ACCESS] No index.html found either');
|
|
}
|
|
}
|
|
|
|
// If still no content, return 404
|
|
if (!content) {
|
|
console.log(`[DIRECT ACCESS] Returning 404 for CID: ${cid}, path: '${path}'`);
|
|
return res.status(404).json({
|
|
error: 'Content not found on IPFS network',
|
|
cid: cid,
|
|
path: path
|
|
});
|
|
}
|
|
}
|
|
|
|
// Set appropriate content type
|
|
if (content.mimeType) {
|
|
console.log(`[DIRECT ACCESS] Setting content type: ${content.mimeType}`);
|
|
res.setHeader('Content-Type', content.mimeType);
|
|
}
|
|
|
|
// Process HTML content: make links absolute and inject tracking script
|
|
console.log('[DIRECT ACCESS] Processing content');
|
|
let processedContent = content.data;
|
|
if (content.mimeType && content.mimeType.includes('text/html')) {
|
|
console.log('[DIRECT ACCESS] HTML content detected, making links absolute');
|
|
processedContent = makeLinksAbsolute(processedContent, content.mimeType, domain, path, true);
|
|
console.log('[DIRECT ACCESS] Injecting tracking script');
|
|
processedContent = injectTrackingScript(processedContent, content.mimeType);
|
|
}
|
|
|
|
// Return the content
|
|
console.log('[DIRECT ACCESS] Sending processed content');
|
|
return res.send(processedContent);
|
|
} catch (error) {
|
|
console.error('[DIRECT ACCESS] Error handling direct domain access:', error);
|
|
throw error; // Rethrow so middleware can fall back to normal processing
|
|
}
|
|
}
|
|
|
|
// Status endpoint
|
|
app.get('/api/status', (req, res) => {
|
|
res.json({ status: 'online', version: '1.0.0' });
|
|
});
|
|
|
|
// New route: Handle root domain requests with direct domain format
|
|
app.get('/:domain', async (req, res, next) => {
|
|
const domain = req.params.domain;
|
|
|
|
console.log(`[DASHBOARD ROUTE] Processing /:domain request for: ${domain}`);
|
|
|
|
// Skip this handler for reserved paths
|
|
if (RESERVED_PATHS.includes(domain)) {
|
|
console.log(`[DASHBOARD ROUTE] Domain '${domain}' is in reserved paths, skipping`);
|
|
return next();
|
|
}
|
|
|
|
try {
|
|
console.log(`[DASHBOARD ROUTE] Processing request for domain root: ${domain}`);
|
|
|
|
// Resolve Handshake domain to get IPFS CID
|
|
const cid = await resolveHandshake(domain);
|
|
|
|
if (!cid) {
|
|
console.warn(`No IPFS CID found for domain: ${domain}`);
|
|
return res.status(404).json({
|
|
error: 'Domain not found or has no IPFS record',
|
|
domain: domain
|
|
});
|
|
}
|
|
|
|
console.log(`Resolved ${domain} to IPFS CID: ${cid}`);
|
|
|
|
// Fetch content from IPFS (root path)
|
|
const content = await fetchFromIpfs(cid, '');
|
|
|
|
if (!content) {
|
|
return res.status(404).json({
|
|
error: 'Content not found on IPFS network',
|
|
cid: cid
|
|
});
|
|
}
|
|
|
|
// Set appropriate content type
|
|
if (content.mimeType) {
|
|
res.setHeader('Content-Type', content.mimeType);
|
|
}
|
|
|
|
// Process HTML content: make links absolute and inject tracking script
|
|
let processedContent = content.data;
|
|
if (content.mimeType && content.mimeType.includes('text/html')) {
|
|
processedContent = makeLinksAbsolute(processedContent, content.mimeType, domain, '');
|
|
processedContent = injectTrackingScript(processedContent, content.mimeType);
|
|
}
|
|
|
|
// Return the content
|
|
res.send(processedContent);
|
|
} catch (error) {
|
|
console.error('Error handling request:', error);
|
|
res.status(500).json({
|
|
error: 'Server error processing request',
|
|
message: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// New route: Handle domain requests with subpaths using direct domain format
|
|
app.get('/:domain/*', async (req, res, next) => {
|
|
const domain = req.params.domain;
|
|
|
|
// Skip this handler for reserved paths
|
|
if (RESERVED_PATHS.includes(domain)) {
|
|
return next();
|
|
}
|
|
|
|
try {
|
|
const subPath = req.params[0] || '';
|
|
|
|
console.log(`Processing request for domain: ${domain}, path: ${subPath}`);
|
|
|
|
// Resolve Handshake domain to get IPFS CID
|
|
const cid = await resolveHandshake(domain);
|
|
|
|
if (!cid) {
|
|
console.warn(`No IPFS CID found for domain: ${domain}`);
|
|
return res.status(404).json({
|
|
error: 'Domain not found or has no IPFS record',
|
|
domain: domain
|
|
});
|
|
}
|
|
|
|
console.log(`Resolved ${domain} to IPFS CID: ${cid}`);
|
|
|
|
// Fetch content from IPFS
|
|
const content = await fetchFromIpfs(cid, subPath);
|
|
|
|
if (!content) {
|
|
return res.status(404).json({
|
|
error: 'Content not found on IPFS network',
|
|
cid: cid,
|
|
path: subPath
|
|
});
|
|
}
|
|
|
|
// Set appropriate content type
|
|
if (content.mimeType) {
|
|
res.setHeader('Content-Type', content.mimeType);
|
|
}
|
|
|
|
// Process HTML content: make links absolute and inject tracking script
|
|
let processedContent = content.data;
|
|
if (content.mimeType && content.mimeType.includes('text/html')) {
|
|
processedContent = makeLinksAbsolute(processedContent, content.mimeType, domain, subPath);
|
|
processedContent = injectTrackingScript(processedContent, content.mimeType);
|
|
}
|
|
|
|
// Return the content
|
|
res.send(processedContent);
|
|
} catch (error) {
|
|
console.error('Error handling request:', error);
|
|
res.status(500).json({
|
|
error: 'Server error processing request',
|
|
message: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// Routes (keeping original routes for backward compatibility)
|
|
app.get('/hns/:domain/*', async (req, res) => {
|
|
try {
|
|
const domain = req.params.domain;
|
|
const subPath = req.params[0] || '';
|
|
|
|
console.log(`Processing request for domain: ${domain}, path: ${subPath}`);
|
|
|
|
// Resolve Handshake domain to get IPFS CID
|
|
const cid = await resolveHandshake(domain);
|
|
|
|
if (!cid) {
|
|
console.warn(`No IPFS CID found for domain: ${domain}`);
|
|
return res.status(404).json({
|
|
error: 'Domain not found or has no IPFS record',
|
|
domain: domain
|
|
});
|
|
}
|
|
|
|
console.log(`Resolved ${domain} to IPFS CID: ${cid}`);
|
|
|
|
// Fetch content from IPFS
|
|
const content = await fetchFromIpfs(cid, subPath);
|
|
|
|
if (!content) {
|
|
return res.status(404).json({
|
|
error: 'Content not found on IPFS network',
|
|
cid: cid,
|
|
path: subPath
|
|
});
|
|
}
|
|
|
|
// Set appropriate content type
|
|
if (content.mimeType) {
|
|
res.setHeader('Content-Type', content.mimeType);
|
|
}
|
|
|
|
// Process HTML content: make links absolute and inject tracking script
|
|
let processedContent = content.data;
|
|
if (content.mimeType && content.mimeType.includes('text/html')) {
|
|
processedContent = makeLinksAbsolute(processedContent, content.mimeType, domain, subPath);
|
|
processedContent = injectTrackingScript(processedContent, content.mimeType);
|
|
}
|
|
|
|
// Return the content
|
|
res.send(processedContent);
|
|
} catch (error) {
|
|
console.error('Error handling request:', error);
|
|
res.status(500).json({
|
|
error: 'Server error processing request',
|
|
message: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// Also add a route without the trailing wildcard to handle root domain requests
|
|
app.get('/hns/:domain', async (req, res) => {
|
|
try {
|
|
const domain = req.params.domain;
|
|
|
|
console.log(`Processing request for domain root: ${domain}`);
|
|
|
|
// Resolve Handshake domain to get IPFS CID
|
|
const cid = await resolveHandshake(domain);
|
|
|
|
if (!cid) {
|
|
console.warn(`No IPFS CID found for domain: ${domain}`);
|
|
return res.status(404).json({
|
|
error: 'Domain not found or has no IPFS record',
|
|
domain: domain
|
|
});
|
|
}
|
|
|
|
console.log(`Resolved ${domain} to IPFS CID: ${cid}`);
|
|
|
|
// Fetch content from IPFS (root path)
|
|
const content = await fetchFromIpfs(cid, '');
|
|
|
|
if (!content) {
|
|
return res.status(404).json({
|
|
error: 'Content not found on IPFS network',
|
|
cid: cid
|
|
});
|
|
}
|
|
|
|
// Set appropriate content type
|
|
if (content.mimeType) {
|
|
res.setHeader('Content-Type', content.mimeType);
|
|
}
|
|
|
|
// Process HTML content: make links absolute and inject tracking script
|
|
let processedContent = content.data;
|
|
if (content.mimeType && content.mimeType.includes('text/html')) {
|
|
processedContent = makeLinksAbsolute(processedContent, content.mimeType, domain, '');
|
|
processedContent = injectTrackingScript(processedContent, content.mimeType);
|
|
}
|
|
|
|
// Return the content
|
|
res.send(processedContent);
|
|
} catch (error) {
|
|
console.error('Error handling request:', error);
|
|
res.status(500).json({
|
|
error: 'Server error processing request',
|
|
message: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// API route to force refresh IPFS content
|
|
app.get('/api/refresh/:domain', async (req, res) => {
|
|
try {
|
|
const domain = req.params.domain;
|
|
|
|
// Validate domain name format
|
|
if (!domain.match(/^[a-z0-9-_]+(\.[a-z0-9-_]+)*\/?$/i)) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: 'Invalid domain format'
|
|
});
|
|
}
|
|
|
|
console.log(`Refreshing content for domain: ${domain}`);
|
|
// Clear cache for the domain
|
|
clearCache(domain);
|
|
|
|
|
|
// Return success response
|
|
res.json({
|
|
success: true,
|
|
message: `Refresh initiated for ${domain}`,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
console.error('Refresh error:', error);
|
|
res.status(500).json({
|
|
success: false,
|
|
message: 'Server error during refresh operation'
|
|
});
|
|
}
|
|
});
|
|
|
|
// New API route to refresh IPNS cache specifically
|
|
app.get('/api/refresh-ipns/:ipnsName', async (req, res) => {
|
|
try {
|
|
const ipnsName = req.params.ipnsName;
|
|
|
|
// Validate IPNS name format (basic validation)
|
|
if (!ipnsName.match(/^[a-zA-Z0-9]+$/)) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: 'Invalid IPNS name format'
|
|
});
|
|
}
|
|
|
|
console.log(`Refreshing IPNS cache for: ${ipnsName}`);
|
|
// Clear IPNS cache
|
|
clearIpnsCache(ipnsName);
|
|
|
|
// Return success response
|
|
res.json({
|
|
success: true,
|
|
message: `IPNS cache refresh initiated for ${ipnsName}`,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
console.error('IPNS refresh error:', error);
|
|
res.status(500).json({
|
|
success: false,
|
|
message: 'Server error during IPNS refresh operation'
|
|
});
|
|
}
|
|
});
|
|
|
|
// Catch-all route to handle SPA navigation
|
|
app.get('*', (req, res) => {
|
|
res.sendFile(path.join(__dirname, 'public', 'index.html'));
|
|
});
|
|
|
|
// Start server
|
|
app.listen(PORT, () => {
|
|
console.log(`\n==================================`);
|
|
console.log(`Fire Portal server running on port ${PORT}`);
|
|
console.log(`Dashboard host: ${DASHBOARD_HOST}`);
|
|
console.log(`==================================\n`);
|
|
});
|