homeio

1import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
2import next from "next";
3import { parse } from "node:url";
4import compression from "compression";
5import { closeServerGracefully } from "./lib/server/http/graceful-shutdown";
6import { LISTEN_BACKLOG, configureUpstreamKeepAlive } from "./lib/server/http/keep-alive";
7
8const dev = process.env.NODE_ENV !== "production";
9const hostname =
10  process.env.HOMEIO_HTTP_HOST || (dev ? "localhost" : "0.0.0.0");
11const port = parseInt(process.env.HOMEIO_HTTP_PORT || process.env.PORT || "3000", 10);
12
13const app = next({ dev, hostname, port, turbopack: false });
14const handle = app.getRequestHandler();
15
16const compressionMiddleware = compression({
17  threshold: 1024,
18  filter: (req, res) => {
19    const requestPath = req.url ?? "";
20    if (requestPath.includes("/stream")) {
21      return false;
22    }
23
24    const contentType = res.getHeader("Content-Type");
25    if (typeof contentType === "string" && contentType.includes("text/event-stream")) {
26      return false;
27    }
28
29    return compression.filter(req as never, res as never);
30  },
31}) as (
32  req: IncomingMessage,
33  res: ServerResponse<IncomingMessage>,
34  next: (error?: unknown) => void,
35) => void;
36
37async function applyCompression(
38  req: IncomingMessage,
39  res: ServerResponse<IncomingMessage>,
40) {
41  await new Promise<void>((resolve, reject) => {
42    compressionMiddleware(req, res, (error?: unknown) => {
43      if (error) {
44        reject(error);
45        return;
46      }
47
48      resolve();
49    });
50  });
51}
52
53process.on("uncaughtException", (error) => {
54  console.error("Uncaught exception:", error);
55  process.exit(1);
56});
57
58process.on("unhandledRejection", (reason) => {
59  console.error("Unhandled promise rejection:", reason);
60});
61
62async function main() {
63  await app.prepare();
64  void import("./lib/server/modules/files/path-resolver")
65    .then((module) => module.ensureFilesRootDirectories())
66    .catch((error: unknown) => {
67      const message = error instanceof Error ? error.message : String(error);
68      console.warn("⚠ Files root initialization warning:", message);
69    });
70
71  const shutdownHooks: Array<() => Promise<unknown> | unknown> = [];
72  const server = createServer(async (req, res) => {
73    try {
74      await applyCompression(req, res);
75      const parsedUrl = parse(req.url || "", true);
76      await handle(req, res, parsedUrl);
77    } catch (error) {
78      console.error("Error occurred handling", req.url, error);
79      res.statusCode = 500;
80      res.end("internal server error");
81    }
82  });
83  configureUpstreamKeepAlive(server);
84
85  // Initialize WebSocket server for terminal (optional feature).
86  // This gracefully fails if node-pty is not available.
87  void import("./lib/server/modules/terminal/websocket-server")
88    .then((module) => {
89      module.initializeWebSocketServer(server);
90      console.log("✓ Terminal WebSocket server initialized");
91    })
92    .catch((error: unknown) => {
93      const message = error instanceof Error ? error.message : String(error);
94      console.warn("⚠ Terminal feature not available:", message);
95      console.log("  The application will work without terminal functionality");
96      console.log("  To enable terminal, run: npm install @lydell/node-pty");
97    });
98
99  // Network storage watcher starts from files API route modules.
100  // Avoid eager server-level import here to keep startup runtime-only.
101
102  let shuttingDown = false;
103  const shutdown = async (signal: string) => {
104    if (shuttingDown) return;
105    shuttingDown = true;
106
107    console.log(`> Received ${signal}, shutting down...`);
108
109    await Promise.allSettled(
110      shutdownHooks.map(async (hook) => {
111        try {
112          await hook();
113        } catch (error) {
114          console.error("Shutdown hook failed", error);
115        }
116      }),
117    );
118
119    await closeServerGracefully(server);
120
121    process.exit(0);
122  };
123
124  process.on("SIGINT", () => {
125    void shutdown("SIGINT");
126  });
127  process.on("SIGTERM", () => {
128    void shutdown("SIGTERM");
129  });
130
131  server.listen(port, hostname, LISTEN_BACKLOG, (error?: Error) => {
132    if (error) throw error;
133    console.log(`> Ready on http://${hostname}:${port}`);
134  });
135}
136
137main().catch((error) => {
138  console.error("Failed to start server", error);
139  process.exit(1);
140});
141