homeio

1import { spawn } from "node:child_process";
2import path from "node:path";
3import { type NextRequest, NextResponse } from "next/server";
4import { serverEnv } from "@/lib/server/env";
5import { requireApiSession } from "@/lib/server/modules/auth/api";
6import {
7  createRequestId,
8  logServerAction,
9  withServerTiming,
10} from "@/lib/server/logging/logger";
11import {
12  FileServiceError,
13  resolveDownloadableFolderAbsolutePath,
14} from "@/lib/server/modules/files/service";
15
16export const runtime = "nodejs";
17// Zip can take a while for large folders
18export const maxDuration = 120;
19
20function toAttachmentFilename(name: string) {
21  const safe = name.replaceAll('"', "").replaceAll("/", "_");
22  return `attachment; filename="${safe}.zip"`;
23}
24
25export async function GET(request: NextRequest) {
26  const apiSession = await requireApiSession(request);
27  if (apiSession.response) return apiSession.response;
28  const requestId = createRequestId();
29
30  try {
31    return await withServerTiming(
32      {
33        layer: "api",
34        action: "files.zip.get",
35        requestId,
36      },
37      async () => {
38        const folderPath = request.nextUrl.searchParams.get("path");
39        if (!folderPath) {
40          return NextResponse.json(
41            { error: "Missing folder path", code: "invalid_path" },
42            { status: 400 },
43          );
44        }
45
46        const includeHidden =
47          serverEnv.FILES_ALLOW_HIDDEN &&
48          request.nextUrl.searchParams.get("includeHidden") === "true";
49
50        const resolved = await resolveDownloadableFolderAbsolutePath({
51          path: folderPath,
52          includeHidden,
53        });
54
55        // Stream the zip output directly using system zip
56        // `zip -r - <folderName>` in the parent directory writes to stdout
57        const zipStream = new ReadableStream({
58          start(controller) {
59            const proc = spawn(
60              "zip",
61              ["-r", "-", resolved.folderName],
62              { cwd: resolved.parentAbsolutePath },
63            );
64
65            proc.stdout.on("data", (chunk: Buffer) => {
66              controller.enqueue(chunk);
67            });
68
69            proc.stderr.on("data", (chunk: Buffer) => {
70              logServerAction({
71                level: "warn",
72                layer: "api",
73                action: "files.zip.get",
74                requestId,
75                message: `zip stderr: ${chunk.toString()}`,
76              });
77            });
78
79            proc.on("close", (code) => {
80              if (code === 0) {
81                controller.close();
82              } else {
83                controller.error(new Error(`zip exited with code ${code}`));
84              }
85            });
86
87            proc.on("error", (err) => {
88              controller.error(err);
89            });
90          },
91        });
92
93        const folderBaseName = path.basename(resolved.folderName);
94
95        return new NextResponse(zipStream, {
96          status: 200,
97          headers: {
98            "Content-Type": "application/zip",
99            "Content-Disposition": toAttachmentFilename(folderBaseName),
100            "Cache-Control": "no-store",
101            "Transfer-Encoding": "chunked",
102          },
103        });
104      },
105    );
106  } catch (error) {
107    if (error instanceof FileServiceError) {
108      return NextResponse.json(
109        { error: error.message, code: error.code },
110        { status: error.statusCode },
111      );
112    }
113
114    logServerAction({
115      level: "error",
116      layer: "api",
117      action: "files.zip.get.response",
118      status: "error",
119      requestId,
120      message: "Unable to zip folder",
121      error,
122    });
123
124    return NextResponse.json(
125      { error: "Unable to zip folder", code: "internal_error" },
126      { status: 500 },
127    );
128  }
129}
130