Initial commit

routes/api/host/+server.ts

@@ -0,0 +1,158 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { getDockerInfo, getHawserInfo } from '$lib/server/docker';
+import { getEnvironment } from '$lib/server/db';
+import { authorize } from '$lib/server/authorize';
+import { getEdgeConnectionInfo } from '$lib/server/hawser';
+import os from 'node:os';
+
+export interface HostInfo {
+	hostname: string;
+	ipAddress: string;
+	platform: string;
+	arch: string;
+	cpus: number;
+	totalMemory: number;
+	freeMemory: number;
+	uptime: number;
+	dockerVersion: string;
+	dockerContainers: number;
+	dockerContainersRunning: number;
+	dockerImages: number;
+	environment: {
+		id: number;
+		name: string;
+		icon?: string;
+		socketPath?: string;
+		connectionType?: string;
+		hawserVersion?: string;
+		highlightChanges?: boolean;
+	};
+}
+
+function getLocalIpAddress(): string {
+	const interfaces = os.networkInterfaces();
+	for (const name of Object.keys(interfaces)) {
+		const netInterface = interfaces[name];
+		if (!netInterface) continue;
+		for (const net of netInterface) {
+			// Skip internal and non-IPv4 addresses
+			if (!net.internal && net.family === 'IPv4') {
+				return net.address;
+			}
+		}
+	}
+	return '127.0.0.1';
+}
+
+export const GET: RequestHandler = async ({ url, cookies }) => {
+	const auth = await authorize(cookies);
+
+	// Check basic environment view permission
+	if (auth.authEnabled && !await auth.can('environments', 'view')) {
+		return json({ error: 'Permission denied' }, { status: 403 });
+	}
+
+	try {
+		// Get environment ID from query param, or use default
+		const envIdParam = url.searchParams.get('env');
+		let env;
+
+		if (envIdParam) {
+			const envId = parseInt(envIdParam);
+			// Check if user can access this specific environment
+			if (auth.authEnabled && auth.isEnterprise && !await auth.canAccessEnvironment(envId)) {
+				return json({ error: 'Access denied to this environment' }, { status: 403 });
+			}
+			env = await getEnvironment(envId);
+		}
+
+		if (!env) {
+			// No environment specified - return basic local info
+			return json({
+				hostname: os.hostname(),
+				ipAddress: getLocalIpAddress(),
+				platform: os.platform(),
+				arch: os.arch(),
+				cpus: os.cpus().length,
+				totalMemory: os.totalmem(),
+				freeMemory: os.freemem(),
+				uptime: os.uptime(),
+				dockerVersion: null,
+				dockerContainers: 0,
+				dockerContainersRunning: 0,
+				dockerImages: 0,
+				environment: null
+			});
+		}
+
+		// Determine if this is a truly local connection (socket without remote host)
+		const isSocketType = env.connectionType === 'socket' || !env.connectionType;
+		const isLocalConnection = isSocketType && (!env.host || env.host === 'localhost' || env.host === '127.0.0.1');
+
+		// Fetch Docker info and Hawser info in parallel for hawser-standard mode
+		let dockerInfo: any;
+		let uptime = 0;
+		let hawserVersion: string | undefined;
+
+		if (env.connectionType === 'hawser-standard') {
+			// Parallel fetch for hawser-standard
+			const [dockerResult, hawserInfo] = await Promise.all([
+				getDockerInfo(env.id),
+				getHawserInfo(env.id)
+			]);
+			dockerInfo = dockerResult;
+			if (hawserInfo?.uptime) {
+				uptime = hawserInfo.uptime;
+			}
+			if (hawserInfo?.hawserVersion) {
+				hawserVersion = hawserInfo.hawserVersion;
+			}
+		} else {
+			// Sequential for other connection types
+			dockerInfo = await getDockerInfo(env.id);
+
+			if (isLocalConnection) {
+				uptime = os.uptime();
+			} else if (env.connectionType === 'hawser-edge') {
+				// For Hawser edge mode, get from edge connection metrics (sync lookup)
+				const edgeConn = getEdgeConnectionInfo(env.id);
+				if (edgeConn?.lastMetrics?.uptime) {
+					uptime = edgeConn.lastMetrics.uptime;
+				}
+			}
+			// For 'direct' connections without Hawser, uptime remains 0 (not available)
+		}
+
+		const hostInfo: HostInfo = {
+			// For local connections, show local system info; for remote, show Docker host info
+			hostname: isLocalConnection ? os.hostname() : (dockerInfo.Name || env.host || 'unknown'),
+			ipAddress: isLocalConnection ? getLocalIpAddress() : (env.host || 'unknown'),
+			platform: isLocalConnection ? os.platform() : (dockerInfo.OperatingSystem || 'unknown'),
+			arch: isLocalConnection ? os.arch() : (dockerInfo.Architecture || 'unknown'),
+			cpus: isLocalConnection ? os.cpus().length : (dockerInfo.NCPU || 0),
+			totalMemory: isLocalConnection ? os.totalmem() : (dockerInfo.MemTotal || 0),
+			freeMemory: isLocalConnection ? os.freemem() : 0, // Not available from Docker API
+			uptime,
+			dockerVersion: dockerInfo.ServerVersion || 'unknown',
+			dockerContainers: dockerInfo.Containers || 0,
+			dockerContainersRunning: dockerInfo.ContainersRunning || 0,
+			dockerImages: dockerInfo.Images || 0,
+			environment: {
+				id: env.id,
+				name: env.name,
+				icon: env.icon,
+				socketPath: env.socketPath,
+				connectionType: env.connectionType || 'socket',
+				// For standard mode, use live-fetched version; for edge mode, use stored version
+				hawserVersion: hawserVersion || env.hawserVersion,
+				highlightChanges: env.highlightChanges
+			}
+		};
+
+		return json(hostInfo);
+	} catch (error) {
+		console.error('Failed to get host info:', error);
+		return json({ error: 'Failed to get host info' }, { status: 500 });
+	}
+};