homeio

1import { lstat, mkdtemp, mkdir, rm } from "node:fs/promises";
2import os from "node:os";
3import path from "node:path";
4import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
5
6let mockDataRoot = "";
7
8vi.mock("@/lib/server/modules/files/path-resolver", () => {
9  class FilesPathError extends Error {
10    code: string;
11    statusCode: number;
12
13    constructor(
14      message: string,
15      options?: {
16        code?: string;
17        statusCode?: number;
18      },
19    ) {
20      super(message);
21      this.code = options?.code ?? "internal_error";
22      this.statusCode = options?.statusCode ?? 500;
23    }
24  }
25
26  return {
27    FilesPathError,
28    resolvePathWithinFilesRoot: vi.fn(async (input: {
29      inputPath?: string;
30      requiredPrefix?: string;
31      allowMissingLeaf?: boolean;
32    }) => {
33      const cleaned = (input.inputPath ?? "").trim().replaceAll("\\", "/");
34      const normalized = cleaned ? path.posix.normalize(cleaned) : "";
35      if (normalized === ".." || normalized.startsWith("../")) {
36        throw new FilesPathError("Path escapes root", {
37          code: "path_outside_root",
38          statusCode: 400,
39        });
40      }
41
42      if (
43        input.requiredPrefix &&
44        normalized !== input.requiredPrefix &&
45        !normalized.startsWith(`${input.requiredPrefix}/`)
46      ) {
47        throw new FilesPathError("Invalid path", {
48          code: "invalid_path",
49          statusCode: 400,
50        });
51      }
52
53      return {
54        rootPath: mockDataRoot,
55        relativePath: normalized,
56        absolutePath: path.resolve(mockDataRoot, normalized),
57        segments: normalized ? normalized.split("/") : [],
58        exists: true,
59      };
60    }),
61  };
62});
63
64vi.mock("@/lib/server/modules/files/local-shares-repository", () => ({
65  listLocalSharesFromDb: vi.fn(),
66  getLocalShareFromDb: vi.fn(),
67  getLocalShareBySourcePathFromDb: vi.fn(),
68  insertLocalShareInDb: vi.fn(),
69  deleteLocalShareFromDb: vi.fn(),
70}));
71
72vi.mock("node:child_process", () => ({
73  execFile: vi.fn(),
74}));
75
76import { execFile } from "node:child_process";
77import {
78  addLocalFolderShare,
79  removeLocalFolderShare,
80  type LocalSharingError,
81} from "@/lib/server/modules/files/local-sharing";
82import {
83  deleteLocalShareFromDb,
84  getLocalShareBySourcePathFromDb,
85  getLocalShareFromDb,
86  insertLocalShareInDb,
87} from "@/lib/server/modules/files/local-shares-repository";
88
89type ExecFileCallback = (error: Error | null, stdout: string, stderr: string) => void;
90
91function getExecInvocation(restArgs: unknown[]) {
92  const callback = restArgs.at(-1);
93  if (typeof callback !== "function") {
94    throw new Error("Missing execFile callback");
95  }
96  const args = Array.isArray(restArgs[0]) ? (restArgs[0] as string[]) : [];
97  return {
98    args,
99    callback: callback as ExecFileCallback,
100  };
101}
102
103function uniqueViolation(constraint: string, detail: string) {
104  const error = new Error("duplicate key value violates unique constraint") as Error & {
105    code?: string;
106    constraint?: string;
107    detail?: string;
108  };
109  error.code = "23505";
110  error.constraint = constraint;
111  error.detail = detail;
112  return error;
113}
114
115describe("local sharing service", () => {
116  beforeEach(async () => {
117    mockDataRoot = await mkdtemp(path.join(os.tmpdir(), "home-server-local-sharing-"));
118    await mkdir(path.join(mockDataRoot, "Media"), { recursive: true });
119    await mkdir(path.join(mockDataRoot, "Shared"), { recursive: true });
120    vi.clearAllMocks();
121  });
122
123  afterEach(async () => {
124    if (mockDataRoot) {
125      await rm(mockDataRoot, { recursive: true, force: true });
126    }
127  });
128
129  it("rolls back reserved share and deletes db row when mount fails", async () => {
130    const reserved = {
131      id: "local-1",
132      shareName: "Media",
133      sourcePath: "Media",
134      sharedPath: "Shared/Media",
135      createdAt: new Date(),
136      updatedAt: new Date(),
137    };
138
139    vi.mocked(getLocalShareBySourcePathFromDb).mockResolvedValueOnce(null);
140    vi.mocked(insertLocalShareInDb).mockResolvedValueOnce(reserved);
141    vi.mocked(deleteLocalShareFromDb).mockResolvedValueOnce(reserved);
142
143    vi.mocked(execFile).mockImplementation((command: string, ...restArgs: unknown[]) => {
144      const { args, callback } = getExecInvocation(restArgs);
145
146      if (command === "mountpoint") {
147        const error = new Error("not mounted") as Error & {
148          code?: number;
149          stderr?: string;
150        };
151        error.code = 1;
152        error.stderr = "not mounted";
153        callback(error, "", "not mounted");
154        return {} as never;
155      }
156
157      if (command === "mount") {
158        const error = new Error("mount failed") as Error & {
159          code?: number;
160          stderr?: string;
161        };
162        error.code = 1;
163        error.stderr = "permission denied";
164        callback(error, "", "permission denied");
165        return {} as never;
166      }
167
168      if (command === "net" && args[0] === "usershare" && args[1] === "delete") {
169        const error = new Error("does not exist") as Error & {
170          code?: number;
171          stderr?: string;
172        };
173        error.code = 1;
174        error.stderr = "usershare does not exist";
175        callback(error, "", "usershare does not exist");
176        return {} as never;
177      }
178
179      if (command === "umount") {
180        const error = new Error("not mounted") as Error & {
181          code?: number;
182          stderr?: string;
183        };
184        error.code = 1;
185        error.stderr = "not mounted";
186        callback(error, "", "not mounted");
187        return {} as never;
188      }
189
190      callback(null, "", "");
191      return {} as never;
192    });
193
194    await expect(
195      addLocalFolderShare({
196        path: "Media",
197      }),
198    ).rejects.toMatchObject<Partial<LocalSharingError>>({
199      code: "permission_denied",
200      statusCode: 403,
201    });
202
203    expect(deleteLocalShareFromDb).toHaveBeenCalledWith("local-1");
204  });
205
206  it("maps source-path unique conflict to share_exists", async () => {
207    vi.mocked(getLocalShareBySourcePathFromDb).mockResolvedValueOnce(null);
208    vi.mocked(insertLocalShareInDb).mockRejectedValueOnce(
209      uniqueViolation(
210        "files_local_shares_source_path_idx",
211        "Key (source_path)=(Media) already exists.",
212      ),
213    );
214
215    await expect(
216      addLocalFolderShare({
217        path: "Media",
218      }),
219    ).rejects.toMatchObject<Partial<LocalSharingError>>({
220      code: "share_exists",
221      statusCode: 409,
222    });
223
224    expect(execFile).not.toHaveBeenCalled();
225  });
226
227  it("retries share-name conflicts and succeeds", async () => {
228    vi.mocked(getLocalShareBySourcePathFromDb).mockResolvedValue(null);
229    vi.mocked(insertLocalShareInDb)
230      .mockRejectedValueOnce(
231        uniqueViolation(
232          "files_local_shares_share_name_idx",
233          "Key (share_name)=(Media) already exists.",
234        ),
235      )
236      .mockResolvedValueOnce({
237        id: "local-2",
238        shareName: "Media-2",
239        sourcePath: "Media",
240        sharedPath: "Shared/Media-2",
241        createdAt: new Date(),
242        updatedAt: new Date(),
243      });
244
245    vi.mocked(execFile).mockImplementation((command: string, ...restArgs: unknown[]) => {
246      const { args, callback } = getExecInvocation(restArgs);
247
248      if (command === "mountpoint") {
249        const error = new Error("not mounted") as Error & { code?: number };
250        error.code = 1;
251        callback(error, "", "");
252        return {} as never;
253      }
254
255      if (command === "mount") {
256        callback(null, "", "");
257        return {} as never;
258      }
259
260      if (command === "net" && args[0] === "usershare" && args[1] === "add") {
261        callback(null, "", "");
262        return {} as never;
263      }
264
265      callback(null, "", "");
266      return {} as never;
267    });
268
269    const result = await addLocalFolderShare({
270      path: "Media",
271      name: "Media",
272    });
273
274    expect(result.shareName).toBe("Media-2");
275    expect(insertLocalShareInDb).toHaveBeenCalledTimes(2);
276  });
277
278  it("removes shared folder idempotently when usershare/mount are absent", async () => {
279    vi.mocked(getLocalShareFromDb).mockResolvedValueOnce({
280      id: "local-1",
281      shareName: "Media",
282      sourcePath: "Media",
283      sharedPath: "Shared/Media",
284      createdAt: new Date(),
285      updatedAt: new Date(),
286    });
287    vi.mocked(deleteLocalShareFromDb).mockResolvedValueOnce({
288      id: "local-1",
289      shareName: "Media",
290      sourcePath: "Media",
291      sharedPath: "Shared/Media",
292      createdAt: new Date(),
293      updatedAt: new Date(),
294    });
295
296    vi.mocked(execFile).mockImplementation((command: string, ...restArgs: unknown[]) => {
297      const { args, callback } = getExecInvocation(restArgs);
298
299      if (command === "mountpoint") {
300        const error = new Error("not mounted") as Error & {
301          code?: number;
302          stderr?: string;
303        };
304        error.code = 1;
305        error.stderr = "not mounted";
306        callback(error, "", "not mounted");
307        return {} as never;
308      }
309
310      if (command === "net" && args[0] === "usershare" && args[1] === "delete") {
311        const error = new Error("usershare does not exist") as Error & {
312          code?: number;
313          stderr?: string;
314        };
315        error.code = 1;
316        error.stderr = "usershare does not exist";
317        callback(error, "", "usershare does not exist");
318        return {} as never;
319      }
320
321      if (command === "umount") {
322        const error = new Error("not mounted") as Error & {
323          code?: number;
324          stderr?: string;
325        };
326        error.code = 1;
327        error.stderr = "not mounted";
328        callback(error, "", "not mounted");
329        return {} as never;
330      }
331
332      callback(null, "", "");
333      return {} as never;
334    });
335
336    const result = await removeLocalFolderShare("local-1");
337    expect(result.removed).toBe(true);
338    expect(deleteLocalShareFromDb).toHaveBeenCalledWith("local-1");
339  });
340
341  it("skips umount when share is already unmounted", async () => {
342    vi.mocked(getLocalShareFromDb).mockResolvedValueOnce({
343      id: "local-2",
344      shareName: "Media",
345      sourcePath: "Media",
346      sharedPath: "Shared/Media",
347      createdAt: new Date(),
348      updatedAt: new Date(),
349    });
350    vi.mocked(deleteLocalShareFromDb).mockResolvedValueOnce({
351      id: "local-2",
352      shareName: "Media",
353      sourcePath: "Media",
354      sharedPath: "Shared/Media",
355      createdAt: new Date(),
356      updatedAt: new Date(),
357    });
358
359    vi.mocked(execFile).mockImplementation((command: string, ...restArgs: unknown[]) => {
360      const { args, callback } = getExecInvocation(restArgs);
361
362      if (command === "net" && args[0] === "usershare" && args[1] === "info") {
363        const error = new Error("usershare does not exist") as Error & {
364          code?: number;
365          stderr?: string;
366        };
367        error.code = 1;
368        error.stderr = "usershare does not exist";
369        callback(error, "", "usershare does not exist");
370        return {} as never;
371      }
372
373      if (command === "mountpoint") {
374        const error = new Error("not mounted") as Error & {
375          code?: number;
376          stderr?: string;
377        };
378        error.code = 1;
379        error.stderr = "not mounted";
380        callback(error, "", "not mounted");
381        return {} as never;
382      }
383
384      if (command === "umount") {
385        callback(new Error("should not call umount"), "", "should not call umount");
386        return {} as never;
387      }
388
389      callback(null, "", "");
390      return {} as never;
391    });
392
393    const result = await removeLocalFolderShare("local-2");
394
395    expect(result.removed).toBe(true);
396    expect(deleteLocalShareFromDb).toHaveBeenCalledWith("local-2");
397    expect(execFile).not.toHaveBeenCalledWith(
398      "umount",
399      expect.any(Array),
400      expect.any(Function),
401    );
402  });
403
404  it("removes stale db record when usershare delete is permission-denied but mount is absent", async () => {
405    vi.mocked(getLocalShareFromDb).mockResolvedValueOnce({
406      id: "local-usershare-perm",
407      shareName: "Media",
408      sourcePath: "Media",
409      sharedPath: "Shared/Media",
410      createdAt: new Date(),
411      updatedAt: new Date(),
412    });
413    vi.mocked(deleteLocalShareFromDb).mockResolvedValueOnce({
414      id: "local-usershare-perm",
415      shareName: "Media",
416      sourcePath: "Media",
417      sharedPath: "Shared/Media",
418      createdAt: new Date(),
419      updatedAt: new Date(),
420    });
421
422    let usershareInfoCalls = 0;
423    vi.mocked(execFile).mockImplementation((command: string, ...restArgs: unknown[]) => {
424      const { args, callback } = getExecInvocation(restArgs);
425
426      if (command === "mountpoint") {
427        const error = new Error("not mounted") as Error & {
428          code?: number;
429          stderr?: string;
430        };
431        error.code = 1;
432        error.stderr = "not mounted";
433        callback(error, "", "not mounted");
434        return {} as never;
435      }
436
437      if (command === "net" && args[0] === "usershare" && args[1] === "info") {
438        usershareInfoCalls += 1;
439        callback(null, "share present", "");
440        return {} as never;
441      }
442
443      if (command === "net" && args[0] === "usershare" && args[1] === "delete") {
444        const error = new Error("permission denied") as Error & {
445          code?: number;
446          stderr?: string;
447        };
448        error.code = 1;
449        error.stderr = "permission denied";
450        callback(error, "", "permission denied");
451        return {} as never;
452      }
453
454      callback(null, "", "");
455      return {} as never;
456    });
457
458    const result = await removeLocalFolderShare("local-usershare-perm");
459
460    expect(result.removed).toBe(true);
461    expect(deleteLocalShareFromDb).toHaveBeenCalledWith("local-usershare-perm");
462    expect(usershareInfoCalls).toBeGreaterThanOrEqual(1);
463  });
464
465  it("falls back to lazy umount when unmount target is busy", async () => {
466    vi.mocked(getLocalShareFromDb).mockResolvedValueOnce({
467      id: "local-3",
468      shareName: "Media",
469      sourcePath: "Media",
470      sharedPath: "Shared/Media",
471      createdAt: new Date(),
472      updatedAt: new Date(),
473    });
474    vi.mocked(deleteLocalShareFromDb).mockResolvedValueOnce({
475      id: "local-3",
476      shareName: "Media",
477      sourcePath: "Media",
478      sharedPath: "Shared/Media",
479      createdAt: new Date(),
480      updatedAt: new Date(),
481    });
482
483    let mountpointCallCount = 0;
484    vi.mocked(execFile).mockImplementation((command: string, ...restArgs: unknown[]) => {
485      const { args, callback } = getExecInvocation(restArgs);
486
487      if (command === "net" && args[0] === "usershare" && args[1] === "info") {
488        callback(null, "share present", "");
489        return {} as never;
490      }
491
492      if (command === "mountpoint") {
493        mountpointCallCount += 1;
494        if (mountpointCallCount === 1) {
495          callback(null, "", "");
496          return {} as never;
497        }
498        const error = new Error("not mounted") as Error & {
499          code?: number;
500          stderr?: string;
501        };
502        error.code = 1;
503        error.stderr = "not mounted";
504        callback(error, "", "not mounted");
505        return {} as never;
506      }
507
508      if (command === "net" && args[0] === "usershare" && args[1] === "delete") {
509        callback(null, "", "");
510        return {} as never;
511      }
512
513      if (command === "umount" && args[0] === "-l") {
514        callback(null, "", "");
515        return {} as never;
516      }
517
518      if (command === "umount") {
519        const error = new Error("target is busy") as Error & {
520          code?: number;
521          stderr?: string;
522        };
523        error.code = 32;
524        error.stderr = "target is busy";
525        callback(error, "", "target is busy");
526        return {} as never;
527      }
528
529      callback(null, "", "");
530      return {} as never;
531    });
532
533    const result = await removeLocalFolderShare("local-3");
534
535    expect(result.removed).toBe(true);
536    expect(deleteLocalShareFromDb).toHaveBeenCalledWith("local-3");
537    expect(execFile).toHaveBeenCalledWith(
538      "umount",
539      ["-l", expect.stringContaining("Shared/Media")],
540      expect.anything(),
541      expect.any(Function),
542    );
543  });
544
545  it("removes db record when cleanup command fails but share is already inactive", async () => {
546    vi.mocked(getLocalShareFromDb).mockResolvedValueOnce({
547      id: "local-4",
548      shareName: "Media",
549      sourcePath: "Media",
550      sharedPath: "Shared/Media",
551      createdAt: new Date(),
552      updatedAt: new Date(),
553    });
554    vi.mocked(deleteLocalShareFromDb).mockResolvedValueOnce({
555      id: "local-4",
556      shareName: "Media",
557      sourcePath: "Media",
558      sharedPath: "Shared/Media",
559      createdAt: new Date(),
560      updatedAt: new Date(),
561    });
562
563    let mountpointCallCount = 0;
564    vi.mocked(execFile).mockImplementation((command: string, ...restArgs: unknown[]) => {
565      const { args, callback } = getExecInvocation(restArgs);
566
567      if (command === "net" && args[0] === "usershare" && args[1] === "info") {
568        const error = new Error("usershare does not exist") as Error & {
569          code?: number;
570          stderr?: string;
571        };
572        error.code = 1;
573        error.stderr = "usershare does not exist";
574        callback(error, "", "usershare does not exist");
575        return {} as never;
576      }
577
578      if (command === "mountpoint") {
579        mountpointCallCount += 1;
580        if (mountpointCallCount === 1) {
581          callback(null, "", "");
582          return {} as never;
583        }
584        const error = new Error("not mounted") as Error & {
585          code?: number;
586          stderr?: string;
587        };
588        error.code = 1;
589        error.stderr = "not mounted";
590        callback(error, "", "not mounted");
591        return {} as never;
592      }
593
594      if (command === "umount") {
595        const error = new Error("permission denied") as Error & {
596          code?: number;
597          stderr?: string;
598        };
599        error.code = 1;
600        error.stderr = "permission denied";
601        callback(error, "", "permission denied");
602        return {} as never;
603      }
604
605      callback(null, "", "");
606      return {} as never;
607    });
608
609    const result = await removeLocalFolderShare("local-4");
610
611    expect(result.removed).toBe(true);
612    expect(deleteLocalShareFromDb).toHaveBeenCalledWith("local-4");
613  });
614
615  it("removes stale db record when shared path is no longer valid", async () => {
616    vi.mocked(getLocalShareFromDb).mockResolvedValueOnce({
617      id: "local-stale",
618      shareName: "Media",
619      sourcePath: "Media",
620      sharedPath: "Network/Media",
621      createdAt: new Date(),
622      updatedAt: new Date(),
623    });
624    vi.mocked(deleteLocalShareFromDb).mockResolvedValueOnce({
625      id: "local-stale",
626      shareName: "Media",
627      sourcePath: "Media",
628      sharedPath: "Network/Media",
629      createdAt: new Date(),
630      updatedAt: new Date(),
631    });
632
633    const result = await removeLocalFolderShare("local-stale");
634
635    expect(result.removed).toBe(true);
636    expect(deleteLocalShareFromDb).toHaveBeenCalledWith("local-stale");
637  });
638
639  it("removes exported shared directory contents when unshare succeeds", async () => {
640    const exportedDir = path.join(mockDataRoot, "Shared", "Media");
641    await mkdir(exportedDir, { recursive: true });
642    await mkdir(path.join(exportedDir, "nested"), { recursive: true });
643
644    vi.mocked(getLocalShareFromDb).mockResolvedValueOnce({
645      id: "local-cleanup-dir",
646      shareName: "Media",
647      sourcePath: "Media",
648      sharedPath: "Shared/Media",
649      createdAt: new Date(),
650      updatedAt: new Date(),
651    });
652    vi.mocked(deleteLocalShareFromDb).mockResolvedValueOnce({
653      id: "local-cleanup-dir",
654      shareName: "Media",
655      sourcePath: "Media",
656      sharedPath: "Shared/Media",
657      createdAt: new Date(),
658      updatedAt: new Date(),
659    });
660
661    vi.mocked(execFile).mockImplementation((command: string, ...restArgs: unknown[]) => {
662      const { args, callback } = getExecInvocation(restArgs);
663
664      if (command === "net" && args[0] === "usershare" && args[1] === "info") {
665        callback(null, "share present", "");
666        return {} as never;
667      }
668
669      if (command === "mountpoint") {
670        const error = new Error("not mounted") as Error & {
671          code?: number;
672          stderr?: string;
673        };
674        error.code = 1;
675        error.stderr = "not mounted";
676        callback(error, "", "not mounted");
677        return {} as never;
678      }
679
680      if (command === "net" && args[0] === "usershare" && args[1] === "delete") {
681        callback(null, "", "");
682        return {} as never;
683      }
684
685      callback(null, "", "");
686      return {} as never;
687    });
688
689    const result = await removeLocalFolderShare("local-cleanup-dir");
690
691    expect(result.removed).toBe(true);
692    await expect(lstat(exportedDir)).rejects.toMatchObject({ code: "ENOENT" });
693  });
694
695  it("serializes concurrent add requests for the same source path", async () => {
696    let sourceReserved = false;
697
698    vi.mocked(getLocalShareBySourcePathFromDb).mockImplementation(async () => {
699      if (!sourceReserved) return null;
700      return {
701        id: "local-1",
702        shareName: "Media",
703        sourcePath: "Media",
704        sharedPath: "Shared/Media",
705        createdAt: new Date(),
706        updatedAt: new Date(),
707      };
708    });
709
710    vi.mocked(insertLocalShareInDb).mockImplementation(async (input) => {
711      if (sourceReserved) {
712        throw uniqueViolation(
713          "files_local_shares_source_path_idx",
714          "Key (source_path)=(Media) already exists.",
715        );
716      }
717      sourceReserved = true;
718      return {
719        id: input.id,
720        shareName: input.shareName,
721        sourcePath: input.sourcePath,
722        sharedPath: input.sharedPath,
723        createdAt: new Date(),
724        updatedAt: new Date(),
725      };
726    });
727
728    vi.mocked(execFile).mockImplementation((command: string, ...restArgs: unknown[]) => {
729      const { args, callback } = getExecInvocation(restArgs);
730
731      if (command === "mountpoint") {
732        const error = new Error("not mounted") as Error & { code?: number };
733        error.code = 1;
734        callback(error, "", "");
735        return {} as never;
736      }
737
738      if (command === "mount") {
739        setTimeout(() => callback(null, "", ""), 30);
740        return {} as never;
741      }
742
743      if (command === "net" && args[0] === "usershare" && args[1] === "add") {
744        callback(null, "", "");
745        return {} as never;
746      }
747
748      callback(null, "", "");
749      return {} as never;
750    });
751
752    const results = await Promise.allSettled([
753      addLocalFolderShare({ path: "Media" }),
754      addLocalFolderShare({ path: "Media" }),
755    ]);
756
757    const fulfilled = results.filter(
758      (result): result is PromiseFulfilledResult<Awaited<ReturnType<typeof addLocalFolderShare>>> =>
759        result.status === "fulfilled",
760    );
761    const rejected = results.filter(
762      (result): result is PromiseRejectedResult => result.status === "rejected",
763    );
764
765    expect(fulfilled).toHaveLength(1);
766    expect(rejected).toHaveLength(1);
767    expect(rejected[0]?.reason).toMatchObject({
768      code: "share_exists",
769      statusCode: 409,
770    });
771  });
772});
773