homeio

1import "server-only";
2
3import { request } from "node:http";
4import { serverEnv } from "@/lib/server/env";
5import type { DockerPullProgressDetail } from "@/lib/shared/contracts/apps";
6
7type DockerProgressDetailRaw = {
8  current?: unknown;
9  total?: unknown;
10};
11
12type DockerPullEventRaw = {
13  status?: unknown;
14  id?: unknown;
15  progress?: unknown;
16  progressDetail?: DockerProgressDetailRaw;
17  error?: unknown;
18};
19
20export type DockerPullEvent = {
21  status: string;
22  id?: string;
23  progress?: string;
24  progressDetail?: DockerPullProgressDetail;
25  error?: string;
26};
27
28function toNumber(value: unknown) {
29  return typeof value === "number" && Number.isFinite(value) ? value : 0;
30}
31
32function toStringOrUndefined(value: unknown) {
33  return typeof value === "string" ? value : undefined;
34}
35
36export function normalizeDockerProgressDetail(
37  value: DockerProgressDetailRaw | undefined,
38): DockerPullProgressDetail | undefined {
39  if (!value) return undefined;
40
41  const current = toNumber(value.current);
42  const total = toNumber(value.total);
43  const percent = total > 0 ? Number(((current / total) * 100).toFixed(2)) : null;
44
45  return {
46    current,
47    total,
48    percent,
49  };
50}
51
52export function parseDockerPullEvent(value: unknown): DockerPullEvent | null {
53  if (!value || typeof value !== "object") {
54    return null;
55  }
56
57  const raw = value as DockerPullEventRaw;
58  const status = toStringOrUndefined(raw.status) ?? "unknown";
59  const parsed: DockerPullEvent = {
60    status,
61  };
62
63  const id = toStringOrUndefined(raw.id);
64  if (id) parsed.id = id;
65
66  const progress = toStringOrUndefined(raw.progress);
67  if (progress) parsed.progress = progress;
68
69  const progressDetail = normalizeDockerProgressDetail(raw.progressDetail);
70  if (progressDetail) parsed.progressDetail = progressDetail;
71
72  const error = toStringOrUndefined(raw.error);
73  if (error) parsed.error = error;
74
75  return parsed;
76}
77
78export async function pullDockerImage(
79  image: string,
80  onEvent?: (event: DockerPullEvent) => Promise<void> | void,
81) {
82  const path = `/images/create?fromImage=${encodeURIComponent(image)}`;
83
84  await new Promise<void>((resolve, reject) => {
85    const req = request(
86      {
87        socketPath: serverEnv.DOCKER_SOCKET_PATH,
88        path,
89        method: "POST",
90        headers: {
91          Host: "docker",
92        },
93      },
94      (res) => {
95        if (res.statusCode && res.statusCode >= 400) {
96          let body = "";
97          res.setEncoding("utf8");
98          res.on("data", (chunk) => {
99            body += chunk;
100          });
101          res.on("end", () => {
102            reject(new Error(`Docker pull failed (${res.statusCode}): ${body}`));
103          });
104          return;
105        }
106
107        let buffered = "";
108
109        const handleLine = async (line: string) => {
110          const trimmed = line.trim();
111          if (!trimmed) return;
112
113          let raw: unknown;
114          try {
115            raw = JSON.parse(trimmed);
116          } catch {
117            return;
118          }
119
120          const event = parseDockerPullEvent(raw);
121          if (!event) return;
122
123          if (event.error) {
124            throw new Error(event.error);
125          }
126
127          if (onEvent) {
128            await onEvent(event);
129          }
130        };
131
132        res.on("data", (chunk) => {
133          buffered += chunk.toString("utf8");
134          const lines = buffered.split("\n");
135          buffered = lines.pop() ?? "";
136
137          void (async () => {
138            for (const line of lines) {
139              await handleLine(line);
140            }
141          })().catch((error) => {
142            req.destroy(error as Error);
143          });
144        });
145
146        res.on("end", () => {
147          void (async () => {
148            if (buffered.trim().length > 0) {
149              await handleLine(buffered);
150            }
151          })()
152            .then(() => resolve())
153            .catch(reject);
154        });
155      },
156    );
157
158    req.on("error", (error) => {
159      reject(error);
160    });
161
162    req.end();
163  });
164}
165