@torrent-tv/proxy 2.87.21 → 2.88.0

package/test/client-log-file.test.js

@@ -1,110 +1,110 @@
-/**
- * @file The browser's log, written beside the proxy's.
- *
- * What these hold is the naming, because the name is the whole point: the two
- * halves of a session have to join without guessing, and a torrent name is
- * arbitrary bytes chosen by a stranger that is about to become a path.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, readdirSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { createClientLogFiles } from "../utils/client-log-file.js";
-
-/** A directory with a proxy log in it, which is what the sink is given. */
-function aDirectory() {
-  const dir = mkdtempSync(join(tmpdir(), "ttv-client-log-"));
-  return { dir, proxyLog: join(dir, "proxy.log") };
-}
-
-const aSession = (over = {}) => ({
-  sessionId: "abcd1234",
-  startedAt: "2026-09-13T16:05:24.123Z",
-  torrentName: "Reacher.S04E07.1080p.rus.LostFilm.TV.mkv",
-  infoHash: "94dda59fdf252447d6ca5a8775dab2d11a832da5",
-  ...over
-});
-
-test("the file lands beside the proxy log, named by when it started and what is watched", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession(), ["first line"]);
-  await logs.close();
-
-  const [name] = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.ok(name, "a client log file was written");
-  // The stamp is UTC and sorts; the session id joins it to the proxy's lines;
-  // the film says which one it is without opening the file.
-  assert.match(name, /^client-20260913-160524-abcd1234-Reacher\.S04E07\.1080p\.rus\.LostFilm\.TV\.mkv-94dda59f\.log$/);
-  assert.equal(readFileSync(join(dir, name), "utf8"), "first line\n");
-});
-
-test("lines from one session go on appending to the one file", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession(), ["one", "two"]);
-  logs.write(aSession(), ["three"]);
-  await logs.close();
-
-  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.equal(names.length, 1);
-  assert.equal(readFileSync(join(dir, names[0]), "utf8"), "one\ntwo\nthree\n");
-});
-
-test("a session that has not chosen a film yet still gets its own file", async () => {
-  // The page opening, a proxy being chosen, a connection failing — all before
-  // any torrent exists, and all worth keeping.
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ torrentName: "", infoHash: "" }), ["before any film"]);
-  await logs.close();
-
-  const [name] = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.match(name, /-no-torrent-yet\.log$/);
-});
-
-test("the file keeps its name when the film arrives mid-session", async () => {
-  // Keyed by the session, not by the name: the earlier lines belong to the same
-  // viewing and must not start a second file.
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ torrentName: "", infoHash: "" }), ["before"]);
-  logs.write(aSession(), ["after"]);
-  await logs.close();
-
-  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.equal(names.length, 1);
-  assert.match(names[0], /-no-torrent-yet\.log$/);
-  assert.equal(readFileSync(join(dir, names[0]), "utf8"), "before\nafter\n");
-});
-
-test("a hostile torrent name cannot escape the directory", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ torrentName: "../../etc/passwd" }), ["x"]);
-  await logs.close();
-
-  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.equal(names.length, 1);
-  assert.ok(!names[0].includes(".."), `no traversal in ${names[0]}`);
-  assert.ok(!names[0].includes("/"), `no separator in ${names[0]}`);
-});
-
-test("two sessions of one film are two files", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ sessionId: "aaaa1111" }), ["one viewer"]);
-  logs.write(aSession({ sessionId: "bbbb2222", startedAt: "2026-09-13T16:07:11.000Z" }), ["another"]);
-  await logs.close();
-
-  assert.equal(readdirSync(dir).filter((f) => f.startsWith("client-")).length, 2);
-});
-
-test("no proxy log path means nothing is written and nothing throws", async () => {
-  const logs = createClientLogFiles("");
-  logs.write(aSession(), ["dropped"]);
-  await logs.close();
-});
+/**
+ * @file The browser's log, written beside the proxy's.
+ *
+ * What these hold is the naming, because the name is the whole point: the two
+ * halves of a session have to join without guessing, and a torrent name is
+ * arbitrary bytes chosen by a stranger that is about to become a path.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readdirSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { createClientLogFiles } from "../utils/client-log-file.js";
+
+/** A directory with a proxy log in it, which is what the sink is given. */
+function aDirectory() {
+  const dir = mkdtempSync(join(tmpdir(), "ttv-client-log-"));
+  return { dir, proxyLog: join(dir, "proxy.log") };
+}
+
+const aSession = (over = {}) => ({
+  sessionId: "abcd1234",
+  startedAt: "2026-09-13T16:05:24.123Z",
+  torrentName: "Reacher.S04E07.1080p.rus.LostFilm.TV.mkv",
+  infoHash: "94dda59fdf252447d6ca5a8775dab2d11a832da5",
+  ...over
+});
+
+test("the file lands beside the proxy log, named by when it started and what is watched", async () => {
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession(), ["first line"]);
+  await logs.close();
+
+  const [name] = readdirSync(dir).filter((f) => f.startsWith("client-"));
+  assert.ok(name, "a client log file was written");
+  // The stamp is UTC and sorts; the session id joins it to the proxy's lines;
+  // the film says which one it is without opening the file.
+  assert.match(name, /^client-20260913-160524-abcd1234-Reacher\.S04E07\.1080p\.rus\.LostFilm\.TV\.mkv-94dda59f\.log$/);
+  assert.equal(readFileSync(join(dir, name), "utf8"), "first line\n");
+});
+
+test("lines from one session go on appending to the one file", async () => {
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession(), ["one", "two"]);
+  logs.write(aSession(), ["three"]);
+  await logs.close();
+
+  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
+  assert.equal(names.length, 1);
+  assert.equal(readFileSync(join(dir, names[0]), "utf8"), "one\ntwo\nthree\n");
+});
+
+test("a session that has not chosen a film yet still gets its own file", async () => {
+  // The page opening, a proxy being chosen, a connection failing — all before
+  // any torrent exists, and all worth keeping.
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession({ torrentName: "", infoHash: "" }), ["before any film"]);
+  await logs.close();
+
+  const [name] = readdirSync(dir).filter((f) => f.startsWith("client-"));
+  assert.match(name, /-no-torrent-yet\.log$/);
+});
+
+test("the file keeps its name when the film arrives mid-session", async () => {
+  // Keyed by the session, not by the name: the earlier lines belong to the same
+  // viewing and must not start a second file.
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession({ torrentName: "", infoHash: "" }), ["before"]);
+  logs.write(aSession(), ["after"]);
+  await logs.close();
+
+  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
+  assert.equal(names.length, 1);
+  assert.match(names[0], /-no-torrent-yet\.log$/);
+  assert.equal(readFileSync(join(dir, names[0]), "utf8"), "before\nafter\n");
+});
+
+test("a hostile torrent name cannot escape the directory", async () => {
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession({ torrentName: "../../etc/passwd" }), ["x"]);
+  await logs.close();
+
+  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
+  assert.equal(names.length, 1);
+  assert.ok(!names[0].includes(".."), `no traversal in ${names[0]}`);
+  assert.ok(!names[0].includes("/"), `no separator in ${names[0]}`);
+});
+
+test("two sessions of one film are two files", async () => {
+  const { dir, proxyLog } = aDirectory();
+  const logs = createClientLogFiles(proxyLog);
+  logs.write(aSession({ sessionId: "aaaa1111" }), ["one viewer"]);
+  logs.write(aSession({ sessionId: "bbbb2222", startedAt: "2026-09-13T16:07:11.000Z" }), ["another"]);
+  await logs.close();
+
+  assert.equal(readdirSync(dir).filter((f) => f.startsWith("client-")).length, 2);
+});
+
+test("no proxy log path means nothing is written and nothing throws", async () => {
+  const logs = createClientLogFiles("");
+  logs.write(aSession(), ["dropped"]);
+  await logs.close();
+});

package/test/completed-files.test.js

@@ -1,115 +1,115 @@
-/**
- * @file Files downloaded whole are files, and outlive the torrent that fetched
- * them.
- *
- * Asked for in these words on 2026-09-11: as soon as a torrent is fully
- * downloaded, downloading stops, the torrent is deleted, and the artefacts —
- * what was downloaded — stay for as long as they are wanted.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { Readable } from "node:stream";
-import { CompletedFiles } from "../services/storage/files/CompletedFiles.js";
-
-const INFO_HASH = "abcdef0123456789abcdef0123456789abcdef01";
-
-/** @returns {Promise<string>} */
-const directory = () => fs.mkdtemp(path.join(os.tmpdir(), "whole-files-"));
-
-/**
- * @param {Buffer} bytes
- * @param {number} [chunk]
- * @returns {() => NodeJS.ReadableStream}
- */
-const opens = (bytes, chunk = 7) => () => {
-  const parts = [];
-  for (let at = 0; at < bytes.length; at += chunk) {
-    parts.push(bytes.subarray(at, Math.min(at + chunk, bytes.length)));
-  }
-  return Readable.from(parts);
-};
-
-test("a file read whole is kept whole, and reads back byte for byte", async () => {
-  const root = await directory();
-  const files = new CompletedFiles({ root });
-  const bytes = Buffer.from("the whole of a small film", "utf8");
-  try {
-    const kept = await files.keep({ infoHash: INFO_HASH, fileIndex: 3, length: bytes.length, name: "film.mkv", open: opens(bytes) });
-    assert.ok(kept, "the file was not kept");
-    assert.equal(kept.length, bytes.length);
-
-    const found = files.find(INFO_HASH, 3);
-    assert.deepEqual(found, kept, "what was kept is not what is found");
-    assert.deepEqual(await fs.readFile(found.path), bytes, "the bytes came back changed");
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("a read that ends early leaves nothing that looks whole", async () => {
-  const root = await directory();
-  const files = new CompletedFiles({ root });
-  const bytes = Buffer.from("half a film", "utf8");
-  try {
-    // The torrent says the file is longer than what its read produced — the
-    // data went away mid-write, which over a torrent is ordinary.
-    const kept = await files.keep({
-      infoHash: INFO_HASH,
-      fileIndex: 0,
-      length: bytes.length + 100,
-      open: opens(bytes)
-    });
-    assert.equal(kept, null, "a short file was kept as whole");
-    assert.equal(files.find(INFO_HASH, 0), null);
-    assert.deepEqual(
-      (await fs.readdir(path.join(root, INFO_HASH))).filter((entry) => entry !== "manifest.json"),
-      [],
-      "a partial file was left behind"
-    );
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("what a previous life left is taken up, and what is the wrong size is not", async () => {
-  const root = await directory();
-  const bytes = Buffer.from("a film from the last time this ran", "utf8");
-  try {
-    const first = new CompletedFiles({ root });
-    await first.keep({ infoHash: INFO_HASH, fileIndex: 2, length: bytes.length, name: "film.mkv", open: opens(bytes) });
-    // And one that was being written when the process died, under a name that
-    // says it is whole — the only way to tell is its size.
-    await fs.writeFile(path.join(root, INFO_HASH, "5"), Buffer.alloc(3));
-
-    const second = new CompletedFiles({ root });
-    const adopted = await second.adopt((infoHash, fileIndex) =>
-      infoHash === INFO_HASH && fileIndex === 2 ? bytes.length : 999
-    );
-    assert.equal(adopted, 1, "the whole file was not taken up, or the short one was");
-    assert.equal(second.find(INFO_HASH, 2)?.name, "film.mkv", "the name the torrent gave it was lost");
-    assert.equal(second.find(INFO_HASH, 5), null, "a file of the wrong size was taken up");
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("forgetting a torrent removes its files and nobody else's", async () => {
-  const root = await directory();
-  const files = new CompletedFiles({ root });
-  const other = "0123456789abcdef0123456789abcdef01234567";
-  const bytes = Buffer.from("kept", "utf8");
-  try {
-    await files.keep({ infoHash: INFO_HASH, fileIndex: 1, length: bytes.length, name: "one.mkv", open: opens(bytes) });
-    await files.keep({ infoHash: other, fileIndex: 1, length: bytes.length, name: "two.mkv", open: opens(bytes) });
-
-    await files.forget(INFO_HASH);
-    assert.equal(files.find(INFO_HASH, 1), null);
-    assert.ok(files.find(other, 1), "another torrent's file went with it");
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
+/**
+ * @file Files downloaded whole are files, and outlive the torrent that fetched
+ * them.
+ *
+ * Asked for in these words on 2026-09-11: as soon as a torrent is fully
+ * downloaded, downloading stops, the torrent is deleted, and the artefacts —
+ * what was downloaded — stay for as long as they are wanted.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { CompletedFiles } from "../services/storage/files/CompletedFiles.js";
+
+const INFO_HASH = "abcdef0123456789abcdef0123456789abcdef01";
+
+/** @returns {Promise<string>} */
+const directory = () => fs.mkdtemp(path.join(os.tmpdir(), "whole-files-"));
+
+/**
+ * @param {Buffer} bytes
+ * @param {number} [chunk]
+ * @returns {() => NodeJS.ReadableStream}
+ */
+const opens = (bytes, chunk = 7) => () => {
+  const parts = [];
+  for (let at = 0; at < bytes.length; at += chunk) {
+    parts.push(bytes.subarray(at, Math.min(at + chunk, bytes.length)));
+  }
+  return Readable.from(parts);
+};
+
+test("a file read whole is kept whole, and reads back byte for byte", async () => {
+  const root = await directory();
+  const files = new CompletedFiles({ root });
+  const bytes = Buffer.from("the whole of a small film", "utf8");
+  try {
+    const kept = await files.keep({ infoHash: INFO_HASH, fileIndex: 3, length: bytes.length, name: "film.mkv", open: opens(bytes) });
+    assert.ok(kept, "the file was not kept");
+    assert.equal(kept.length, bytes.length);
+
+    const found = files.find(INFO_HASH, 3);
+    assert.deepEqual(found, kept, "what was kept is not what is found");
+    assert.deepEqual(await fs.readFile(found.path), bytes, "the bytes came back changed");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("a read that ends early leaves nothing that looks whole", async () => {
+  const root = await directory();
+  const files = new CompletedFiles({ root });
+  const bytes = Buffer.from("half a film", "utf8");
+  try {
+    // The torrent says the file is longer than what its read produced — the
+    // data went away mid-write, which over a torrent is ordinary.
+    const kept = await files.keep({
+      infoHash: INFO_HASH,
+      fileIndex: 0,
+      length: bytes.length + 100,
+      open: opens(bytes)
+    });
+    assert.equal(kept, null, "a short file was kept as whole");
+    assert.equal(files.find(INFO_HASH, 0), null);
+    assert.deepEqual(
+      (await fs.readdir(path.join(root, INFO_HASH))).filter((entry) => entry !== "manifest.json"),
+      [],
+      "a partial file was left behind"
+    );
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("what a previous life left is taken up, and what is the wrong size is not", async () => {
+  const root = await directory();
+  const bytes = Buffer.from("a film from the last time this ran", "utf8");
+  try {
+    const first = new CompletedFiles({ root });
+    await first.keep({ infoHash: INFO_HASH, fileIndex: 2, length: bytes.length, name: "film.mkv", open: opens(bytes) });
+    // And one that was being written when the process died, under a name that
+    // says it is whole — the only way to tell is its size.
+    await fs.writeFile(path.join(root, INFO_HASH, "5"), Buffer.alloc(3));
+
+    const second = new CompletedFiles({ root });
+    const adopted = await second.adopt((infoHash, fileIndex) =>
+      infoHash === INFO_HASH && fileIndex === 2 ? bytes.length : 999
+    );
+    assert.equal(adopted, 1, "the whole file was not taken up, or the short one was");
+    assert.equal(second.find(INFO_HASH, 2)?.name, "film.mkv", "the name the torrent gave it was lost");
+    assert.equal(second.find(INFO_HASH, 5), null, "a file of the wrong size was taken up");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
+test("forgetting a torrent removes its files and nobody else's", async () => {
+  const root = await directory();
+  const files = new CompletedFiles({ root });
+  const other = "0123456789abcdef0123456789abcdef01234567";
+  const bytes = Buffer.from("kept", "utf8");
+  try {
+    await files.keep({ infoHash: INFO_HASH, fileIndex: 1, length: bytes.length, name: "one.mkv", open: opens(bytes) });
+    await files.keep({ infoHash: other, fileIndex: 1, length: bytes.length, name: "two.mkv", open: opens(bytes) });
+
+    await files.forget(INFO_HASH);
+    assert.equal(files.find(INFO_HASH, 1), null);
+    assert.ok(files.find(other, 1), "another torrent's file went with it");
+  } finally {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});